@yuaone/core 0.9.7 → 0.9.9

package/dist/agent-loop.js

@@ -9,17 +9,7 @@
 import { EventEmitter } from "node:events";
 import { randomUUID } from "node:crypto";
 import { execSync } from "node:child_process";
-import { appendFileSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
 import { basename, join as pathJoin } from "node:path";
-function debugLog(msg) {
-    try {
-        const dir = `${homedir()}/.yuan/logs`;
-        mkdirSync(dir, { recursive: true });
-        appendFileSync(`${dir}/debug.log`, `[${new Date().toISOString()}] ${msg}\n`);
-    }
-    catch { /* silent */ }
-}
 import { BYOKClient } from "./llm-client.js";
 import { Governor } from "./governor.js";
 import { ContextManager } from "./context-manager.js";
@@ -31,7 +21,6 @@ import { InterruptManager } from "./interrupt-manager.js";
 import { YuanMemory } from "./memory.js";
 import { MemoryManager } from "./memory-manager.js";
 import { buildSystemPrompt } from "./system-prompt.js";
-import { StrategySelector } from "./strategy-selector.js";
 import { HierarchicalPlanner, } from "./hierarchical-planner.js";
 import { TaskClassifier } from "./task-classifier.js";
 import { PromptDefense } from "./prompt-defense.js";
@@ -40,6 +29,7 @@ import { TokenBudgetManager } from "./token-budget.js";
 import { ContinuationEngine } from "./continuation-engine.js";
 import { MemoryUpdater } from "./memory-updater.js";
 import { MCPClient } from "./mcp-client.js";
+import { BOUNDS, cap } from "./safe-bounds.js";
 import { WorldStateCollector } from "./world-state.js";
 import { FailureRecovery } from "./failure-recovery.js";
 import { ExecutionPolicyEngine } from "./execution-policy-engine.js";
@@ -65,10 +55,27 @@ import { ContextBudgetManager } from "./context-budget.js";
 import { QAPipeline } from "./qa-pipeline.js";
 import { PersonaManager } from "./persona.js";
 import { InMemoryVectorStore, OllamaEmbeddingProvider } from "./vector-store.js";
+import { OverheadGovernor } from "./overhead-governor.js";
 import { StateStore, TransitionModel, SimulationEngine, StateUpdater, } from "./world-model/index.js";
 import { MilestoneChecker, RiskEstimator, PlanEvaluator, ReplanningEngine, } from "./planner/index.js";
-import { SandboxManager } from "./sandbox-tiers.js";
-import { SecurityScanner } from "./security-scanner.js";
+import { TraceRecorder } from "./trace-recorder.js";
+import { ArchSummarizer } from "./arch-summarizer.js";
+import { FailureSignatureMemory } from "./failure-signature-memory.js";
+import { PlaybookLibrary } from "./playbook-library.js";
+import { ProjectExecutive } from "./project-executive.js";
+import { StallDetector } from "./stall-detector.js";
+import { SelfImprovementLoop } from "./self-improvement-loop.js";
+import { MetaLearningCollector } from "./meta-learning-collector.js";
+import { TrustEconomics } from "./trust-economics.js";
+import { StrategyLearner } from "./strategy-learner.js";
+import { SkillRegistry } from "./skill-registry.js";
+import { TracePatternExtractor } from "./trace-pattern-extractor.js";
+import { MetaLearningEngine } from "./meta-learning-engine.js";
+import { ToolSynthesizer } from "./tool-synthesizer.js";
+import { BudgetGovernorV2 } from "./budget-governor-v2.js";
+import { CapabilityGraph } from "./capability-graph.js";
+import { CapabilitySelfModel } from "./capability-self-model.js";
+import { StrategyMarket } from "./strategy-market.js";
 /**
  * AgentLoop — YUAN 에이전트의 핵심 실행 루프.
  *
@@ -98,87 +105,6 @@ import { SecurityScanner } from "./security-scanner.js";
  */
 /** Minimum confidence for classification-based hints/routing to activate */
 const CLASSIFICATION_CONFIDENCE_THRESHOLD = 0.6;
-// ─── Security Table Formatter ─────────────────────────────────────────────────
-/**
- * Renders SecurityScanner findings as a box-drawn terminal table with ANSI colors.
- *
- *   ⚠ Security Scan · src/app.ts
- *   ┌────────────┬─────────┬──────────────────────────────────┐
- *   │ Severity   │  Count  │ Rules                            │
- *   ├────────────┼─────────┼──────────────────────────────────┤
- *   │ CRITICAL   │    1    │ hardcoded-secret                 │
- *   │ HIGH       │    2    │ sql-injection, xss-reflected     │
- *   │ MEDIUM     │    0    │ —                                │
- *   │ LOW        │    1    │ weak-hash                        │
- *   └────────────┴─────────┴──────────────────────────────────┘
- */
-function formatSecurityTable(findings, filePath) {
-    // ANSI
-    const R = "\x1b[0m";
-    const BOLD = "\x1b[1m";
-    const DIM = "\x1b[2m";
-    const RED = "\x1b[1;31m";
-    const YEL = "\x1b[33m";
-    const CYN = "\x1b[36m";
-    const GRN = "\x1b[32m";
-    const WHT = "\x1b[1;37m";
-    // Aggregate
-    const counts = { critical: 0, high: 0, medium: 0, low: 0 };
-    const ruleMap = { critical: [], high: [], medium: [], low: [] };
-    for (const f of findings) {
-        const sev = f.severity.toLowerCase();
-        if (sev in counts) {
-            counts[sev]++;
-            if (sev in ruleMap && !ruleMap[sev].includes(f.rule))
-                ruleMap[sev].push(f.rule);
-        }
-    }
-    const totalBad = counts.critical + counts.high;
-    // Column widths (content only, borders + spaces added separately)
-    const C1 = 10; // severity label
-    const C2 = 7; // count
-    const C3 = 34; // rules
-    const h = "─";
-    const v = "│";
-    const tl = "┌";
-    const tr = "┐";
-    const bl = "└";
-    const br = "┘";
-    const lm = "├";
-    const rm = "┤";
-    const tm = "┬";
-    const bm = "┴";
-    const x = "┼";
-    const divider = (L, M, Ri) => `${L}${h.repeat(C1 + 2)}${M}${h.repeat(C2 + 2)}${M}${h.repeat(C3 + 2)}${Ri}`;
-    const row = (label, color, count, rules) => {
-        const rulesStr = rules.length > 0 ? rules.join(", ") : "—";
-        const col1 = label.padEnd(C1);
-        const col2 = String(count).padStart(3).padEnd(C2);
-        const col3 = (rulesStr.length > C3 ? rulesStr.slice(0, C3 - 1) + "…" : rulesStr).padEnd(C3);
-        const c = count > 0 ? color : DIM;
-        return `${v} ${c}${col1}${R} ${v} ${c}${col2}${R} ${v} ${c}${col3}${R} ${v}`;
-    };
-    const headerCol1 = "Severity".padEnd(C1);
-    const headerCol2 = "Count".padEnd(C2);
-    const headerCol3 = "Rules".padEnd(C3);
-    const header = `${v} ${WHT}${headerCol1}${R} ${v} ${WHT}${headerCol2}${R} ${v} ${WHT}${headerCol3}${R} ${v}`;
-    const shortPath = filePath.length > 44 ? "…" + filePath.slice(-43) : filePath;
-    const icon = totalBad > 0 ? `${YEL}⚠${R}` : `${GRN}✓${R}`;
-    return [
-        "",
-        `${icon}  ${BOLD}Security Scan${R}  ${DIM}·  ${shortPath}${R}`,
-        "",
-        divider(tl, tm, tr),
-        header,
-        divider(lm, x, rm),
-        row("CRITICAL", RED, counts.critical, ruleMap.critical),
-        row("HIGH", YEL, counts.high, ruleMap.high),
-        row("MEDIUM", CYN, counts.medium, ruleMap.medium),
-        row("LOW", DIM, counts.low, ruleMap.low),
-        divider(bl, bm, br),
-        "",
-    ].join("\n");
-}
 export class AgentLoop extends EventEmitter {
     abortSignal;
     llmClient;
@@ -206,10 +132,7 @@ export class AgentLoop extends EventEmitter {
     _lastInjectedTaskIndex = -1; // track when plan progress was last injected
     changedFiles = [];
     aborted = false;
-    fastInitialized = false;
-    slowInitDone = false;
-    slowInitPromise = null;
-    _slowInitContext = {};
+    initialized = false;
     continuationEngine = null;
     mcpClient = null;
     mcpToolDefinitions = [];
@@ -240,8 +163,6 @@ export class AgentLoop extends EventEmitter {
     skillLearner = null;
     repoGraph = null;
     backgroundAgentManager = null;
-    sandbox = null;
-    securityScanner = null;
     sessionPersistence = null;
     sessionId = null;
     enableToolPlanning;
@@ -249,9 +170,6 @@ export class AgentLoop extends EventEmitter {
     enableBackgroundAgents;
     currentToolPlan = null;
     executedToolNames = [];
-    currentTaskType = undefined;
-    strategySelector = new StrategySelector();
-    activeStrategies = [];
     /** Context Budget: max 3 active skills at once */
     activeSkillIds = [];
     static MAX_ACTIVE_SKILLS = 3;
@@ -269,6 +187,22 @@ export class AgentLoop extends EventEmitter {
     iterationTsFilesModified = [];
     /** Task 3: Whether tsc was run in the previous iteration (skip cooldown) */
     tscRanLastIteration = false;
+    // ─── OverheadGovernor — subsystem execution policy ──────────────────────
+    overheadGovernor;
+    /** Writes since last verify ran (for QA/quickVerify trigger) */
+    writeCountSinceVerify = 0;
+    /** Current task phase (explore → implement → verify → finalize) */
+    taskPhase = "explore";
+    /** Per-iteration: verify already ran this iteration (single-flight guard) */
+    verifyRanThisIteration = false;
+    /** Per-iteration: summarize already ran this iteration */
+    summarizeRanThisIteration = false;
+    /** Per-iteration: llmFixer run count */
+    llmFixerRunCount = 0;
+    /** Repeated error signature (same error string seen 2+ times) */
+    repeatedErrorSignature = undefined;
+    _lastErrorSignature = undefined;
+    _errorSignatureCount = 0;
     /** PersonaManager — learns user communication style, injects persona into system prompt */
     personaManager = null;
     /** InMemoryVectorStore — RAG: semantic code context retrieval for relevant snippets */
@@ -297,6 +231,28 @@ export class AgentLoop extends EventEmitter {
     reasoningAggregator = new ReasoningAggregator();
     reasoningTree = new ReasoningTree();
     resumedFromSession = false;
+    traceRecorder = null;
+    archSummarizer = null;
+    failureSigMemory = null;
+    playbookLibrary = null;
+    projectExecutive = null;
+    stallDetector = null;
+    selfImprovementLoop = null;
+    metaLearningCollector = null;
+    trustEconomics = null;
+    // Phase 5: Strategy Learner + Skill Registry
+    strategyLearner = null;
+    skillRegistry = null;
+    // Phase 5 extended: TracePatternExtractor, MetaLearningEngine, ToolSynthesizer
+    tracePatternExtractor = null;
+    metaLearningEngine = null;
+    toolSynthesizer = null;
+    // Phase 6: BudgetGovernorV2, CapabilityGraph, CapabilitySelfModel, StrategyMarket
+    budgetGovernorV2 = null;
+    capabilityGraph = null;
+    capabilitySelfModel = null;
+    strategyMarket = null;
+    sessionRunCount = 0;
     /**
      * Restore AgentLoop state from persisted session (yuan resume)
      */
@@ -360,7 +316,7 @@ export class AgentLoop extends EventEmitter {
         this.abortSignal = options.abortSignal;
         this.enableMemory = options.enableMemory !== false;
         this.enablePlanning = options.enablePlanning !== false;
-        this.planningThreshold = options.planningThreshold ?? "complex";
+        this.planningThreshold = options.planningThreshold ?? "moderate";
         this.environment = options.environment;
         this.enableSelfReflection = options.enableSelfReflection !== false;
         this.enableDebate = options.enableDebate !== false;
@@ -368,6 +324,11 @@ export class AgentLoop extends EventEmitter {
         this.llmClient = new BYOKClient(options.config.byok);
         // Governor 생성
         this.governor = new Governor(options.governorConfig);
+        // OverheadGovernor — subsystem execution policy
+        this.overheadGovernor = new OverheadGovernor(options.overheadGovernorConfig, (subsystem, reason) => {
+            // Shadow log — emit as thinking event so TUI can see it (dimmed)
+            this.emitEvent({ kind: "agent:thinking", content: `[shadow] ${subsystem}: ${reason}` });
+        });
         // ContextManager 생성
         this.contextManager = new ContextManager({
             maxContextTokens: options.contextConfig?.maxContextTokens ??
@@ -407,18 +368,6 @@ export class AgentLoop extends EventEmitter {
         this.enableToolPlanning = options.enableToolPlanning !== false;
         this.enableSkillLearning = options.enableSkillLearning !== false;
         this.enableBackgroundAgents = options.enableBackgroundAgents === true;
-        // SandboxManager — preflight guard (auto-instantiated from projectPath)
-        const sandboxProject = options.sandboxConfig?.projectPath ?? options.config.loop.projectPath;
-        if (sandboxProject) {
-            this.sandbox = new SandboxManager({
-                projectPath: sandboxProject,
-                ...(options.sandboxConfig ?? {}),
-            });
-        }
-        // SecurityScanner — postflight guard (opt-in)
-        if (options.enableSecurityScan && sandboxProject) {
-            this.securityScanner = new SecurityScanner({ projectPath: sandboxProject });
-        }
         // 시스템 프롬프트 추가 (메모리 없이 기본 프롬프트로 시작, init()에서 갱신)
         this.contextManager.addMessage({
             role: "system",
@@ -426,45 +375,21 @@ export class AgentLoop extends EventEmitter {
         });
     }
     /**
-     * Fast init — runs synchronously before LLM call (< 50ms).
-     * Sets up ContextBudgetManager and a minimal system prompt.
-     * Idempotent: subsequent calls are no-ops.
+     * Memory와 프로젝트 컨텍스트를 로드하여 시스템 프롬프트를 갱신.
+     * run() 호출 전에 한 번 호출하면 메모리가 자동으로 주입된다.
+     * 이미 초기화되었으면 스킵.
      */
-    async fastInit() {
-        if (this.fastInitialized)
+    async init() {
+        if (this.initialized)
             return;
-        this.fastInitialized = true;
-        // ContextBudgetManager must be ready before any LLM call
+        this.initialized = true;
+        // Task 1: Initialize ContextBudgetManager with the total token budget
         this.contextBudgetManager = new ContextBudgetManager({
             totalBudget: this.config.loop.totalTokenBudget,
             enableSummarization: true,
-            summarizationThreshold: 0.60,
+            summarizationThreshold: 0.60, // trigger summarize() at 60% (before ContextCompressor at 70%)
         });
         const projectPath = this.config.loop.projectPath;
-        if (!projectPath)
-            return;
-        // Minimal system prompt — no project structure yet (slowInit provides it later)
-        const basicPrompt = buildSystemPrompt({
-            projectStructure: undefined,
-            yuanMdContent: undefined,
-            tools: [...this.config.loop.tools],
-            projectPath,
-            environment: this.environment,
-            model: this.config.byok.model,
-        });
-        this.contextManager.replaceSystemMessage(basicPrompt);
-        debugLog("[fastInit] done — LLM ready");
-    }
-    /**
-     * Slow init — background fire-and-forget.
-     * Loads memory, world state, MCP, etc. and enriches system prompt for next turn.
-     * Idempotent: subsequent calls are no-ops.
-     */
-    async slowInit() {
-        if (this.slowInitDone)
-            return;
-        this.slowInitDone = true;
-        const projectPath = this.config.loop.projectPath;
         if (!projectPath)
             return;
         // Session persistence init
@@ -474,47 +399,12 @@ export class AgentLoop extends EventEmitter {
         catch {
             this.sessionPersistence = null;
         }
-        // Session save (moved from run() into slowInit)
-        if (this.sessionPersistence) {
-            try {
-                if (!this.sessionId) {
-                    this.sessionId = randomUUID();
-                }
-                const nowIso = new Date().toISOString();
-                const snapshot = {
-                    id: this.sessionId,
-                    createdAt: nowIso,
-                    updatedAt: nowIso,
-                    workDir: projectPath,
-                    provider: String(this.config.byok.provider ?? "unknown"),
-                    model: String(this.config.byok.model ?? "unknown"),
-                    status: "running",
-                    iteration: this.iterationCount,
-                    tokenUsage: {
-                        input: this.tokenUsage.input,
-                        output: this.tokenUsage.output,
-                    },
-                    messageCount: this.contextManager.getMessages().length,
-                };
-                await this.sessionPersistence.save(this.sessionId, {
-                    snapshot,
-                    messages: this.contextManager.getMessages(),
-                    plan: this.activePlan,
-                    changedFiles: [],
-                });
-            }
-            catch {
-                // Session save failure is non-fatal
-            }
-        }
         let yuanMdContent;
         let projectStructure;
-        debugLog("[slowInit] start");
         // Memory 로드
         if (this.enableMemory) {
             try {
                 // YUAN.md (raw markdown)
-                debugLog("[slowInit] yuanMemory.load start");
                 this.yuanMemory = new YuanMemory(projectPath);
                 const memData = await this.yuanMemory.load();
                 if (memData) {
@@ -544,20 +434,8 @@ export class AgentLoop extends EventEmitter {
                     const indexer = new CodeIndexer({});
                     indexer.indexProject(projectPath, vectorStoreRef).catch(() => { });
                 }).catch(() => { });
-                // 프로젝트 구조 분석 (5초 타임아웃)
-                debugLog("[slowInit] analyzeProject start");
-                const analyzeTimeout = new Promise((_, reject) => setTimeout(() => reject(new Error("analyzeProject timeout")), 15000));
-                projectStructure = await Promise.race([
-                    this.yuanMemory.analyzeProject(),
-                    analyzeTimeout,
-                ]).catch((e) => {
-                    debugLog(`[slowInit] analyzeProject skipped: ${String(e)}`);
-                    return undefined;
-                });
-                debugLog("[slowInit] analyzeProject done");
-                // Store for enriched system prompt at end of slowInit
-                this._slowInitContext.yuanMdContent = yuanMdContent;
-                this._slowInitContext.projectStructure = projectStructure;
+                // 프로젝트 구조 분석
+                projectStructure = await this.yuanMemory.analyzeProject();
             }
             catch (memErr) {
                 // 메모리 로드 실패는 치명적이지 않음 — 경고만 출력
@@ -584,7 +462,6 @@ export class AgentLoop extends EventEmitter {
         catch {
             // 정책 로드 실패 → 기본값 사용
         }
-        debugLog("[slowInit] worldState.collect start");
         // WorldState 수집 → system prompt에 주입
         try {
             const worldStateCollector = new WorldStateCollector({
@@ -593,11 +470,9 @@ export class AgentLoop extends EventEmitter {
                 skipTest: true,
             });
             this.worldState = await worldStateCollector.collect();
-            this._slowInitContext.worldState = this.worldState ?? undefined;
-            debugLog("[slowInit] worldState.collect done");
         }
-        catch (e) {
-            debugLog(`[slowInit] worldState.collect ERROR: ${String(e)}`);
+        catch {
+            // WorldState 수집 실패는 치명적이지 않음
         }
         // Initialize World Model
         if (this.worldState && projectPath) {
@@ -625,13 +500,11 @@ export class AgentLoop extends EventEmitter {
         catch {
             // Not a git repo or git unavailable — FailureRecovery will use file-level rollback only
         }
-        debugLog("[slowInit] continuationEngine + MCP start");
         // ImpactAnalyzer 생성
         this.impactAnalyzer = new ImpactAnalyzer({ projectPath });
         // ContinuationEngine 생성
         this.continuationEngine = new ContinuationEngine({ projectPath });
         // 이전 세션 체크포인트 복원
-        debugLog("[slowInit] checkpoint restore start");
         try {
             const latestCheckpoint = await this.continuationEngine.findLatestCheckpoint();
             if (latestCheckpoint) {
@@ -647,9 +520,7 @@ export class AgentLoop extends EventEmitter {
         catch {
             // 체크포인트 복원 실패는 치명적이지 않음
         }
-        debugLog("[slowInit] checkpoint restore done");
         // MCP 클라이언트 연결
-        debugLog("[slowInit] MCP connect start");
         if (this.mcpServerConfigs.length > 0) {
             try {
                 this.mcpClient = new MCPClient({
@@ -664,7 +535,6 @@ export class AgentLoop extends EventEmitter {
                 this.mcpToolDefinitions = [];
             }
         }
-        debugLog("[slowInit] MCP connect done");
         // ReflexionEngine 생성
         if (projectPath) {
             this.reflexionEngine = new ReflexionEngine({ projectPath });
@@ -703,6 +573,22 @@ export class AgentLoop extends EventEmitter {
                 totalTokenBudget: Math.floor(this.config.loop.totalTokenBudget * 0.3),
             });
         }
+        // 향상된 시스템 프롬프트 생성
+        const enhancedPrompt = buildSystemPrompt({
+            projectStructure,
+            yuanMdContent,
+            tools: [...this.config.loop.tools, ...this.mcpToolDefinitions],
+            projectPath,
+            environment: this.environment,
+        });
+        // WorldState를 시스템 프롬프트에 추가
+        let worldStateSection = "";
+        if (this.worldState) {
+            const collector = new WorldStateCollector({ projectPath });
+            worldStateSection = "\n\n" + collector.formatForPrompt(this.worldState);
+        }
+        // 기존 시스템 메시지를 향상된 프롬프트로 교체
+        this.contextManager.replaceSystemMessage(enhancedPrompt + worldStateSection);
         // MemoryManager의 관련 학습/경고를 추가 컨텍스트로 주입
         if (this.memoryManager) {
             const memory = this.memoryManager.getMemory();
@@ -717,7 +603,6 @@ export class AgentLoop extends EventEmitter {
             }
         }
         // SkillLearner 초기화 (경험에서 학습된 스킬 자동 로드)
-        debugLog("[slowInit] skillLearner init start");
         if (this.enableSkillLearning && projectPath) {
             try {
                 this.skillLearner = new SkillLearner(projectPath);
@@ -727,10 +612,67 @@ export class AgentLoop extends EventEmitter {
                 this.skillLearner = null;
             }
         }
-        debugLog("[slowInit] skillLearner init done");
+        // Phase 4: FailureSignatureMemory, PlaybookLibrary, ProjectExecutive, StallDetector
+        if (projectPath) {
+            try {
+                this.failureSigMemory = new FailureSignatureMemory({ projectPath });
+                this.playbookLibrary = new PlaybookLibrary();
+                this.projectExecutive = new ProjectExecutive(projectPath);
+                // Estimated iterations from config or default 20
+                const estimatedIter = this.config.loop.maxIterations ?? 20;
+                this.stallDetector = new StallDetector(estimatedIter);
+                // Forward project executive events
+                this.projectExecutive.on("event", (ev) => this.emitEvent(ev));
+                // Phase 4 remaining: SelfImprovementLoop, MetaLearningCollector, TrustEconomics
+                this.selfImprovementLoop = new SelfImprovementLoop({ projectPath });
+                this.metaLearningCollector = new MetaLearningCollector({ projectPath });
+                this.trustEconomics = new TrustEconomics({ projectPath });
+            }
+            catch {
+                // Phase 4 init failure is non-fatal
+            }
+        }
+        // Phase 5: StrategyLearner + SkillRegistry
+        try {
+            this.strategyLearner = new StrategyLearner();
+            this.skillRegistry = new SkillRegistry();
+            // Forward Phase 5 events
+            this.strategyLearner.on("event", (ev) => this.emitEvent(ev));
+            this.skillRegistry.on("event", (ev) => this.emitEvent(ev));
+        }
+        catch {
+            // Phase 5 init failure is non-fatal
+        }
+        // Phase 5 extended: TracePatternExtractor, MetaLearningEngine, ToolSynthesizer
+        try {
+            this.tracePatternExtractor = new TracePatternExtractor();
+            this.metaLearningEngine = new MetaLearningEngine({
+                collector: this.metaLearningCollector ?? undefined,
+                strategyLearner: this.strategyLearner ?? undefined,
+            });
+            this.toolSynthesizer = new ToolSynthesizer();
+            // Forward Phase 5 extended events
+            this.tracePatternExtractor.on("event", (ev) => this.emitEvent(ev));
+            this.metaLearningEngine.on("event", (ev) => this.emitEvent(ev));
+            this.toolSynthesizer.on("event", (ev) => this.emitEvent(ev));
+        }
+        catch {
+            // Phase 5 extended init failure is non-fatal
+        }
+        // Phase 6: BudgetGovernorV2, CapabilityGraph, CapabilitySelfModel, StrategyMarket
+        try {
+            this.budgetGovernorV2 = new BudgetGovernorV2();
+            this.capabilityGraph = new CapabilityGraph();
+            this.capabilitySelfModel = new CapabilitySelfModel();
+            this.strategyMarket = new StrategyMarket();
+            this.budgetGovernorV2.on("event", (ev) => this.emitEvent(ev));
+            this.capabilityGraph.on("event", (ev) => this.emitEvent(ev));
+            this.capabilitySelfModel.on("event", (ev) => this.emitEvent(ev));
+            this.strategyMarket.on("event", (ev) => this.emitEvent(ev));
+        }
+        catch { /* non-fatal */ }
         // HierarchicalPlanner 생성
         this.planner = new HierarchicalPlanner({ projectPath });
-        debugLog("[slowInit] planner created");
         if (this.skillLearner) {
             this.planner.setSkillLearner(this.skillLearner);
         }
@@ -880,44 +822,6 @@ export class AgentLoop extends EventEmitter {
         this.continuousReflection.on("reflection:context_overflow", () => {
             void this.handleSoftContextOverflow();
         });
-        // Enrich system prompt now that we have full context (projectStructure, yuanMd, MCP tools, worldState)
-        const enrichedPrompt = buildSystemPrompt({
-            projectStructure: this._slowInitContext.projectStructure,
-            yuanMdContent: this._slowInitContext.yuanMdContent,
-            tools: [...this.config.loop.tools, ...this.mcpToolDefinitions],
-            projectPath,
-            environment: this.environment,
-            model: this.config.byok.model,
-            // NOTE: currentTaskType is undefined on turn 1 (slowInit fires before classification).
-            // The task-type hint still reaches the LLM on turn 1 via the separate system message injection.
-            // From turn 2+ this field carries the previous turn's classification.
-            currentTaskType: this.currentTaskType,
-            experienceHints: this.buildExperienceHints(),
-            activeStrategies: this.activeStrategies.length > 0 ? this.activeStrategies : undefined,
-        });
-        let worldStateSection = "";
-        if (this.worldState) {
-            const collector = new WorldStateCollector({ projectPath, maxRecentCommits: 10, skipTest: true });
-            worldStateSection = "\n\n" + collector.formatForPrompt(this.worldState);
-        }
-        this.contextManager.replaceSystemMessage(enrichedPrompt + worldStateSection);
-        debugLog("[slowInit] DONE — context enriched for next turn");
-    }
-    /**
-     * MemoryManager.learnings에서 경험 힌트를 추출한다.
-     * confidence >= 0.4인 학습만, 최대 8개, "[category] content" 형식으로 반환.
-     */
-    buildExperienceHints() {
-        if (!this.memoryManager)
-            return [];
-        const memory = this.memoryManager.getMemory();
-        if (!memory?.learnings?.length)
-            return [];
-        return memory.learnings
-            .filter((l) => l.confidence >= 0.4)
-            .sort((a, b) => b.confidence - a.confidence)
-            .slice(0, 8)
-            .map((l) => `[${l.category}] ${l.content}`);
     }
     /**
      * MemoryManager의 학습/실패 기록을 시스템 메시지로 변환.
@@ -986,21 +890,69 @@ export class AgentLoop extends EventEmitter {
         this.costOptimizer.reset();
         this.tokenBudgetManager.reset();
         const runStartTime = Date.now();
-        // fastInit: < 50ms — sets up ContextBudgetManager + basic system prompt
-        debugLog("[run] fastInit start");
-        await this.fastInit();
-        debugLog("[run] fastInit done");
-        // slowInit: background fire-and-forget — enriches context for next turn
-        if (!this.slowInitPromise) {
-            this.slowInitPromise = this.slowInit().catch((e) => {
-                debugLog(`[slowInit] unhandled error: ${String(e)}`);
-                this.emitEvent({
-                    kind: "agent:thinking",
-                    content: `Background init failed — running with basic context: ${String(e)}`,
-                });
+        // 첫 실행 시 메모리/프로젝트 컨텍스트 자동 로드
+        await this.init();
+        if (!this.sessionId) {
+            this.sessionId = randomUUID();
+        }
+        // Phase 6: start task budget tracking
+        try {
+            this.budgetGovernorV2?.startTask(this.sessionId ?? "default");
+        }
+        catch { /* non-fatal */ }
+        // Initialize trace recorder (once per run)
+        if (!this.traceRecorder) {
+            this.traceRecorder = new TraceRecorder(this.sessionId);
+        }
+        // Initialize arch summarizer (once per run)
+        if (!this.archSummarizer && this.config.loop.projectPath) {
+            this.archSummarizer = new ArchSummarizer(this.config.loop.projectPath);
+            // Trigger refresh in background if dirty
+            this.archSummarizer.getSummary().catch(() => { });
+        }
+        // Phase 4: PlaybookLibrary — inject hint into system context based on goal
+        if (this.playbookLibrary) {
+            try {
+                const playbook = this.playbookLibrary.query(userMessage);
+                if (playbook) {
+                    this.contextManager.addMessage({
+                        role: "system",
+                        content: `[Playbook: ${playbook.taskType} v${playbook.version}] ` +
+                            `Phase order: ${playbook.phaseOrder.join(" → ")}. ` +
+                            `Stop conditions: ${playbook.stopConditions.join(", ")}. ` +
+                            `Evidence required: ${playbook.evidenceRequirements.join(", ")}.`,
+                    });
+                }
+            }
+            catch { /* non-fatal */ }
+        }
+        if (this.sessionPersistence) {
+            if (!this.sessionId) {
+                this.sessionId = randomUUID();
+            }
+            const nowIso = new Date().toISOString();
+            const snapshot = {
+                id: this.sessionId,
+                createdAt: nowIso,
+                updatedAt: nowIso,
+                workDir: this.config.loop.projectPath ?? "",
+                provider: String(this.config.byok.provider ?? "unknown"),
+                model: String(this.config.byok.model ?? "unknown"),
+                status: "running",
+                iteration: this.iterationCount,
+                tokenUsage: {
+                    input: this.tokenUsage.input,
+                    output: this.tokenUsage.output,
+                },
+                messageCount: this.contextManager.getMessages().length,
+            };
+            await this.sessionPersistence.save(this.sessionId, {
+                snapshot,
+                messages: this.contextManager.getMessages(),
+                plan: this.activePlan,
+                changedFiles: prevChangedFiles,
             });
         }
-        debugLog("[run] starting executeLoop");
         // 사용자 입력 검증 (prompt injection 방어)
         const inputValidation = this.promptDefense.validateUserInput(userMessage);
         if (inputValidation.injectionDetected && (inputValidation.severity === "critical" || inputValidation.severity === "high")) {
@@ -1088,12 +1040,6 @@ export class AgentLoop extends EventEmitter {
             }
             // Task 분류 → 시스템 프롬프트에 tool sequence hint 주입
             const classification = this.taskClassifier.classify(userMessage);
-            // Store classification type for system prompt enrichment
-            this.currentTaskType = classification.confidence >= CLASSIFICATION_CONFIDENCE_THRESHOLD
-                ? classification.type
-                : undefined;
-            // Select active strategies based on task type and execution mode
-            this.activeStrategies = this.strategySelector.select(this.currentTaskType, undefined);
             if (classification.confidence >= CLASSIFICATION_CONFIDENCE_THRESHOLD) {
                 const classificationHint = this.taskClassifier.formatForSystemPrompt(classification);
                 this.contextManager.addMessage({
@@ -1201,6 +1147,92 @@ export class AgentLoop extends EventEmitter {
             }
             // 실행 완료 후 메모리 자동 업데이트
             await this.updateMemoryAfterRun(userMessage, result, Date.now() - runStartTime);
+            // Phase 4: FailureSignatureMemory promote + PlaybookLibrary outcome recording
+            if (result.reason === "GOAL_ACHIEVED") {
+                try {
+                    if (this.failureSigMemory && this.repeatedErrorSignature) {
+                        this.failureSigMemory.promote(this.repeatedErrorSignature, "resolved", this.allToolResults.filter(r => r.success).map(r => r.name), true);
+                    }
+                    if (this.playbookLibrary) {
+                        const taskType = this.playbookLibrary.query(userMessage)?.taskType;
+                        if (taskType) {
+                            this.playbookLibrary.recordOutcome(taskType, true);
+                        }
+                    }
+                }
+                catch { /* non-fatal */ }
+            }
+            // Phase 4 remaining: SelfImprovementLoop + MetaLearningCollector + TrustEconomics
+            try {
+                const taskType = this.playbookLibrary?.query(userMessage)?.taskType ?? "unknown";
+                const toolSeq = this.allToolResults.slice(-20).map((r) => r.name);
+                const runSuccess = result.reason === "GOAL_ACHIEVED";
+                const runDurationMs = Date.now() - runStartTime;
+                if (this.selfImprovementLoop) {
+                    this.selfImprovementLoop.recordOutcome({
+                        taskType,
+                        strategy: "default",
+                        toolSequence: toolSeq,
+                        success: runSuccess,
+                        iterationsUsed: this.iterationCount,
+                        tokensUsed: this.tokenUsage.total,
+                        durationMs: runDurationMs,
+                        errorSignatures: this.repeatedErrorSignature ? [this.repeatedErrorSignature] : [],
+                    });
+                    this.selfImprovementLoop.generateProposals();
+                }
+                if (this.metaLearningCollector) {
+                    this.metaLearningCollector.record({
+                        taskType,
+                        governorPolicies: {},
+                        toolSequence: toolSeq,
+                        latencyMs: runDurationMs,
+                        tokensUsed: this.tokenUsage.total,
+                        success: runSuccess,
+                        iterationsUsed: this.iterationCount,
+                    });
+                }
+                if (this.trustEconomics) {
+                    for (const tr of this.allToolResults.slice(-20)) {
+                        const ac = toolNameToActionClass(tr.name);
+                        if (ac)
+                            this.trustEconomics.record(ac, tr.success);
+                    }
+                }
+                // Phase 5: record strategy outcome
+                if (this.strategyLearner) {
+                    const activePlaybookId = this._activePlaybookId ?? "default";
+                    if (runSuccess) {
+                        this.strategyLearner.recordSuccess(activePlaybookId, taskType, this.iterationCount, this.tokenUsage.total);
+                    }
+                    else {
+                        this.strategyLearner.recordFailure(activePlaybookId, taskType, this.iterationCount, this.tokenUsage.total);
+                    }
+                }
+                // Phase 5 extended: periodic pattern extraction (every 10 runs)
+                this.sessionRunCount += 1;
+                if (this.sessionRunCount % 10 === 0) {
+                    if (this.tracePatternExtractor) {
+                        this.tracePatternExtractor.extract().catch(() => { });
+                    }
+                    if (this.metaLearningEngine) {
+                        this.metaLearningEngine.analyze().catch(() => { });
+                    }
+                }
+                // Phase 6: record outcomes in capability self model and strategy market
+                try {
+                    const env = this._detectedEnvironment ?? "general";
+                    this.capabilitySelfModel?.recordOutcome(env, taskType, runSuccess);
+                    this.strategyMarket?.recordResult(this._activePlaybookId ?? "default", taskType, {
+                        success: runSuccess,
+                        tokenCost: this.tokenUsage?.total ?? 0,
+                        latencyMs: Date.now() - runStartTime,
+                    });
+                    this.budgetGovernorV2?.endTask(this.sessionId ?? "default");
+                }
+                catch { /* non-fatal */ }
+            }
+            catch { /* non-fatal */ }
             // SkillLearner: 성공적 에러 해결 시 새로운 스킬 학습
             if (this.skillLearner && result.reason === "GOAL_ACHIEVED") {
                 try {
@@ -1523,7 +1555,7 @@ export class AgentLoop extends EventEmitter {
         if ((complexityOrder[complexity] ?? 0) < effectiveThreshold) {
             return;
         }
-        this.emitEvent({ kind: "agent:thinking", content: `planning · ${complexity} complexity` });
+        this.emitSubagent("planner", "start", `task complexity ${complexity}. creating execution plan`);
         try {
             const plan = await this.planner.createHierarchicalPlan(userMessage, this.llmClient);
             this.activePlan = plan;
@@ -1549,7 +1581,7 @@ export class AgentLoop extends EventEmitter {
                 role: "system",
                 content: planContext,
             });
-            this.emitEvent({ kind: "agent:thinking", content: `plan ready · ${plan.tactical.length} tasks · risk ${plan.strategic.riskAssessment.level}` });
+            this.emitSubagent("planner", "done", `plan created: ${plan.tactical.length} tasks, ${plan.totalEstimatedIterations} estimated iterations, risk ${plan.strategic.riskAssessment.level}`);
         }
         catch (err) {
             this.emitEvent({
@@ -1707,8 +1739,29 @@ export class AgentLoop extends EventEmitter {
      * (ambitious short requests that keywords miss across any language).
      */
     async detectComplexity(message) {
-        // Heuristic-only — no LLM pre-call (eliminates 10s blocking delay before every response)
-        return this._detectComplexityHeuristic(message);
+        const heuristic = this._detectComplexityHeuristic(message);
+        // Clear extremes — trust heuristic, skip LLM call cost
+        if (heuristic === "trivial" || heuristic === "massive")
+            return heuristic;
+        // Borderline ambiguous range: ask LLM for one-word verdict
+        // Short cheap call: no tools, 1-word response, ~50 tokens total
+        try {
+            const resp = await this.llmClient.chat([
+                {
+                    role: "user",
+                    content: `Rate this software task complexity in ONE word only (trivial/simple/moderate/complex/massive). Task: "${message.slice(0, 300)}"`,
+                },
+            ], []);
+            const word = (resp.content ?? "").trim().toLowerCase().replace(/[^a-z]/g, "");
+            const valid = ["trivial", "simple", "moderate", "complex", "massive"];
+            if (valid.includes(word)) {
+                return word;
+            }
+        }
+        catch {
+            // LLM classification failure — fall back to heuristic
+        }
+        return heuristic;
     }
     /**
      * HierarchicalPlan을 LLM이 따라갈 수 있는 컨텍스트 메시지로 포맷.
@@ -1846,8 +1899,17 @@ export class AgentLoop extends EventEmitter {
             iteration++;
             this.iterationCount = iteration;
             const iterationStart = Date.now();
+            // Reset per-iteration governor state
+            this.verifyRanThisIteration = false;
+            this.summarizeRanThisIteration = false;
+            this.llmFixerRunCount = 0;
+            this.iterationSystemMsgCount = 0;
+            // Message pruning — cap in-memory messages to prevent OOM (GPT recommendation)
+            this.pruneMessagesIfNeeded();
+            // Cap allToolResults (prevents unbounded memory growth)
+            this.allToolResults = cap(this.allToolResults, BOUNDS.allToolResults);
+            this.allToolResultsSinceLastReplan = cap(this.allToolResultsSinceLastReplan, BOUNDS.toolResultsSinceReplan);
             this.emitReasoning(`iteration ${iteration}: preparing context`);
-            this.iterationSystemMsgCount = 0; // Reset per-iteration (prevents accumulation across iterations)
             // Proactive replanning check (every 10 iterations when plan is active)
             if (this.replanningEngine &&
                 this.activePlan &&
@@ -1906,10 +1968,11 @@ export class AgentLoop extends EventEmitter {
             // Soft context rollover:
             // checkpoint first, then let ContextManager compact instead of aborting/throwing.
             const contextUsageRatio = this.contextManager.getUsageRatio();
-            // Task 1: ContextBudgetManager LLM summarization at 60-70% — runs BEFORE ContextCompressor
-            // Summarizes old "medium" priority conversation turns into a compact summary message,
-            // freeing tokens before the heavier ContextCompressor kicks in at 70%.
-            if (contextUsageRatio >= 0.60 && contextUsageRatio < 0.70 && this.contextBudgetManager && !this._contextSummarizationDone) {
+            // Task 1: ContextBudgetManager LLM summarization — Governor gated (default SHADOW)
+            const summarizeMode = this.overheadGovernor.shouldRunSummarize(this.buildTriggerContext());
+            if (summarizeMode === "BLOCKING")
+                this.summarizeRanThisIteration = true;
+            if (contextUsageRatio >= 0.75 && this.contextBudgetManager && !this._contextSummarizationDone && summarizeMode === "BLOCKING") {
                 this._contextSummarizationDone = true; // run at most once per agent turn
                 // Non-blocking: fire-and-forget so the main iteration is not stalled
                 this.contextBudgetManager.importMessages(this.contextManager.getMessages());
@@ -2063,12 +2126,29 @@ export class AgentLoop extends EventEmitter {
             if (response.toolCalls.length === 0) {
                 const content = response.content ?? "";
                 let finalSummary = content || "Task completed.";
+                // Phase transition: implement → verify when LLM signals completion (no tool calls)
+                if (this.taskPhase === "implement" && this.changedFiles.length > 0) {
+                    this.transitionPhase("verify", "LLM completion signal (no tool calls)");
+                    // Run cheap checks — if they fail, stay in implement and continue loop
+                    const cheapOk = await this.runCheapChecks();
+                    if (cheapOk) {
+                        this.transitionPhase("finalize", "cheap checks passed");
+                    }
+                    else {
+                        // cheap checks failed — stay in implement, let LLM fix
+                        this.transitionPhase("implement", "cheap check failed, continuing");
+                        continue;
+                    }
+                }
                 const finalImpactSummary = await this.buildFinalImpactSummary();
                 if (finalImpactSummary) {
                     finalSummary = `${finalSummary}\n\n${finalImpactSummary}`;
                 }
-                // Level 2: Deep verification before declaring completion
-                if (this.selfReflection && this.changedFiles.length > 0) {
+                // Level 2: Deep verification before declaring completion — Governor gated (default OFF)
+                const deepVerifyMode = this.overheadGovernor.shouldRunDeepVerify(this.buildTriggerContext());
+                if (deepVerifyMode === "BLOCKING")
+                    this.verifyRanThisIteration = true;
+                if (this.selfReflection && this.changedFiles.length > 0 && deepVerifyMode === "BLOCKING") {
                     try {
                         const changedFilesMap = this.buildChangedFilesMap();
                         const verifyFn = async (prompt) => {
@@ -2097,10 +2177,12 @@ export class AgentLoop extends EventEmitter {
                             this.emitSubagent("verifier", "done", `deep verification failed, score ${deepResult.overallScore}. continuing to address issues`);
                             continue; // Don't return GOAL_ACHIEVED, continue the loop
                         }
-                        // Level 3: Multi-agent debate for complex/massive tasks
+                        // Level 3: Multi-agent debate — Governor gated (default OFF)
+                        const debateMode = this.overheadGovernor.shouldRunDebate(this.buildTriggerContext());
                         if (this.debateOrchestrator &&
                             ["complex", "massive"].includes(this.currentComplexity) &&
-                            deepResult.verdict !== "pass") {
+                            deepResult.verdict !== "pass" &&
+                            debateMode === "BLOCKING") {
                             try {
                                 this.emitSubagent("reviewer", "start", `starting debate for ${this.currentComplexity} task verification`);
                                 const debateContext = [
@@ -2267,7 +2349,8 @@ export class AgentLoop extends EventEmitter {
             }
             // Task 2: QAPipeline — run "quick" (structural only) after any WRITE tool call this iteration
             const projectPath = this.config.loop.projectPath;
-            if (this.iterationWriteToolPaths.length > 0 && projectPath) {
+            const qaMode = this.overheadGovernor.shouldRunQaPipeline(this.buildTriggerContext());
+            if (this.iterationWriteToolPaths.length > 0 && projectPath && qaMode !== "OFF") {
                 try {
                     const qaPipeline = new QAPipeline({
                         projectPath,
@@ -2281,21 +2364,21 @@ export class AgentLoop extends EventEmitter {
                     });
                     const qaResult = await qaPipeline.run(this.iterationWriteToolPaths);
                     this.lastQAResult = qaResult;
-                    // Surface QA issues as a system message so LLM sees them next iteration
                     const failedChecks = qaResult.stages
                         .flatMap((s) => s.checks)
                         .filter((c) => c.status === "fail" || c.status === "warn");
                     const qaIssues = failedChecks
                         .slice(0, 10)
                         .map((c) => `[${c.severity}] ${c.name}: ${c.message}`);
-                    // Emit structured qa_result event for TUI display
+                    // Always emit event for TUI display (SHADOW + BLOCKING)
                     this.emitEvent({
                         kind: "agent:qa_result",
                         stage: "quick",
                         passed: failedChecks.length === 0,
                         issues: qaIssues,
                     });
-                    if (failedChecks.length > 0 && this.iterationSystemMsgCount < 5) {
+                    // Only inject into LLM context in BLOCKING mode (SHADOW = observe only)
+                    if (qaMode === "BLOCKING" && failedChecks.length > 0 && this.iterationSystemMsgCount < 5) {
                         const checkSummary = failedChecks
                             .slice(0, 5)
                             .map((c) => `  - [${c.severity}] ${c.name}: ${c.message}`)
@@ -2313,13 +2396,31 @@ export class AgentLoop extends EventEmitter {
             }
             // Reset per-iteration write tool tracking
             this.iterationWriteToolPaths = [];
+            // Phase 4: StallDetector check (non-blocking observer)
+            if (this.stallDetector) {
+                try {
+                    const stallResult = this.stallDetector.check(this.iterationCount, this.changedFiles, this.repeatedErrorSignature);
+                    if (stallResult.stalled && stallResult.reason) {
+                        this.emitEvent({
+                            kind: "agent:task_stalled",
+                            taskId: this.sessionId ?? "unknown",
+                            stallReason: stallResult.reason,
+                            iterationsElapsed: stallResult.iterationsElapsed,
+                            estimatedIterations: this.config.loop.maxIterations ?? 20,
+                            timestamp: Date.now(),
+                        });
+                    }
+                }
+                catch { /* non-fatal */ }
+            }
             // Task 3: Auto-run tsc --noEmit after 2+ TS files modified in this iteration
             // Skip if tsc was already run in the previous iteration (cooldown)
             const tscFilesThisIteration = [...this.iterationTsFilesModified];
             this.iterationTsFilesModified = []; // reset for next iteration
             const tscRanPrev = this.tscRanLastIteration;
             this.tscRanLastIteration = false; // will set to true below if we run it
-            if (tscFilesThisIteration.length >= 2 && projectPath && !tscRanPrev) {
+            const tscMode = this.overheadGovernor.shouldRunAutoTsc(this.buildTriggerContext());
+            if (tscFilesThisIteration.length >= 2 && projectPath && !tscRanPrev && tscMode !== "OFF") {
                 try {
                     const tscResult = await this.toolExecutor.execute({
                         id: `auto-tsc-${Date.now()}`,
@@ -2331,27 +2432,28 @@ export class AgentLoop extends EventEmitter {
                         }),
                     });
                     this.tscRanLastIteration = true;
-                    // Inject TypeScript errors into context so LLM sees them next iteration
                     if (tscResult.success && tscResult.output && tscResult.output.trim().length > 0) {
                         const tscOutput = tscResult.output.trim();
-                        // Only inject if there are actual TS errors (output is non-empty)
                         const hasErrors = tscOutput.includes(": error TS") || tscOutput.includes("error TS");
-                        if (hasErrors && this.iterationSystemMsgCount < 5) {
-                            // Truncate long tsc output to avoid context bloat
-                            const truncated = tscOutput.length > 2000
-                                ? tscOutput.slice(0, 2000) + "\n[...tsc output truncated]"
-                                : tscOutput;
-                            this.contextManager.addMessage({
-                                role: "system",
-                                content: `[Auto-TSC] TypeScript errors detected after modifying ${tscFilesThisIteration.length} files:\n\`\`\`\n${truncated}\n\`\`\`\nPlease fix these type errors.`,
-                            });
-                            this.iterationSystemMsgCount++;
+                        if (hasErrors) {
+                            // Always emit thinking event (SHADOW + BLOCKING)
                             this.emitEvent({
                                 kind: "agent:thinking",
                                 content: `Auto-TSC: TypeScript errors found after editing ${tscFilesThisIteration.join(", ")}.`,
                             });
+                            // Only inject into LLM context in BLOCKING mode
+                            if (tscMode === "BLOCKING" && this.iterationSystemMsgCount < 5) {
+                                const truncated = tscOutput.length > 2000
+                                    ? tscOutput.slice(0, 2000) + "\n[...tsc output truncated]"
+                                    : tscOutput;
+                                this.contextManager.addMessage({
+                                    role: "system",
+                                    content: `[Auto-TSC] TypeScript errors detected after modifying ${tscFilesThisIteration.length} files:\n\`\`\`\n${truncated}\n\`\`\`\nPlease fix these type errors.`,
+                                });
+                                this.iterationSystemMsgCount++;
+                            }
                         }
-                        else if (!hasErrors) {
+                        else {
                             this.emitEvent({
                                 kind: "agent:thinking",
                                 content: `Auto-TSC: No type errors after editing ${tscFilesThisIteration.length} file(s).`,
@@ -2418,8 +2520,9 @@ export class AgentLoop extends EventEmitter {
                     // Reflection failure is non-fatal
                 }
             }
-            // Level 1: Quick verification after every 3rd iteration
-            if (this.selfReflection && iteration % 3 === 0) {
+            // Level 1: Quick verification — Governor gated (default SHADOW = no LLM call)
+            const quickVerifyMode = this.overheadGovernor.shouldRunQuickVerify(this.buildTriggerContext());
+            if (this.selfReflection && iteration % 3 === 0 && quickVerifyMode === "BLOCKING") {
                 try {
                     this.emitSubagent("verifier", "start", "running quick verification");
                     const changedFilesMap = this.buildChangedFilesMap();
@@ -2457,6 +2560,8 @@ export class AgentLoop extends EventEmitter {
                 const errorSummary = errorResults
                     .map((r) => `${r.name}: ${r.output}`)
                     .join("\n");
+                // Track repeated error signature for Governor
+                this.trackErrorSignature(errorSummary);
                 // FailureRecovery: 근본 원인 분석 + 전략 선택
                 const rootCause = this.failureRecovery.analyzeRootCause(errorSummary, errorResults[0]?.name);
                 const decision = this.failureRecovery.selectStrategy(rootCause, {
@@ -2501,7 +2606,8 @@ export class AgentLoop extends EventEmitter {
                     });
                     // SelfDebugLoop: merge debug strategy into recovery message (not separate system msg)
                     let debugSuffix = "";
-                    if (iteration >= 3) {
+                    const llmFixerMode = this.overheadGovernor.shouldRunLlmFixer(this.buildTriggerContext());
+                    if (iteration >= 3 && llmFixerMode === "BLOCKING") {
                         const rootCauseAnalysis = this.selfDebugLoop.analyzeError(errorSummary);
                         if (rootCauseAnalysis.confidence >= 0.5) {
                             const debugStrategy = this.selfDebugLoop.selectStrategy(iteration - 2, []);
@@ -2519,6 +2625,7 @@ export class AgentLoop extends EventEmitter {
                             debugSuffix = `\n\n[SelfDebug L${Math.min(iteration - 2, 5)}] Strategy: ${debugStrategy}\n${debugPrompt}`;
                             // Bug 2 fix: wire a real llmFixer so selfDebugLoop.debug() can call LLM
                             if (debugStrategy !== "escalate") {
+                                this.llmFixerRunCount++;
                                 this.selfDebugLoop.debug({
                                     testCommand: testCmd,
                                     errorOutput: errorSummary,
@@ -2893,35 +3000,32 @@ export class AgentLoop extends EventEmitter {
         }
         // MCP 도구 호출 확인
         if (this.mcpClient && this.isMCPTool(toolCall.name)) {
+            // Emit tool_start before execution (required for trace, QA pipeline, replay)
+            this.emitEvent({
+                kind: "agent:tool_start",
+                tool: toolCall.name,
+                input: args,
+                source: "mcp",
+            });
             const mcpResult = await this.executeMCPTool(toolCall);
+            // Normalize MCP result: wrap search tool output into structured JSON if applicable
+            const normalizedOutput = this.normalizeMcpResult(toolCall.name, mcpResult.output);
+            const finalResult = { ...mcpResult, output: normalizedOutput };
             this.emitEvent({
                 kind: "agent:tool_result",
                 tool: toolCall.name,
-                output: mcpResult.output.length > 200
-                    ? mcpResult.output.slice(0, 200) + "..."
-                    : mcpResult.output,
-                durationMs: mcpResult.durationMs,
+                output: finalResult.output.length > 200
+                    ? finalResult.output.slice(0, 200) + "..."
+                    : finalResult.output,
+                durationMs: finalResult.durationMs,
             });
             this.emitEvent({ kind: "agent:reasoning_delta", text: `tool finished: ${toolCall.name}` });
-            return { result: mcpResult, deferredFixPrompt: null };
+            return { result: finalResult, deferredFixPrompt: null };
         }
         // 도구 실행
         const startTime = Date.now();
         const toolAbort = new AbortController();
         this.interruptManager.registerToolAbort(toolAbort);
-        // Sandbox preflight — block disallowed tool calls before execution
-        if (this.sandbox) {
-            const sandboxCheck = this.sandbox.validateToolCall(toolCall.name, args);
-            if (!sandboxCheck.allowed) {
-                this.interruptManager.clearToolAbort();
-                const blocked = `[SANDBOX BLOCKED] ${sandboxCheck.violations.join("; ")}`;
-                this.emitEvent({ kind: "agent:tool_result", tool: toolCall.name, output: blocked, durationMs: 0 });
-                return {
-                    result: { tool_call_id: toolCall.id, name: toolCall.name, output: blocked, success: false, durationMs: 0 },
-                    deferredFixPrompt: null,
-                };
-            }
-        }
         if (["file_write", "file_edit"].includes(toolCall.name)) {
             const candidatePath = args.path ??
                 args.file;
@@ -2969,29 +3073,21 @@ export class AgentLoop extends EventEmitter {
             });
             this.emitReasoning(`success: ${toolCall.name}`);
             this.reasoningTree.add("tool", `success: ${toolCall.name}`);
-            // Security Scanner postflight — scan written files for vulnerabilities (opt-in)
-            if (this.securityScanner && result.success && ["file_write", "file_edit"].includes(toolCall.name)) {
-                const writtenPath = args.path ?? args.file;
-                if (typeof writtenPath === "string") {
-                    this.securityScanner.scan([writtenPath]).then((scanResult) => {
-                        // Always render table — shows ✓ when clean, ⚠ when findings exist
-                        const hasBad = scanResult.findings.some((f) => f.severity === "critical" || f.severity === "high");
-                        if (hasBad || scanResult.findings.length > 0) {
-                            this.emitEvent({
-                                kind: "agent:text_delta",
-                                text: formatSecurityTable(scanResult.findings, writtenPath),
-                            });
-                        }
-                    }).catch(() => { });
-                }
-            }
             if (["file_write", "file_edit"].includes(toolCall.name) && result.success) {
+                // Phase transition: explore → implement on first write
+                if (this.taskPhase === "explore") {
+                    this.transitionPhase("implement", `first write: ${toolCall.name}`);
+                }
                 const filePath = args.path ??
                     args.file ??
                     "unknown";
                 const filePathStr = String(filePath);
                 if (!this.changedFiles.includes(filePathStr)) {
                     this.changedFiles.push(filePathStr);
+                    // Cap changedFiles to prevent unbounded growth on massive refactors
+                    if (this.changedFiles.length > BOUNDS.changedFiles) {
+                        this.changedFiles = this.changedFiles.slice(-BOUNDS.changedFiles);
+                    }
                 }
                 // Task 2: track write tool paths per-iteration for QA triggering
                 if (!this.iterationWriteToolPaths.includes(filePathStr)) {
@@ -3002,6 +3098,8 @@ export class AgentLoop extends EventEmitter {
                     this.iterationTsFilesModified.push(filePathStr);
                 }
                 this.emitEvent({ kind: "agent:file_change", path: filePathStr, diff: result.output });
+                // Emit evidence report (async, fire-and-forget — no loop complexity added)
+                this.emitEvidenceReport(filePathStr, toolCall.name).catch(() => { });
                 // Update world state after file modification
                 if (this.config.loop.projectPath) {
                     const wsProjectPath = this.config.loop.projectPath;
@@ -3709,6 +3807,44 @@ export class AgentLoop extends EventEmitter {
         const args = this.parseToolArgs(toolCall.arguments);
         return this.mcpClient.callToolAsYuan(toolCall.name, args, toolCall.id);
     }
+    /**
+     * Normalize an MCP tool result for consistent downstream consumption.
+     *
+     * - Search tools (tool name contains "search"): if the output is unstructured text,
+     *   wrap it into a JSON array of `{ title, url, snippet, source }` objects.
+     *   Each non-empty line is treated as a snippet entry when structured data is absent.
+     * - All other tools: pass through unchanged.
+     */
+    normalizeMcpResult(toolName, output) {
+        const isSearch = /search/i.test(toolName);
+        if (!isSearch)
+            return output;
+        // If already valid JSON, leave as-is
+        try {
+            JSON.parse(output);
+            return output;
+        }
+        catch {
+            // Not JSON — wrap plain-text lines into structured objects
+        }
+        const lines = output
+            .split("\n")
+            .map((l) => l.trim())
+            .filter(Boolean);
+        if (lines.length === 0)
+            return output;
+        const structured = lines.map((line) => {
+            // Attempt to extract a URL from the line
+            const urlMatch = line.match(/https?:\/\/\S+/);
+            return {
+                title: "",
+                url: urlMatch ? urlMatch[0] : "",
+                snippet: line,
+                source: toolName,
+            };
+        });
+        return JSON.stringify(structured, null, 2);
+    }
     /**
      * ContinuousReflection overflow signal을 soft rollover로 처리한다.
      * 절대 abort하지 않고, 체크포인트 저장 후 다음 iteration에서
@@ -3738,6 +3874,7 @@ export class AgentLoop extends EventEmitter {
                 // cleanup failure ignored
             }
         }
+        this.traceRecorder?.stop();
     }
     // ─── Helpers ───
     /**
@@ -3758,6 +3895,8 @@ export class AgentLoop extends EventEmitter {
     }
     emitEvent(event) {
         this.emit("event", event);
+        // Trace recording — fire-and-forget, never blocks
+        this.traceRecorder?.record(event);
     }
     emitReasoning(content) {
         this.reasoningTree.add("reasoning", content);
@@ -3770,6 +3909,13 @@ export class AgentLoop extends EventEmitter {
     emitSubagent(name, phase, content) {
         this.reasoningTree.add(name, `[${phase}] ${content}`);
         this.emitReasoning(`[${name}:${phase}] ${content}`);
+        // Route subagent events to task panel via proper events
+        if (phase === "start") {
+            this.emitEvent({ kind: "agent:subagent_phase", taskId: name, phase: content });
+        }
+        else {
+            this.emitEvent({ kind: "agent:subagent_done", taskId: name, success: !content.includes("failed") });
+        }
     }
     handleFatalError(err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -3783,5 +3929,221 @@ export class AgentLoop extends EventEmitter {
         });
         return { reason: "ERROR", error: message };
     }
+    // ─── Task phase transitions ───────────────────────────────────────────────
+    /**
+     * Deterministic phase transition — no LLM involved.
+     * Emits agent:phase_transition event for TUI trace.
+     */
+    transitionPhase(to, trigger) {
+        if (this.taskPhase === to)
+            return;
+        const from = this.taskPhase;
+        this.taskPhase = to;
+        this.emitEvent({
+            kind: "agent:phase_transition",
+            from,
+            to,
+            iteration: this.iterationCount,
+            trigger,
+        });
+        this.emitReasoning(`phase: ${from} → ${to} (${trigger})`);
+    }
+    /**
+     * Cheap local checks run in verify phase — no LLM.
+     * Returns true if all checks pass (safe to advance to finalize).
+     */
+    async runCheapChecks() {
+        const projectPath = this.config.loop.projectPath;
+        // 1. Diff size check — if nothing changed, skip
+        if (this.changedFiles.length === 0)
+            return true;
+        // 2. File existence check — all changedFiles should exist
+        const { existsSync } = await import("node:fs");
+        for (const f of this.changedFiles) {
+            const abs = projectPath ? `${projectPath}/${f}` : f;
+            if (f.startsWith("/") ? !existsSync(f) : !existsSync(abs)) {
+                this.emitReasoning(`cheap check: file missing: ${f}`);
+                return false;
+            }
+        }
+        // 3. Fast syntax check — tsc --noEmit --skipLibCheck only on changed TS files
+        const tsFiles = this.changedFiles.filter(f => /\.[cm]?tsx?$/.test(f));
+        if (tsFiles.length > 0 && projectPath) {
+            try {
+                const result = await this.toolExecutor.execute({
+                    id: `cheap-tsc-${Date.now()}`,
+                    name: "shell_exec",
+                    arguments: JSON.stringify({
+                        command: `npx tsc --noEmit --skipLibCheck 2>&1 | head -20 || true`,
+                        cwd: projectPath,
+                        timeout: 30000,
+                    }),
+                });
+                if (result.success && result.output) {
+                    const hasErrors = result.output.includes(": error TS");
+                    if (hasErrors) {
+                        this.emitReasoning(`cheap check: tsc errors found, staying in verify`);
+                        // Inject TS errors so LLM sees them and fixes them
+                        if (this.iterationSystemMsgCount < 5) {
+                            const truncated = result.output.length > 1000
+                                ? result.output.slice(0, 1000) + "\n[truncated]"
+                                : result.output;
+                            this.contextManager.addMessage({
+                                role: "system",
+                                content: `[Verify Phase] TypeScript errors found:\n\`\`\`\n${truncated}\n\`\`\`\nPlease fix before completion.`,
+                            });
+                            this.iterationSystemMsgCount++;
+                        }
+                        return false;
+                    }
+                }
+            }
+            catch {
+                // cheap check failure is non-fatal — allow finalize
+            }
+        }
+        return true;
+    }
+    // ─── Evidence Report ───────────────────────────────────────────────────────
+    /**
+     * After a file write/edit, collect diff stats + syntax signal and emit
+     * `agent:evidence_report`. Runs async and never blocks the main loop.
+     */
+    async emitEvidenceReport(filePath, tool) {
+        const timestamp = Date.now();
+        const projectPath = this.config.loop.projectPath;
+        // 1. Diff stats via git diff --stat
+        let diffStats = null;
+        try {
+            const diffResult = await this.toolExecutor.execute({
+                id: `evidence-diff-${timestamp}`,
+                name: "shell_exec",
+                arguments: JSON.stringify({
+                    command: `git diff --numstat HEAD -- "${filePath}" 2>/dev/null || echo "0\t0\t${filePath}"`,
+                    cwd: projectPath ?? ".",
+                    timeout: 5000,
+                }),
+            });
+            if (diffResult.success && diffResult.output) {
+                const match = diffResult.output.match(/^(\d+)\s+(\d+)/m);
+                if (match) {
+                    diffStats = { added: parseInt(match[1], 10), removed: parseInt(match[2], 10) };
+                }
+            }
+        }
+        catch { /* non-fatal */ }
+        // 2. Syntax check — skipped here to avoid spawning a duplicate tsc process.
+        // runCheapChecks() already runs tsc at the implement→verify boundary and
+        // the result flows to the QA pipeline. Spawning tsc per-write would
+        // create N parallel tsc processes for bulk refactors.
+        const syntax = "skipped";
+        this.emitEvent({
+            kind: "agent:evidence_report",
+            filePath,
+            tool,
+            syntax,
+            diffStats,
+            lintResult: "skipped",
+            timestamp,
+        });
+        // If a dep-graph file changed, invalidate arch summary cache
+        const isDepsChange = filePath.includes("package.json") || filePath.includes("tsconfig");
+        if (isDepsChange && this.archSummarizer) {
+            this.archSummarizer.regenerate().catch(() => { });
+        }
+    }
+    // ─── OverheadGovernor helpers ─────────────────────────────────────────────
+    /**
+     * 현재 런타임 상태로 TriggerContext 빌드.
+     */
+    buildTriggerContext() {
+        const totalBudget = this.config.loop.totalTokenBudget;
+        return {
+            changedFiles: this.changedFiles,
+            writeCountSinceVerify: this.writeCountSinceVerify,
+            failureCount: this.allToolResults.filter(r => !r.success).length,
+            repeatedErrorSignature: this.repeatedErrorSignature,
+            plannerConfidence: undefined,
+            contextUsageRatio: totalBudget > 0 ? this.tokenUsage.total / totalBudget : 0,
+            riskyWrite: this.changedFiles.some(f => f.includes("tsconfig") || f.includes("package.json") ||
+                f.endsWith("index.ts") || f.endsWith("index.tsx") || f.includes(".d.ts")),
+            taskPhase: this.taskPhase,
+            iteration: this.iterationCount,
+            verifyRanThisIteration: this.verifyRanThisIteration,
+            summarizeRanThisIteration: this.summarizeRanThisIteration,
+            llmFixerRunCount: this.llmFixerRunCount,
+        };
+    }
+    /**
+     * 반복 에러 시그니처 추적 — 같은 에러가 2번 이상 나오면 repeatedErrorSignature 세팅.
+     */
+    trackErrorSignature(errorSummary) {
+        const sig = errorSummary.slice(0, 120);
+        if (sig === this._lastErrorSignature) {
+            this._errorSignatureCount++;
+            if (this._errorSignatureCount >= 2) {
+                this.repeatedErrorSignature = sig;
+            }
+        }
+        else {
+            this._lastErrorSignature = sig;
+            this._errorSignatureCount = 1;
+            this.repeatedErrorSignature = undefined;
+        }
+    }
+    // ─── Message pruning — GPT recommendation ────────────────────────────────
+    static MAX_MESSAGES = 40;
+    static PRUNE_KEEP_RECENT = 10;
+    /**
+     * 메시지 배열이 MAX_MESSAGES를 초과하면 prune.
+     * 구조: [system] + [task summary] + [last PRUNE_KEEP_RECENT turns]
+     *
+     * "turns" = user/assistant 쌍 (tool messages는 해당 assistant 메시지에 귀속)
+     */
+    pruneMessagesIfNeeded() {
+        const msgs = this.contextManager.getMessages();
+        if (msgs.length <= AgentLoop.MAX_MESSAGES)
+            return;
+        const system = msgs.filter(m => m.role === "system");
+        const nonSystem = msgs.filter(m => m.role !== "system");
+        // last N non-system messages 유지
+        const keep = nonSystem.slice(-AgentLoop.PRUNE_KEEP_RECENT);
+        // pruned 범위에서 task summary 추출 (user 메시지 첫 번째)
+        const pruned = nonSystem.slice(0, nonSystem.length - AgentLoop.PRUNE_KEEP_RECENT);
+        const userGoals = pruned
+            .filter(m => m.role === "user")
+            .map(m => typeof m.content === "string" ? m.content.slice(0, 200) : "")
+            .filter(Boolean)
+            .slice(0, 3);
+        const summaryContent = userGoals.length > 0
+            ? `[Context pruned — earlier goals: ${userGoals.join(" | ")}]`
+            : `[Context pruned — ${pruned.length} older messages removed]`;
+        const summary = [{ role: "system", content: summaryContent }];
+        // contextManager 재구성 (system + summary + recent)
+        this.contextManager.clear();
+        for (const m of [...system, ...summary, ...keep]) {
+            this.contextManager.addMessage(m);
+        }
+    }
+}
+// ─── Phase 4: TrustEconomics helper ─────────────────────────────────────────
+function toolNameToActionClass(name) {
+    if (name === "file_read")
+        return "file_read";
+    if (name === "file_write")
+        return "file_write";
+    if (name === "file_edit")
+        return "file_edit";
+    if (name === "file_delete")
+        return "file_delete";
+    if (name === "shell_exec")
+        return "shell_exec_risky"; // conservative default
+    if (name === "git_read" || name === "git_log" || name === "git_blame")
+        return "git_read";
+    if (name === "git_commit" || name === "git_push" || name === "git_stash")
+        return "git_write";
+    if (name.startsWith("mcp_"))
+        return "mcp_call";
+    return null;
 }
 //# sourceMappingURL=agent-loop.js.map