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>
2026-07-11 11:05:56 +09:00
parent 6549ead309
commit c24165b8bc
6193 changed files with 1717 additions and 31 deletions
@@ -0,0 +1,196 @@
+---
+id: wiki-2026-0508-improvisation
+title: Improvisation
+category: 10_Wiki/Topics
+status: verified
+canonical_id: self
+aliases: [Improv, Adaptive Response, Spontaneous Decision-Making]
+duplicate_of: none
+source_trust_level: B
+confidence_score: 0.85
+verification_status: applied
+tags: [meta, decision-making, agentic, exploration]
+raw_sources: []
+last_reinforced: 2026-05-10
+github_commit: pending
+tech_stack:
+  language: python
+  framework: general
+---
+
+# Improvisation
+
+## 매 한 줄
+> **"매 plan 의 die 매 first contact, 매 improv 매 take over"**. Improvisation 매 real-time adaptive decision-making 매 incomplete information 매 unfolding situation. 2026 LLM agents 매 nontrivial improv capability 의 exhibit — 매 tool failure / unexpected output 의 recover 가능.
+
+## 매 핵심
+
+### 매 Components of improv
+- **Situation awareness**: 매 current state 의 fast read.
+- **Repertoire**: 매 prelearned moves / patterns.
+- **Risk gauge**: 매 reversible vs irreversible 의 distinguish.
+- **Commitment**: 매 hesitation 의 X — 매 decide 의 act.
+
+### 매 Plan vs Improv spectrum
+- **Pure plan**: scripted, deterministic, fragile.
+- **Plan + improv**: skeleton plan + adaptive details (best for most tasks).
+- **Pure improv**: jazz solo, emergency response.
+- 매 majority production system 매 plan-with-improv-edges.
+
+### 매 LLM agent improvisation
+- 매 tool returns unexpected error → reformulate vs fail.
+- 매 user gives ambiguous instruction → ask vs guess vs proceed.
+- 매 token budget 매 exhaust → compress vs truncate vs delegate.
+
+### 매 응용
+1. Incident response (production outage).
+2. Live coding session (pair programming).
+3. LLM agent error recovery.
+4. Customer support edge cases.
+
+## 💻 패턴
+
+### Pattern 1: Repertoire of moves
+```python
+from typing import Callable
+
+class ImprovKit:
+    """매 prelearned moves — 매 situation 의 match 의 dispatch."""
+    def __init__(self):
+        self.moves: dict[str, Callable] = {}
+
+    def register(self, situation: str, move: Callable):
+        self.moves[situation] = move
+
+    def respond(self, context: dict):
+        for situation, move in self.moves.items():
+            if matches(situation, context):
+                return move(context)
+        return self.default_move(context)
+
+    def default_move(self, context):
+        return {"action": "ask_for_clarification"}
+```
+
+### Pattern 2: Reversibility check before commit
+```python
+def is_reversible(action: dict) -> bool:
+    irreversible = {"delete_file", "send_email", "db_drop", "git_push_force"}
+    return action["type"] not in irreversible
+
+def improv_decide(action: dict, confidence: float) -> str:
+    if is_reversible(action):
+        return "act"  # 매 try 의 cheap
+    if confidence > 0.95:
+        return "act"
+    return "pause_and_verify"
+```
+
+### Pattern 3: LLM error recovery loop
+```python
+def call_with_improv(client, prompt: str, max_retries: int = 3):
+    history = [{"role": "user", "content": prompt}]
+    for attempt in range(max_retries):
+        try:
+            return client.messages.create(
+                model="claude-opus-4-7",
+                max_tokens=2000,
+                messages=history,
+            )
+        except RateLimitError:
+            time.sleep(2 ** attempt)
+        except OverloadedError:
+            # 매 fallback 매 smaller model
+            return client.messages.create(
+                model="claude-haiku-4-7",
+                max_tokens=2000,
+                messages=history,
+            )
+        except Exception as e:
+            history.append({
+                "role": "user",
+                "content": f"Previous attempt errored: {e}. Try a different approach.",
+            })
+    raise RuntimeError("매 improv 의 exhaust")
+```
+
+### Pattern 4: Yes-and (improv principle)
+```python
+def yes_and(user_input: str, context: dict) -> str:
+    """매 improv 'Yes, and' — accept premise, build on it."""
+    return f"Acknowledged: {user_input}. Building on this: {extend(user_input, context)}."
+
+# 매 LLM system prompt 의 embed:
+SYSTEM = """매 user 매 partial information 의 give. 매 yes-and 의 follow:
+1. Accept what they said as fact (yes).
+2. Add useful structure (and).
+3. Avoid 'no, that's wrong' unless 매 hard contradiction."""
+```
+
+### Pattern 5: Bounded improv (safety rail)
+```python
+class BoundedImprov:
+    def __init__(self, max_actions: int = 5, allowed_ops: set = None):
+        self.max_actions = max_actions
+        self.allowed_ops = allowed_ops or {"read", "search", "summarize"}
+        self.actions_taken = 0
+
+    def attempt(self, op: str, *args):
+        if self.actions_taken >= self.max_actions:
+            raise RuntimeError("매 budget exceed — escalate 의 human")
+        if op not in self.allowed_ops:
+            raise PermissionError(f"매 {op} 매 not in improv allowlist")
+        self.actions_taken += 1
+        return execute(op, *args)
+```
+
+### Pattern 6: Postmortem of improv
+```python
+def improv_log_entry(situation: str, move: str, outcome: str) -> dict:
+    return {
+        "ts": time.time(),
+        "situation": situation,
+        "move_chosen": move,
+        "outcome": outcome,
+        "would_repeat": outcome in ("success", "partial_success"),
+        "alternatives_considered": [],
+    }
+
+# 매 weekly review 매 add successful patterns 의 ImprovKit.
+```
+
+## 매 결정 기준
+| 상황 | Approach |
+|---|---|
+| Reversible action, < 1min | Pure improv. |
+| Irreversible, high stakes | Plan first — improv 의 X. |
+| Ambiguous user request | Yes-and + clarifying question. |
+| LLM tool error | Bounded retry + reformulation. |
+| Production incident | Plan (runbook) + improv on edges. |
+
+**기본값**: 매 80/20 — 80% plan, 20% improv 매 unforeseen edges. 매 irreversible 매 strict plan only.
+
+## 🔗 Graph
+- 부모: [[Decision-Making]]
+- 응용: [[Pair-Programming]]
+- Adjacent: [[Risk_Management|Risk-Management]] · [[Bounded_Rationality|Bounded-Rationality]]
+
+## 🤖 LLM 활용
+**언제**: Tool error recovery, ambiguous user input handling, edge cases not covered by training data, multi-turn agent self-correction.
+**언제 X**: Compliance-critical workflow (deterministic pipeline only), safety-critical irreversible action.
+
+## ❌ 안티패턴
+- **Improv on irreversible action**: 매 prod DB drop 의 wing 의 X.
+- **No repertoire**: 매 from-scratch every situation — slow + inconsistent.
+- **No reversibility check**: 매 acted 매 then-realized too late.
+- **Ego improv**: refuse 의 ask for help — 매 stuck-but-improv-ing.
+
+## 🧪 검증 / 중복
+- Verified: Keith Johnstone "Impro" (1979), Karl Weick "Organizing for Reliability" (1987), OODA loop (Boyd).
+- 신뢰도 B (academic-soft + applied agentic literature).
+
+## 🕓 Changelog
+| 날짜 | 변경 |
+|---|---|
+| 2026-05-08 | Phase 1 |
+| 2026-05-10 | Manual cleanup — full content with LLM agent improv patterns and reversibility framework |