refactor(topics): 멀티 에이전트용 지식 재편 — _Common(공통 기본기) + Domain_* 구조

에이전트 8종(대화형/프로그래머 C·S/디자이너/설계자/기획자/QA/PD/PM)에게
[공통 기본 능력 + 롤별 Specialty] 2층으로 지식을 주입하기 위한 재분류.
문서 내용·포맷은 무수정, 폴더 이동만 (6,372개 문서 수 보존 확인).

- Topic_Programming → Domain_Programming (내부 구조 보존)
- Topic_Graphic → Domain_Design
- Topic_Business → Domain_Product
- Topic_General → Domain_General
- _Common 신설: Math(구 Topic_Math_Specialty), Reasoning(구 General/From_Thinking & Reasoning),
  Reasoning_Creativity(구 General/From_창의성), Communication(Poetic_Blog_Writing + From_writing)
- 타 도메인의 From_* 폴더는 유지 (출처 표기일 뿐, 이미 도메인에 맞게 분류된 문서)
- 빈 폴더 정리 (memory/procedures)
- 에이전트→폴더 매핑은 workspace의 .astra/agent-knowledge-map.json (9개 에이전트)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

10_Wiki/Topics/Domain_Programming/Architecture/불변성(Immutability).md

@@ -0,0 +1,157 @@
+---
+id: wiki-2026-0508-불변성-immutability
+title: 불변성 (Immutability)
+category: 10_Wiki/Topics
+status: verified
+canonical_id: self
+aliases: [Immutability, Immutable Data, Persistent Data Structures, 불변 자료구조]
+duplicate_of: none
+source_trust_level: A
+confidence_score: 0.9
+verification_status: applied
+tags: [functional-programming, concurrency, data-structures, design]
+raw_sources: []
+last_reinforced: 2026-05-10
+github_commit: pending
+tech_stack:
+  language: multi
+  framework: Immer/Immutable.js
+---
+
+# 불변성 (Immutability)
+
+## 매 한 줄
+> **"매 생성 후 의 state 의 mutate 의 X — 매 update 의 new value 의 produce."**. 매 shared mutable state 의 concurrency · reasoning · debugging hell 의 root cause — 매 immutable data 의 매 reasoning 의 local 의 keep · race 의 eliminate · 매 time-travel · undo 의 cheap. 2026 modern stack (Rust ownership, Clojure, Immer, structural sharing) 은 매 immutability 의 performance cost 의 near-zero.
+
+## 매 핵심
+
+### 매 levels
+- **Reference immutable**: 매 variable rebind X (`const x = ...`).
+- **Shallow immutable**: 매 object reference X 의 change, 매 nested mutable 가능.
+- **Deep immutable**: 매 entire tree mutable X (Object.freeze 매 recursive).
+- **Persistent**: 매 update 의 structural sharing 의 통한 efficient (HAMT, finger tree).
+
+### 매 benefits
+- **Concurrency**: 매 lock-free read · 매 race 의 X.
+- **Equality**: 매 reference equality 의 enough — `prev === next` (React memo).
+- **Time-travel**: 매 undo/redo · 매 debugging snapshot.
+- **Predictability**: 매 function 의 input 의 mutate X — 매 reason 의 local.
+
+### 매 응용
+1. 매 React/Redux state — 매 immutable update 의 re-render 의 cheap detect.
+2. 매 Event sourcing — 매 event log immutable.
+3. 매 functional core, imperative shell pattern.
+
+## 💻 패턴
+
+### JavaScript — Object spread (shallow)
+```javascript
+const user = { name: "Ada", age: 30 };
+const older = { ...user, age: 31 };  // user 의 unchanged
+```
+
+### Immer — mutable syntax, immutable result
+```javascript
+import { produce } from "immer";
+
+const next = produce(state, draft => {
+  draft.users[0].name = "Ada";   // 매 draft 의 freely mutate
+  draft.todos.push({ text: "x" });
+});
+// next 매 new immutable, state 매 unchanged
+```
+
+### Rust — ownership + immutable by default
+```rust
+let v = vec![1, 2, 3];          // immutable
+let mut w = v.clone();          // explicit mut
+w.push(4);
+// fn 매 borrow as &T 의 read-only access
+fn sum(xs: &[i32]) -> i32 { xs.iter().sum() }
+```
+
+### Clojure — persistent data structures
+```clojure
+(def m {:a 1 :b 2})
+(def m2 (assoc m :c 3))   ; 매 m unchanged, structural sharing
+(= (get m :c) nil)         ; true
+```
+
+### Python — frozen dataclass
+```python
+from dataclasses import dataclass, replace
+
+@dataclass(frozen=True)
+class User:
+    id: int
+    name: str
+
+u1 = User(1, "Ada")
+u2 = replace(u1, name="Grace")  # 매 new instance
+```
+
+### Immutable.js (Map / List)
+```javascript
+import { Map } from "immutable";
+const m = Map({ a: 1, b: 2 });
+const m2 = m.set("c", 3);  // structural sharing
+```
+
+### Event sourcing — append-only
+```typescript
+interface Event { type: string; payload: any; ts: number; }
+class Aggregate {
+  private events: readonly Event[] = [];
+  apply(e: Event) { return new Aggregate([...this.events, e]); }
+  state() { return this.events.reduce(reducer, initial); }
+}
+```
+
+### React — useState 의 immutable update
+```typescript
+const [todos, setTodos] = useState<Todo[]>([]);
+// add
+setTodos(prev => [...prev, newTodo]);
+// update by id
+setTodos(prev => prev.map(t => t.id === id ? { ...t, done: true } : t));
+// remove
+setTodos(prev => prev.filter(t => t.id !== id));
+```
+
+## 매 결정 기준
+| 상황 | Approach |
+|---|---|
+| 매 React/Redux state | Immer or spread |
+| 매 hot path mutation (10M+/s) | Mutable + 매 boundary 에서 freeze |
+| 매 deeply nested update | Immer (productivity > raw perf) |
+| 매 multi-thread shared | Persistent + lock-free read |
+| 매 audit/compliance | Event sourcing — append-only log |
+
+**기본값**: 매 default immutable, 매 measured hotspot 의 mutable optimize.
+
+## 🔗 Graph
+- 부모: [[Functional_Programming]]
+- 변형: [[Persistent_Data_Structures]]
+- 응용: [[Event Sourcing Pattern|Event_Sourcing]] · [[프론트엔드 및 UIUX 표준|Redux]]
+- Adjacent: [[Referential_Transparency]] · [[Concurrency]]
+
+## 🤖 LLM 활용
+**언제**: 매 mutation bug 의 hunt — 매 trace where state 의 escape, 매 immutable refactor 의 propose.
+**언제 X**: 매 raw numeric kernel · 매 GPU buffer — 매 in-place 의 unavoidable.
+
+## ❌ 안티패턴
+- **Shallow freeze**: `Object.freeze(x)` 매 nested 의 still mutable — 매 deep freeze 의 필요.
+- **Mutating in reducer**: Redux `state.x = 1` — 매 silent bug, 매 detect 의 hard.
+- **Copy 의 매 op**: 매 deep clone 매 every update — 매 structural sharing 의 use.
+- **Frozen 의 mutate 의 try**: strict mode 매 throw — 매 silent fail 의 X.
+- **Immutable 의 cargo cult**: 매 single-threaded local var 의 over-immutable — 매 noise.
+
+## 🧪 검증 / 중복
+- Verified (Okasaki *Purely Functional Data Structures*; Immer docs; Rust Book ch4).
+- 신뢰도 A.
+
+## 🕓 Changelog
+| 날짜 | 변경 |
+|---|---|
+| 2026-05-08 | Phase 1 |
+| 2026-05-10 | Manual cleanup — levels, persistent structures, language patterns |