@yuaone/core 0.9.43 → 1.0.0

package/dist/agent-loop.js

@@ -21,6 +21,8 @@ import { InterruptManager } from "./interrupt-manager.js";
 import { YuanMemory } from "./memory.js";
 import { MemoryManager } from "./memory-manager.js";
 import { buildSystemPrompt } from "./system-prompt.js";
+import { compilePromptEnvelope } from "./prompt-runtime.js";
+import { buildPrompt } from "./prompt-builder.js";
 import { HierarchicalPlanner, } from "./hierarchical-planner.js";
 import { TaskClassifier } from "./task-classifier.js";
 import { PromptDefense } from "./prompt-defense.js";
@@ -55,12 +57,14 @@ 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 { agentDecide, DEFAULT_DECISION, worldStateToProjectContext } from "./agent-decision.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 { TraceRecorder } from "./trace-recorder.js";
 import { ArchSummarizer } from "./arch-summarizer.js";
 import { FailureSignatureMemory } from "./failure-signature-memory.js";
+import { CausalChainResolver } from "./causal-chain-resolver.js";
 import { PlaybookLibrary } from "./playbook-library.js";
 import { ProjectExecutive } from "./project-executive.js";
 import { StallDetector } from "./stall-detector.js";
@@ -81,37 +85,20 @@ import { registerToolsInGraph, recordToolOutcomeInGraph } from "./extensions/cap
 import { getSelfWeaknessContext } from "./extensions/self-model-wiring.js";
 import { initMarketPlaybooks, selectMarketStrategy } from "./extensions/strategy-wiring.js";
 import { VisionIntentDetector } from "./vision-intent-detector.js";
+import { PatchTransactionJournal } from "./patch-transaction.js";
+import { securityCheck } from "./security-gate.js";
+import { JudgmentRuleRegistry } from "./judgment-rules.js";
+import { loadOrScanProfile } from "./repo-capability-profile.js";
+import { verifyToolResult } from "./verifier-rules.js";
+import { checkDependencyChange } from "./dependency-guard.js";
+import { WorkspaceMutationPolicy } from "./workspace-mutation-policy.js";
+import { validateBeforeWrite, detectFileRole } from "./pre-write-validator.js";
+import { PatchScopeController, detectRepoLifecycle } from "./patch-scope-controller.js";
+import { classifyCommand, validateProposedCommand, compileVerifyCommands } from "./command-plan-compiler.js";
+import { reviewFileDiff } from "./semantic-diff-reviewer.js";
+import { ModelWeaknessTracker } from "./model-weakness-tracker.js";
 import { dlog, dlogSep } from "./debug-logger.js";
-/**
- * AgentLoop — YUAN 에이전트의 핵심 실행 루프.
- *
- * 동작 흐름:
- * 1. 사용자 메시지 수신
- * 2. 시스템 프롬프트 + 히스토리로 LLM 호출
- * 3. LLM 응답에서 tool_call 파싱
- * 4. Governor가 안전성 검증
- * 5. 도구 실행 → 결과를 히스토리에 추가
- * 6. LLM에 결과 피드백 → 2번으로 반복
- * 7. 종료 조건 충족 시 결과 반환
- *
- * @example
- * ```typescript
- * const loop = new AgentLoop({
- *   config: agentConfig,
- *   toolExecutor: executor,
- *   governorConfig: { planTier: "PRO" },
- * });
- *
- * loop.on("event", (event: AgentEvent) => {
- *   // SSE 스트리밍
- * });
- *
- * const result = await loop.run("모든 console.log를 제거해줘");
- * ```
- */
-/** Minimum confidence for classification-based hints/routing to activate */
 const CLASSIFICATION_CONFIDENCE_THRESHOLD = 0.6;
-/** spawn_sub_agent tool definition — allows the LLM to delegate tasks to sub-agents */
 const SPAWN_SUB_AGENT_TOOL = {
     name: "spawn_sub_agent",
     description: "Spawn a sub-agent to work on a delegated task in parallel. " +
@@ -167,14 +154,19 @@ export class AgentLoop extends EventEmitter {
     approvalManager;
     autoFixLoop;
     interruptManager;
+    /** @deprecated Use decision.core.memoryLoad.shouldLoad at runtime. Kept for constructor init only. */
     enableMemory;
+    /** @deprecated Use decision.core.planRequired at runtime. Kept for constructor init only. */
     enablePlanning;
+    /** @deprecated Planning threshold is now determined by Decision Engine. Kept for constructor init only. */
     planningThreshold;
     environment;
     yuanMemory = null;
     memoryManager = null;
+    judgmentRegistry = null;
     planner = null;
     activePlan = null;
+    /** @deprecated Use AgentDecisionContext when available; taskClassifier is legacy fallback only */
     taskClassifier;
     promptDefense;
     reflexionEngine = null;
@@ -205,6 +197,23 @@ export class AgentLoop extends EventEmitter {
     enableSelfReflection;
     enableDebate;
     currentComplexity = "simple";
+    // ─── Agent Decision Engine ─────────────────────────────────────────────────
+    decision = DEFAULT_DECISION;
+    // ─── Prompt 3-Layer Architecture ──────────────────────────────────────────
+    pendingRunContext = {};
+    /** Cached values for refreshSystemPrompt() — set during criticalInit/backgroundInit */
+    _cachedProjectStructure;
+    _cachedYuanMdContent;
+    prevDecision = DEFAULT_DECISION;
+    toolUsageCounter = {
+        reads: 0,
+        edits: 0,
+        shells: 0,
+        tests: 0,
+        searches: 0,
+        webLookups: 0,
+        sameFileEdits: new Map(),
+    };
     policyOverrides;
     checkpointSaved = false;
     iterationCount = 0;
@@ -224,33 +233,35 @@ export class AgentLoop extends EventEmitter {
     backgroundAgentManager = null;
     sessionPersistence = null;
     sessionId = null;
+    /** @deprecated Use decision.core.skillActivation.enableToolPlanning at runtime. Kept for constructor init only. */
     enableToolPlanning;
+    /** @deprecated Use decision.core.skillActivation.enableSkillLearning at runtime. Kept for constructor init only. */
     enableSkillLearning;
+    /** @deprecated Use decision.core.subAgentPlan.enabled at runtime. Kept for constructor init only. */
     enableBackgroundAgents;
     currentToolPlan = null;
     executedToolNames = [];
     /** Unfulfilled-intent continuation counter — reset each run(), max 3 nudges */
     _unfulfilledContinuations = 0;
+    /** Model weakness learning layer — scoped by model+repo */
+    weaknessTracker = null;
     /** Context Budget: max 3 active skills at once */
     activeSkillIds = [];
     static MAX_ACTIVE_SKILLS = 3;
     /** Context Budget: track injected system messages per iteration to cap at 5 */
     iterationSystemMsgCount = 0;
-    /** Task 1: ContextBudgetManager for LLM-based summarization at 60-70% context usage */
     contextBudgetManager = null;
-    /** Task 1: Flag to ensure LLM summarization only runs once per agent run (non-blocking guard) */
     _contextSummarizationDone = false;
-    /** Task 2: Track whether write tools ran this iteration for QA triggering */
     iterationWriteToolPaths = [];
-    /** Task 2: Last QA result (surfaced to LLM on issues) */
     lastQAResult = null;
-    /** Task 3: Track TS files modified this run for auto-tsc */
     iterationTsFilesModified = [];
-    /** Task 3: Whether tsc was run in the previous iteration (skip cooldown) */
     tscRanLastIteration = false;
-    // Removed aggressive recovery fields (_lastToolFailed, _toolRetryCount, _consecutiveTextOnlyIterations)
-    // — they caused recovery loops. Model decides retry on its own.
-    // ─── OverheadGovernor — subsystem execution policy ──────────────────────
+    patchJournal = null;
+    mutationPolicy = null;
+    patchScopeController = null;
+    /** Per-iteration ephemeral hints — collected and bulk-injected before next LLM call */
+    ephemeralHints = [];
+    // ─── OverheadGovernor ──────────────────────────────────────────────────
     overheadGovernor;
     /** Writes since last verify ran (for QA/quickVerify trigger) */
     writeCountSinceVerify = 0;
@@ -303,14 +314,11 @@ export class AgentLoop extends EventEmitter {
     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;
@@ -385,30 +393,23 @@ export class AgentLoop extends EventEmitter {
         this.environment = options.environment;
         this.enableSelfReflection = options.enableSelfReflection !== false;
         this.enableDebate = options.enableDebate !== false;
-        // BYOK LLM 클라이언트 생성
         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 ??
                 options.config.loop.totalTokenBudget,
             outputReserveTokens: options.contextConfig?.outputReserveTokens ?? 4096,
             ...options.contextConfig,
         });
-        // ApprovalManager 생성
         this.approvalManager = new ApprovalManager(options.approvalConfig);
         if (options.approvalHandler) {
             this.approvalManager.setHandler(options.approvalHandler);
         }
-        // AutoFixLoop 생성
         this.autoFixLoop = new AutoFixLoop(options.autoFixConfig);
-        // Task Classifier + Prompt Defense + Token Budget + Memory Updater
         this.taskClassifier = new TaskClassifier();
         this.promptDefense = new PromptDefense();
         this.tokenBudgetManager = new TokenBudgetManager({
@@ -418,22 +419,17 @@ export class AgentLoop extends EventEmitter {
         this.failureRecovery = new FailureRecovery();
         this.costOptimizer = new CostOptimizer();
         this.policyOverrides = options.policyOverrides;
-        // MCP 서버 설정 저장
         this.mcpServerConfigs = options.mcpServerConfigs ?? [];
-        // InterruptManager 설정 (외부 주입 또는 내부 생성)
         this.interruptManager = options.interruptManager ?? new InterruptManager();
         this.setupInterruptListeners();
-        // PluginRegistry + SkillLoader 초기화
         this.pluginRegistry = options.pluginRegistry ?? new PluginRegistry();
         this.skillLoader = new SkillLoader();
-        // Advanced Intelligence 모듈 초기화
         this.specialistRegistry = new SpecialistRegistry();
         this.toolPlanner = new ToolPlanner();
         this.selfDebugLoop = new SelfDebugLoop();
         this.enableToolPlanning = options.enableToolPlanning !== false;
         this.enableSkillLearning = options.enableSkillLearning !== false;
         this.enableBackgroundAgents = options.enableBackgroundAgents === true;
-        // 시스템 프롬프트 추가 (메모리 없이 기본 프롬프트로 시작, init()에서 갱신)
         this.contextManager.addMessage({
             role: "system",
             content: this.config.loop.systemPrompt,
@@ -464,7 +460,6 @@ export class AgentLoop extends EventEmitter {
         if (this.partialInit)
             return;
         this.partialInit = true;
-        // ContextBudgetManager 초기화
         this.contextBudgetManager = new ContextBudgetManager({
             totalBudget: this.config.loop.totalTokenBudget,
             enableSummarization: true,
@@ -473,7 +468,6 @@ export class AgentLoop extends EventEmitter {
         const projectPath = this.config.loop.projectPath;
         if (!projectPath)
             return;
-        // Session persistence init
         try {
             this.sessionPersistence = new SessionPersistence(undefined, projectPath);
         }
@@ -481,19 +475,22 @@ export class AgentLoop extends EventEmitter {
             this.sessionPersistence = null;
         }
         let yuanMdContent;
-        // Memory 로드 (YUAN.md + MemoryManager + PersonaManager — fast file I/O only)
         if (this.enableMemory) {
             try {
-                // YUAN.md (raw markdown)
                 this.yuanMemory = new YuanMemory(projectPath);
                 const memData = await this.yuanMemory.load();
                 if (memData) {
                     yuanMdContent = memData.raw;
                 }
-                // MemoryManager (structured learnings)
                 this.memoryManager = new MemoryManager(projectPath);
                 await this.memoryManager.load();
-                // PersonaManager — user communication style learning + persona injection
+                this.judgmentRegistry = new JudgmentRuleRegistry(projectPath);
+                // Auto-expand judgment rules from repo capability profile
+                try {
+                    const repoProfile = loadOrScanProfile(projectPath);
+                    this.judgmentRegistry.autoExpandFromProfile(repoProfile);
+                }
+                catch { /* non-fatal */ }
                 const personaUserId = basename(projectPath) || "default";
                 this.personaManager = new PersonaManager({
                     userId: personaUserId,
@@ -503,7 +500,6 @@ export class AgentLoop extends EventEmitter {
                 await this.personaManager.loadProfile().catch(() => { });
             }
             catch (memErr) {
-                // 메모리 로드 실패는 치명적이지 않음 — 경고만 출력
                 this.emitEvent({
                     kind: "agent:error",
                     message: `Memory load failed: ${memErr instanceof Error ? memErr.message : String(memErr)}`,
@@ -511,7 +507,6 @@ export class AgentLoop extends EventEmitter {
                 });
             }
         }
-        // ExecutionPolicyEngine 로드
         try {
             this.policyEngine = new ExecutionPolicyEngine(projectPath);
             await this.policyEngine.load();
@@ -520,16 +515,13 @@ export class AgentLoop extends EventEmitter {
                     this.policyEngine.override(section, values);
                 }
             }
-            // FailureRecovery에 정책 적용
             const recoveryConfig = this.policyEngine.toFailureRecoveryConfig();
             this.failureRecovery = new FailureRecovery(recoveryConfig);
         }
         catch {
-            // 정책 로드 실패 → 기본값 사용
+            // Policy load failure — use defaults
         }
-        // ImpactAnalyzer 생성
         this.impactAnalyzer = new ImpactAnalyzer({ projectPath });
-        // ContinuationEngine 생성 + 체크포인트 복원
         this.continuationEngine = new ContinuationEngine({ projectPath });
         try {
             const latestCheckpoint = await this.continuationEngine.findLatestCheckpoint();
@@ -539,39 +531,53 @@ export class AgentLoop extends EventEmitter {
                     role: "system",
                     content: continuationPrompt,
                 });
-                // 복원 후 체크포인트 정리
                 await this.continuationEngine.pruneOldCheckpoints();
             }
         }
         catch {
-            // 체크포인트 복원 실패는 치명적이지 않음
-        }
-        // 향상된 시스템 프롬프트 생성 (projectStructure/worldState는 background에서 보완)
-        const enhancedPrompt = buildSystemPrompt({
-            projectStructure: undefined, // background에서 analyzeProject() 후 갱신
-            yuanMdContent,
-            tools: [...this.config.loop.tools, ...this.mcpToolDefinitions, SPAWN_SUB_AGENT_TOOL],
-            projectPath,
-            environment: this.environment,
-        });
-        // 기존 시스템 메시지를 향상된 프롬프트로 교체
-        this.contextManager.replaceSystemMessage(enhancedPrompt);
-        // MemoryManager의 관련 학습/경고를 추가 컨텍스트로 주입
+            // non-fatal
+        }
+        this._cachedYuanMdContent = yuanMdContent;
+        this._cachedProjectStructure = undefined;
+        const allTools = [...this.config.loop.tools, ...this.mcpToolDefinitions, SPAWN_SUB_AGENT_TOOL];
+        try {
+            const envelope = compilePromptEnvelope({
+                decision: this.decision,
+                promptOptions: {
+                    projectStructure: undefined, // background에서 analyzeProject() 후 갱신
+                    yuanMdContent,
+                    tools: allTools,
+                    activeToolNames: allTools.map(t => t.name),
+                    projectPath,
+                    environment: this.environment,
+                },
+                runContext: this.pendingRunContext,
+            });
+            const enhancedPrompt = buildPrompt(envelope);
+            this.contextManager.replaceSystemMessage(enhancedPrompt);
+        }
+        catch {
+            // Fallback to legacy buildSystemPrompt if PromptRuntime fails
+            const enhancedPrompt = buildSystemPrompt({
+                projectStructure: undefined,
+                yuanMdContent,
+                tools: allTools,
+                projectPath,
+                environment: this.environment,
+            });
+            this.contextManager.replaceSystemMessage(enhancedPrompt);
+        }
+        // MemoryManager learnings → pendingRunContext
         if (this.memoryManager) {
             const memory = this.memoryManager.getMemory();
             if (memory.learnings.length > 0 || memory.failedApproaches.length > 0) {
                 const memoryContext = this.buildMemoryContext(memory);
                 if (memoryContext) {
-                    this.contextManager.addMessage({
-                        role: "system",
-                        content: memoryContext,
-                    });
+                    this.pendingRunContext.memoryContext = memoryContext;
+                    this.refreshSystemPrompt();
                 }
             }
         }
-        // criticalInit 완료 — LLM 호출 가능 상태
-        // initialized=true는 backgroundInit() 완료 후 설정됨
-        // partialInit은 backgroundInit이 시작될 때까지 유지
     }
     /**
      * TTFT 최적화: LLM 호출을 블로킹하지 않는 백그라운드 초기화.
@@ -583,8 +589,6 @@ export class AgentLoop extends EventEmitter {
      * criticalInit() 완료 후 fire-and-forget으로 실행됨.
      */
     async backgroundInit() {
-        // backgroundInit은 criticalInit이 완료된 후에만 의미 있음
-        // initialized=true이면 이미 완료된 것
         if (this.initialized)
             return;
         const projectPath = this.config.loop.projectPath;
@@ -593,9 +597,7 @@ export class AgentLoop extends EventEmitter {
             this.partialInit = false;
             return;
         }
-        // partialInit을 false로 — backgroundInit 실행 중이므로 재진입 방어 불필요
         this.partialInit = false;
-        // VectorStore — RAG semantic code context (Ollama 느릴 수 있음)
         if (this.enableMemory && this.yuanMemory) {
             try {
                 const personaUserId = basename(projectPath) || "default";
@@ -608,30 +610,21 @@ export class AgentLoop extends EventEmitter {
                     this.vectorStore.load(),
                     new Promise(resolve => setTimeout(resolve, 1_500)),
                 ]).catch(() => { });
-                // Background code indexing — fire and forget
                 const vectorStoreRef = this.vectorStore;
                 import("./code-indexer.js").then(({ CodeIndexer }) => {
                     const indexer = new CodeIndexer({});
                     indexer.indexProject(projectPath, vectorStoreRef).catch(() => { });
                 }).catch(() => { });
-                // 프로젝트 구조 분석 (느림 — file scan)
                 const projectStructure = await this.yuanMemory.analyzeProject();
-                // analyzeProject 완료 후 시스템 프롬프트 재빌드 (WorldState 아직 없어도 됨)
                 const yuanMdContent = (await this.yuanMemory.load().catch(() => null))?.raw;
-                const updatedPrompt = buildSystemPrompt({
-                    projectStructure,
-                    yuanMdContent,
-                    tools: [...this.config.loop.tools, ...this.mcpToolDefinitions, SPAWN_SUB_AGENT_TOOL],
-                    projectPath,
-                    environment: this.environment,
-                });
-                this.contextManager.replaceSystemMessage(updatedPrompt);
+                this._cachedProjectStructure = projectStructure;
+                this._cachedYuanMdContent = yuanMdContent;
+                this.refreshSystemPrompt();
             }
             catch {
                 // non-fatal
             }
         }
-        // WorldState 수집 → system prompt에 주입
         try {
             const worldStateCollector = new WorldStateCollector({
                 projectPath,
@@ -639,22 +632,17 @@ export class AgentLoop extends EventEmitter {
                 skipTest: true,
             });
             this.worldState = await worldStateCollector.collect();
-            // WorldState 섹션 시스템 프롬프트에 추가
             if (this.worldState) {
                 const collector = new WorldStateCollector({ projectPath });
-                const worldStateSection = "\n\n" + collector.formatForPrompt(this.worldState);
-                // 현재 시스템 메시지에 WorldState 추가
-                const currentMsgs = this.contextManager.getMessages();
-                const sysMsg = currentMsgs.find((m) => m.role === "system");
-                if (sysMsg && !String(sysMsg.content).includes("## Current Environment")) {
-                    this.contextManager.replaceSystemMessage(String(sysMsg.content) + worldStateSection);
-                }
+                const worldStateSection = collector.formatForPrompt(this.worldState);
+                this.pendingRunContext.worldStateSection = worldStateSection;
+                this.refreshSystemPrompt();
             }
         }
         catch {
-            // WorldState 수집 실패는 치명적이지 않음
+            // non-fatal
         }
-        // CodeOrchestrator: 언어별 코딩 표준 + 프로젝트 컨텍스트 주입
+        // CodeOrchestrator — append directly (not yet in runContext schema)
         try {
             const { codeOrchestrator } = await import('./code-orchestrator.js');
             const codeCtx = await codeOrchestrator.getContextForLLM(projectPath ?? '');
@@ -667,7 +655,6 @@ export class AgentLoop extends EventEmitter {
             }
         }
         catch { /* non-fatal */ }
-        // Initialize World Model
         if (this.worldState && projectPath) {
             try {
                 this.transitionModel = new TransitionModel();
@@ -675,11 +662,8 @@ export class AgentLoop extends EventEmitter {
                 this.simulationEngine = new SimulationEngine(this.transitionModel, this.worldModel);
                 this.stateUpdater = new StateUpdater(this.worldModel, projectPath);
             }
-            catch {
-                // World Model initialization failure is non-fatal
-            }
+            catch { /* non-fatal */ }
         }
-        // Capture last known good git commit for FailureRecovery rollback
         try {
             const headHash = execSync("git rev-parse HEAD", {
                 cwd: projectPath,
@@ -691,9 +675,8 @@ export class AgentLoop extends EventEmitter {
             }
         }
         catch {
-            // Not a git repo or git unavailable — FailureRecovery will use file-level rollback only
+            // non-fatal — FailureRecovery will use file-level rollback
         }
-        // MCP 클라이언트 연결 (connectAll은 네트워크 I/O라 느릴 수 있음)
         {
             let mergedMCPConfigs = [...this.mcpServerConfigs];
             try {
@@ -732,9 +715,7 @@ export class AgentLoop extends EventEmitter {
                 }
             }
         }
-        // ReflexionEngine 생성
         this.reflexionEngine = new ReflexionEngine({ projectPath });
-        // SelfReflection 생성 (6D deep verify + quick verify)
         if (this.enableSelfReflection) {
             const sessionId = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
             this.selfReflection = new SelfReflection(sessionId, {
@@ -749,12 +730,9 @@ export class AgentLoop extends EventEmitter {
                     const memory = await this.memoryManager.load();
                     this.selfReflection.loadFromMemory(memory);
                 }
-                catch {
-                    // 학습 복원 실패는 치명적이지 않음
-                }
+                catch { /* non-fatal */ }
             }
         }
-        // DebateOrchestrator 생성 (complex/massive 태스크에서 multi-agent debate)
         if (this.enableDebate && projectPath) {
             this.debateOrchestrator = new DebateOrchestrator({
                 projectPath,
@@ -767,13 +745,31 @@ export class AgentLoop extends EventEmitter {
                 totalTokenBudget: Math.floor(this.config.loop.totalTokenBudget * 0.3),
             });
         }
-        // Self-model weakness context injection
         const weaknessCtx = getSelfWeaknessContext(this.capabilitySelfModel);
         if (weaknessCtx) {
-            this.contextManager.addMessage({ role: "system", content: weaknessCtx });
+            this.pendingRunContext.weaknessContext = weaknessCtx;
+            this.refreshSystemPrompt();
+        }
+        // ModelWeaknessTracker — learn from repeated validator blocks
+        if (projectPath) {
+            try {
+                const modelId = this.config.byok.model ?? this.config.byok.provider;
+                this.weaknessTracker = new ModelWeaknessTracker(projectPath, modelId);
+                const hints = this.weaknessTracker.getPreventiveHints();
+                if (hints.length > 0) {
+                    const existing = this.pendingRunContext.weaknessContext ?? "";
+                    this.pendingRunContext.weaknessContext =
+                        (existing ? existing + "\n" : "") +
+                            "[Model Weakness Prevention]\n" + hints.map(h => `- ${h}`).join("\n");
+                    this.refreshSystemPrompt();
+                }
+            }
+            catch {
+                this.weaknessTracker = null;
+            }
         }
-        // SkillLearner 초기화 (경험에서 학습된 스킬 자동 로드 — slow disk I/O)
-        if (this.enableSkillLearning && projectPath) {
+        const shouldLearnSkills = this.decision.core.skillActivation.enableSkillLearning;
+        if (shouldLearnSkills && projectPath) {
             try {
                 this.skillLearner = new SkillLearner(projectPath);
                 await this.skillLearner.init();
@@ -782,7 +778,6 @@ export class AgentLoop extends EventEmitter {
                 this.skillLearner = null;
             }
         }
-        // Phase 4: FailureSignatureMemory, PlaybookLibrary, ProjectExecutive, StallDetector
         if (projectPath) {
             try {
                 this.failureSigMemory = new FailureSignatureMemory({ projectPath });
@@ -796,21 +791,15 @@ export class AgentLoop extends EventEmitter {
                 this.metaLearningCollector = new MetaLearningCollector({ projectPath });
                 this.trustEconomics = new TrustEconomics({ projectPath });
             }
-            catch {
-                // Phase 4 init failure is non-fatal
-            }
+            catch { /* non-fatal */ }
         }
-        // Phase 5: StrategyLearner + SkillRegistry
         try {
             this.strategyLearner = new StrategyLearner();
             this.skillRegistry = new SkillRegistry();
             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
+        catch { /* non-fatal */ }
         try {
             this.tracePatternExtractor = new TracePatternExtractor();
             this.metaLearningEngine = new MetaLearningEngine({
@@ -822,10 +811,7 @@ export class AgentLoop extends EventEmitter {
             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
+        catch { /* non-fatal */ }
         try {
             this.budgetGovernorV2 = new BudgetGovernorV2({ taskBudget: this.config.loop.totalTokenBudget || 200_000 });
             this.capabilityGraph = new CapabilityGraph();
@@ -839,12 +825,10 @@ export class AgentLoop extends EventEmitter {
             registerToolsInGraph(this.capabilityGraph, toolNames);
         }
         catch { /* non-fatal */ }
-        // HierarchicalPlanner 생성
         this.planner = new HierarchicalPlanner({ projectPath });
         if (this.skillLearner) {
             this.planner.setSkillLearner(this.skillLearner);
         }
-        // Initialize Proactive Replanning (requires planner + impactAnalyzer + worldModel)
         try {
             if (this.impactAnalyzer && this.worldModel && this.simulationEngine && this.transitionModel) {
                 this.milestoneChecker = new MilestoneChecker();
@@ -853,9 +837,7 @@ export class AgentLoop extends EventEmitter {
                 this.replanningEngine = new ReplanningEngine(this.planner, this.planEvaluator, this.riskEstimator, this.milestoneChecker);
             }
         }
-        catch {
-            // Proactive replanning initialization failure is non-fatal
-        }
+        catch { /* non-fatal */ }
         if (this.skillLearner) {
             const learnedSkills = this.skillLearner.getAllSkills();
             if (learnedSkills.length > 0) {
@@ -863,14 +845,11 @@ export class AgentLoop extends EventEmitter {
                     .filter((s) => s.confidence >= CLASSIFICATION_CONFIDENCE_THRESHOLD)
                     .map((s) => s.id);
                 if (skillNames.length > 0) {
-                    this.contextManager.addMessage({
-                        role: "system",
-                        content: `[Learned Skills: ${skillNames.join(", ")}] — Auto-activate on matching error patterns.`,
-                    });
+                    this.pendingRunContext.learnedSkills = `[Learned Skills: ${skillNames.join(", ")}] — Auto-activate on matching error patterns.`;
+                    this.refreshSystemPrompt();
                 }
             }
         }
-        // RepoKnowledgeGraph 초기화 (코드 구조 그래프 — 비동기 빌드)
         try {
             this.repoGraph = new RepoKnowledgeGraph(projectPath);
             this.repoGraph.buildFromProject(projectPath).catch(() => { });
@@ -878,8 +857,8 @@ export class AgentLoop extends EventEmitter {
         catch {
             this.repoGraph = null;
         }
-        // BackgroundAgentManager 초기화 (opt-in)
-        if (this.enableBackgroundAgents && projectPath) {
+        const shouldEnableBgAgents = this.decision.core.subAgentPlan.enabled;
+        if (shouldEnableBgAgents && projectPath) {
             try {
                 this.backgroundAgentManager = new BackgroundAgentManager();
                 this.backgroundAgentManager.createDefaults(projectPath);
@@ -903,18 +882,14 @@ export class AgentLoop extends EventEmitter {
                 this.backgroundAgentManager = null;
             }
         }
-        // Inject active plugin skills into system prompt (lazy: names only)
         const activeSkills = this.pluginRegistry.getAllSkills();
         if (activeSkills.length > 0) {
             const skillSummary = activeSkills
                 .map((s) => `${s.pluginId}/${s.skill.name}`)
                 .join(", ");
-            this.contextManager.addMessage({
-                role: "system",
-                content: `[Plugins: ${skillSummary}] — Skills auto-activate on matching files/errors.`,
-            });
+            this.pendingRunContext.pluginSkills = `[Plugins: ${skillSummary}] — Skills auto-activate on matching files/errors.`;
+            this.refreshSystemPrompt();
         }
-        // ContinuousReflection 생성 (1분 간격 체크포인트 + 자기검증 + 컨텍스트 모니터)
         this.continuousReflection = new ContinuousReflection({
             getState: () => this.getStateSnapshot(),
             checkpoint: async (state, _emergency) => {
@@ -965,7 +940,6 @@ export class AgentLoop extends EventEmitter {
                 }
             },
         });
-        // Wire ContinuousReflection events to agent loop
         this.continuousReflection.on("reflection:feedback", (feedback) => {
             this.contextManager.addMessage({
                 role: "system",
@@ -981,7 +955,6 @@ export class AgentLoop extends EventEmitter {
         this.continuousReflection.on("reflection:context_overflow", () => {
             void this.handleSoftContextOverflow();
         });
-        // Mark fully initialized
         this.initialized = true;
         this.partialInit = false;
     }
@@ -1014,6 +987,35 @@ export class AgentLoop extends EventEmitter {
         }
         return parts.length > 0 ? parts.join("\n") : null;
     }
+    /**
+     * 3-Layer Prompt 재빌드: pendingRunContext + cached state → PromptRuntime → PromptBuilder.
+     * backgroundInit()에서 부분 컨텍스트가 채워질 때마다 호출.
+     */
+    refreshSystemPrompt() {
+        if (!this.initialized && !this.partialInit)
+            return;
+        const projectPath = this.config.loop.projectPath;
+        const allTools = [...this.config.loop.tools, ...this.mcpToolDefinitions, SPAWN_SUB_AGENT_TOOL];
+        try {
+            const envelope = compilePromptEnvelope({
+                decision: this.decision,
+                promptOptions: {
+                    projectStructure: this._cachedProjectStructure,
+                    yuanMdContent: this._cachedYuanMdContent,
+                    tools: allTools,
+                    activeToolNames: allTools.map(t => t.name),
+                    projectPath,
+                    environment: this.environment,
+                },
+                runContext: this.pendingRunContext,
+            });
+            const prompt = buildPrompt(envelope);
+            this.contextManager.replaceSystemMessage(prompt);
+        }
+        catch {
+            // If PromptRuntime fails, leave existing system message as-is
+        }
+    }
     /**
      * 에이전트 루프를 실행.
      * 첫 호출 시 자동으로 Memory와 프로젝트 컨텍스트를 로드한다.
@@ -1026,7 +1028,6 @@ export class AgentLoop extends EventEmitter {
         dlog("AGENT-LOOP", `run() called`, { goal: userMessage.slice(0, 120), resumedFromSession: this.resumedFromSession });
         this.reasoningAggregator.reset();
         this.reasoningTree.reset();
-        // Capture before reset so session snapshot gets accurate file list
         const prevChangedFiles = [...this.changedFiles];
         if (!this.resumedFromSession) {
             this.changedFiles = [];
@@ -1043,69 +1044,58 @@ export class AgentLoop extends EventEmitter {
                 total: 0,
             };
             this.impactHintInjected = false;
-            // Task 3: reset tsc tracking per run
+            this.pendingRunContext = {};
+            this.decision = DEFAULT_DECISION;
+            this.toolUsageCounter = { reads: 0, edits: 0, shells: 0, tests: 0, searches: 0, webLookups: 0, sameFileEdits: new Map() };
             this.iterationTsFilesModified = [];
             this.tscRanLastIteration = false;
-            // Task 1: reset context summarization guard per run
             this._contextSummarizationDone = false;
             this._unfulfilledContinuations = 0;
-            // aggressive recovery fields removed
         }
-        // Reset resumedFromSession flag after consuming it — prevents stale state
-        // from leaking into subsequent runs when the same AgentLoop instance is reused.
         this.resumedFromSession = false;
         this.checkpointSaved = false;
         this.failureRecovery.reset();
+        this.patchJournal?.reset();
+        this.patchScopeController?.reset();
         this.costOptimizer.reset();
         this.tokenBudgetManager.reset();
         const runStartTime = Date.now();
-        // 즉시 start 이벤트 emit — init 전에 TUI 타이머/상태 시작
         dlog("AGENT-LOOP", `emitting agent:start, sessionId=${this.sessionId}`);
         this.emitEvent({ kind: "agent:start", goal: userMessage });
-        // 첫 실행 시 메모리/프로젝트 컨텍스트 자동 로드
-        // criticalInit은 최대 1초만 블로킹 — LLM 호출 TTFT 최소화
-        // backgroundInit은 fire-and-forget — LLM 호출을 블로킹하지 않음
         await Promise.race([
             this.criticalInit(),
             new Promise(resolve => setTimeout(resolve, 1_000)),
         ]);
-        // If criticalInit timed out (partialInit still true), allow retry on next run
         if (this.partialInit && !this.initialized) {
             this.partialInit = false;
         }
-        // Background init — does NOT block LLM call
         this.backgroundInit().catch(() => { });
-        // Always generate a fresh sessionId per run — prevents BudgetGovernorV2
-        // from accumulating exhausted task budget across multiple runs on the same instance.
         this.sessionId = randomUUID();
-        // Phase 6: start task budget tracking
+        // Initialize patch transaction journal for atomic rollback
+        if (this.config.loop.projectPath) {
+            this.patchJournal = new PatchTransactionJournal(this.config.loop.projectPath, this.sessionId);
+        }
         try {
             this.budgetGovernorV2?.startTask(this.sessionId ?? "default");
             initMarketPlaybooks(this.strategyMarket);
         }
         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}] ` +
+                    this.pendingRunContext.playbookHint =
+                        `[Playbook: ${playbook.taskType} v${playbook.version}] ` +
                             `Phase order: ${playbook.phaseOrder.join(" → ")}. ` +
                             `Stop conditions: ${playbook.stopConditions.join(", ")}. ` +
-                            `Evidence required: ${playbook.evidenceRequirements.join(", ")}.`,
-                    });
+                            `Evidence required: ${playbook.evidenceRequirements.join(", ")}.`;
                 }
             }
             catch { /* non-fatal */ }
@@ -1137,7 +1127,6 @@ export class AgentLoop extends EventEmitter {
                 changedFiles: prevChangedFiles,
             });
         }
-        // 사용자 입력 검증 (prompt injection 방어)
         const inputValidation = this.promptDefense.validateUserInput(userMessage);
         if (inputValidation.injectionDetected && (inputValidation.severity === "critical" || inputValidation.severity === "high")) {
             this.emitEvent({
@@ -1146,18 +1135,14 @@ export class AgentLoop extends EventEmitter {
                 retryable: false,
             });
         }
-        // 사용자 메시지 추가
         this.contextManager.addMessage({
             role: "user",
             content: userMessage,
         });
-        // PersonaManager — 유저 메시지로 커뮤니케이션 스타일 학습
         this.lastUserMessage = userMessage;
         if (this.personaManager) {
             this.personaManager.analyzeUserMessage(userMessage);
         }
-        // Vision Intent Detection — user message
-        // If the user signals they want to look at an image, auto-read it and inject as vision.
         try {
             const visionIntent = this.visionIntentDetector.detect(userMessage);
             if (visionIntent && visionIntent.confidence >= 0.5) {
@@ -1186,18 +1171,14 @@ export class AgentLoop extends EventEmitter {
                 }
             }
         }
-        catch {
-            // Vision intent detection is non-fatal; continue normally
-        }
+        catch { /* non-fatal */ }
         try {
-            // Persona injection — 유저 선호도/언어/스타일 어댑테이션을 시스템 메시지로 주입
             if (this.personaManager) {
                 const personaSection = this.personaManager.buildPersonaPrompt();
                 if (personaSection) {
-                    this.contextManager.addMessage({ role: "system", content: personaSection });
+                    this.pendingRunContext.personaSection = personaSection;
                 }
             }
-            // MemoryManager.getRelevant() — 현재 태스크와 관련된 conventions/patterns/warnings 주입
             if (this.memoryManager) {
                 const relevant = this.memoryManager.getRelevant(userMessage);
                 const parts = [];
@@ -1211,13 +1192,9 @@ export class AgentLoop extends EventEmitter {
                     parts.push(`## Relevant Code Patterns\n${relevant.patterns.slice(0, 3).map((p) => `- **${p.name}**: ${p.description}`).join("\n")}`);
                 }
                 if (parts.length > 0) {
-                    this.contextManager.addMessage({
-                        role: "system",
-                        content: `[Task Memory]\n${parts.join("\n\n")}`,
-                    });
+                    this.pendingRunContext.taskMemory = `[Task Memory]\n${parts.join("\n\n")}`;
                 }
             }
-            // VectorStore RAG — 태스크와 의미적으로 유사한 코드 컨텍스트 검색·주입
             if (this.vectorStore) {
                 try {
                     const hits = await this.vectorStore.search(userMessage, 3, 0.2);
@@ -1225,70 +1202,27 @@ export class AgentLoop extends EventEmitter {
                         const ragCtx = hits
                             .map((h) => `**${h.id}** (relevance: ${(h.similarity * 100).toFixed(0)}%)\n${h.text.slice(0, 400)}`)
                             .join("\n\n---\n\n");
-                        this.contextManager.addMessage({
-                            role: "system",
-                            content: `[RAG Context — semantically relevant code snippets]\n${ragCtx}`,
-                        });
+                        this.pendingRunContext.ragContext = `[RAG Context — semantically relevant code snippets]\n${ragCtx}`;
                     }
                 }
-                catch {
-                    // VectorStore search failure is non-fatal
-                }
+                catch { /* non-fatal */ }
             }
-            // Reflexion: 과거 실행에서 배운 가이던스 주입
             if (this.reflexionEngine) {
                 try {
                     const guidance = await this.reflexionEngine.getGuidance(userMessage);
-                    // 가이던스 유효성 검증: 빈 전략이나 매우 낮은 confidence 필터링
                     const validStrategies = guidance.relevantStrategies.filter((s) => s.strategy && s.strategy.length > 5 && s.confidence > 0.1);
                     if (validStrategies.length > 0 || guidance.recentFailures.length > 0) {
                         const filteredGuidance = { ...guidance, relevantStrategies: validStrategies };
                         const guidancePrompt = this.reflexionEngine.formatForSystemPrompt(filteredGuidance);
-                        this.contextManager.addMessage({
-                            role: "system",
-                            content: guidancePrompt,
-                        });
+                        this.pendingRunContext.reflexionGuidance = guidancePrompt;
                     }
                 }
-                catch {
-                    // guidance 로드 실패는 치명적이지 않음
-                }
-            }
-            // Task 분류 → 시스템 프롬프트에 tool sequence hint 주입
-            const classification = this.taskClassifier.classify(userMessage);
-            if (classification.confidence >= CLASSIFICATION_CONFIDENCE_THRESHOLD) {
-                const classificationHint = this.taskClassifier.formatForSystemPrompt(classification);
-                this.contextManager.addMessage({
-                    role: "system",
-                    content: classificationHint,
-                });
-            }
-            // Specialist routing: 태스크 타입에 맞는 전문 에이전트 설정 주입
-            if (classification.specialistDomain) {
-                const specialistMatch = this.specialistRegistry.findSpecialist(classification.specialistDomain);
-                if (specialistMatch && specialistMatch.confidence >= CLASSIFICATION_CONFIDENCE_THRESHOLD) {
-                    this.contextManager.addMessage({
-                        role: "system",
-                        content: `[Specialist: ${specialistMatch.specialist.name}] ${specialistMatch.specialist.systemPrompt.slice(0, 500)}`,
-                    });
-                }
-            }
-            // Tool Planning: 태스크 타입에 맞는 도구 실행 계획 힌트 주입
-            if (this.enableToolPlanning && classification.confidence >= CLASSIFICATION_CONFIDENCE_THRESHOLD) {
-                const planContext = {
-                    userMessage,
-                };
-                this.currentToolPlan = this.toolPlanner.planForTask(classification.type, planContext);
-                this.executedToolNames = [];
-                if (this.currentToolPlan.confidence >= CLASSIFICATION_CONFIDENCE_THRESHOLD) {
-                    const planHint = this.toolPlanner.formatPlanHint(this.currentToolPlan);
-                    this.contextManager.addMessage({
-                        role: "system",
-                        content: planHint,
-                    });
-                }
+                catch { /* non-fatal */ }
             }
-            // CrossFileRefactor: detect rename/move intent and inject preview hint
+            this.refreshSystemPrompt();
+            // Legacy task classification block removed — Decision Engine is now always present.
+            // Task classification, specialist routing, and tool planning are handled via
+            // decision.core.skillActivation in the Decision-based overrides section below.
             if (this.config.loop.projectPath) {
                 try {
                     const renameMatch = userMessage.match(/\brename\s+[`'"]?(\w[\w.]*)[`'"]?\s+to\s+[`'"]?(\w[\w.]*)[`'"]/i);
@@ -1316,7 +1250,6 @@ export class AgentLoop extends EventEmitter {
                     else if (moveMatch) {
                         const [, symbolOrFile, destination] = moveMatch;
                         const refactor = new CrossFileRefactor(this.config.loop.projectPath);
-                        // Try move as symbol move (source heuristic: look for a file with that name)
                         const preview = await refactor.moveSymbol(symbolOrFile, symbolOrFile, destination);
                         if (preview.totalChanges > 0) {
                             const affectedList = preview.affectedFiles
@@ -1335,13 +1268,123 @@ export class AgentLoop extends EventEmitter {
                         }
                     }
                 }
-                catch {
-                    // CrossFileRefactor preview failure is non-fatal
+                catch { /* non-fatal */ }
+            }
+            try {
+                let projectCtx = this.worldState
+                    ? worldStateToProjectContext(this.worldState)
+                    : undefined;
+                // Codebase complexity stats are enriched by ExecutionEngine when it calls agentDecide
+                // AgentLoop uses worldState only; CodebaseContext lives in ExecutionEngine
+                this.decision = agentDecide({
+                    message: userMessage,
+                    projectContext: projectCtx,
+                    prevDecision: this.prevDecision ?? undefined,
+                });
+                this.emitEvent({
+                    kind: "agent:decision",
+                    decision: {
+                        intent: this.decision.core.reasoning.intent,
+                        complexity: this.decision.core.reasoning.complexity,
+                        taskStage: this.decision.core.reasoning.taskStage,
+                        planRequired: this.decision.core.planRequired,
+                        nextAction: this.decision.core.nextAction,
+                    },
+                });
+                this.emitEvent({
+                    kind: "agent:interaction_mode",
+                    mode: this.decision.core.interactionMode,
+                });
+                if (this.decision.core.nextAction === "ask_user" && this.decision.core.clarification) {
+                    const clar = this.decision.core.clarification;
+                    const clarMsg = `I need some clarification before proceeding:\n\n${clar.reason}` +
+                        (clar.missingFields.length > 0 ? `\n\nMissing: ${clar.missingFields.join(", ")}` : "") +
+                        (clar.allowProceedWithAssumptions ? "\n\n(I can proceed with assumptions if you prefer.)" : "");
+                    this.emitEvent({ kind: "agent:completed", summary: clarMsg, filesChanged: [] });
+                    return { reason: "NEEDS_CLARIFICATION", summary: clarMsg };
+                }
+                if (this.decision.core.nextAction === "blocked_external") {
+                    const blockedMsg = "This task appears to be blocked by an external dependency. Please resolve the blocking issue and retry.";
+                    this.emitEvent({ kind: "agent:completed", summary: blockedMsg, filesChanged: [] });
+                    return { reason: "BLOCKED_EXTERNAL", summary: blockedMsg };
+                }
+                this.currentComplexity = this.decision.core.reasoning.complexity;
+                const decMode = this.decision.core.interactionMode;
+                const decVd = this.decision.core.verifyDepth;
+                if (decMode === "CHAT") {
+                    this.overheadGovernor.overrideConfig({
+                        autoTsc: "OFF",
+                        debate: "OFF",
+                        deepVerify: "OFF",
+                        quickVerify: "OFF",
+                        qaPipeline: "OFF",
+                        llmFixer: "OFF",
+                        summarize: "OFF",
+                    });
+                }
+                else if (decMode === "AGENT" && decVd === "thorough") {
+                    this.overheadGovernor.overrideConfig({
+                        autoTsc: "BLOCKING",
+                        deepVerify: "BLOCKING",
+                        quickVerify: "BLOCKING",
+                        qaPipeline: "BLOCKING",
+                    });
+                }
+                else if (decMode === "HYBRID") {
+                    this.overheadGovernor.overrideConfig({
+                        autoTsc: "SHADOW",
+                        quickVerify: "SHADOW",
+                        qaPipeline: "SHADOW",
+                    });
+                }
+                // ── Initialize safety floor modules (MutationPolicy + PatchScopeController) ──
+                if (this.config.loop.projectPath) {
+                    this.mutationPolicy = new WorkspaceMutationPolicy(this.config.loop.projectPath);
+                    const lifecycle = detectRepoLifecycle(this.config.loop.projectPath);
+                    this.patchScopeController = new PatchScopeController(this.decision.core.reasoning.complexity, lifecycle);
+                }
+                // ── Decision-based memory load override (Phase I+ SSOT) ──
+                // If Decision says memory is not needed, clear already-loaded memory context
+                // to reduce prompt size for trivial tasks.
+                const shouldLoadMemory = this.decision.core.memoryLoad.shouldLoad;
+                if (!shouldLoadMemory) {
+                    this.pendingRunContext.memoryContext = undefined;
+                    this.pendingRunContext.taskMemory = undefined;
+                    this.pendingRunContext.ragContext = undefined;
+                }
+                // ── Decision-based skill/specialist/background overrides (Phase I SSOT) ──
+                const sa = this.decision.core.skillActivation;
+                // Specialist routing from Decision
+                if (sa.enableSpecialist && sa.specialistDomain) {
+                    const specialistMatch = this.specialistRegistry.findSpecialist(sa.specialistDomain);
+                    if (specialistMatch && specialistMatch.confidence >= CLASSIFICATION_CONFIDENCE_THRESHOLD) {
+                        this.contextManager.addMessage({
+                            role: "system",
+                            content: `[Specialist: ${specialistMatch.specialist.name}] ${specialistMatch.specialist.systemPrompt.slice(0, 500)}`,
+                        });
+                    }
                 }
+                // Tool planning from Decision
+                if (sa.enableToolPlanning) {
+                    const classification = this.taskClassifier.classify(userMessage);
+                    if (classification.confidence >= CLASSIFICATION_CONFIDENCE_THRESHOLD) {
+                        const planContext = { userMessage };
+                        this.currentToolPlan = this.toolPlanner.planForTask(classification.type, planContext);
+                        this.executedToolNames = [];
+                        if (this.currentToolPlan.confidence >= CLASSIFICATION_CONFIDENCE_THRESHOLD) {
+                            const planHint = this.toolPlanner.formatPlanHint(this.currentToolPlan);
+                            this.contextManager.addMessage({
+                                role: "system",
+                                content: planHint,
+                            });
+                        }
+                    }
+                }
+            }
+            catch {
+                this.decision = DEFAULT_DECISION;
             }
-            // 복잡도 감지 → 필요 시 자동 플래닝
             await this.maybeCreatePlan(userMessage);
-            // ContinuousReflection 시작 (1분 간격 체크포인트/자기검증/컨텍스트모니터)
             if (this.continuousReflection) {
                 this.continuousReflection.start();
             }
@@ -1350,20 +1393,19 @@ export class AgentLoop extends EventEmitter {
                 result = await this.executeLoop();
             }
             finally {
-                // ContinuousReflection 정지 (루프 종료 시 반드시 정리)
                 if (this.continuousReflection) {
                     this.continuousReflection.stop();
                 }
             }
+            this.prevDecision = this.decision;
+            this.toolUsageCounter = { reads: 0, edits: 0, shells: 0, tests: 0, searches: 0, webLookups: 0, sameFileEdits: new Map() };
             if (this.sessionPersistence && this.sessionId) {
                 const finalStatus = result.reason === "ERROR"
                     ? "crashed"
                     : "completed";
                 await this.sessionPersistence.updateStatus(this.sessionId, finalStatus);
             }
-            // 실행 완료 후 메모리 자동 업데이트
             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) {
@@ -1378,7 +1420,6 @@ export class AgentLoop extends EventEmitter {
                 }
                 catch { /* non-fatal */ }
             }
-            // Phase 4 remaining: SelfImprovementLoop + MetaLearningCollector + TrustEconomics
             try {
                 const taskType = this.playbookLibrary?.query(userMessage)?.taskType ?? "unknown";
                 const championPlaybook = selectMarketStrategy(this.strategyMarket, taskType);
@@ -1419,7 +1460,6 @@ export class AgentLoop extends EventEmitter {
                             this.trustEconomics.record(ac, tr.success);
                     }
                 }
-                // Phase 5: record strategy outcome
                 if (this.strategyLearner) {
                     const activePlaybookId = this._activePlaybookId ?? "default";
                     if (runSuccess) {
@@ -1429,7 +1469,6 @@ export class AgentLoop extends EventEmitter {
                         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) {
@@ -1439,7 +1478,6 @@ export class AgentLoop extends EventEmitter {
                         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);
@@ -1453,13 +1491,11 @@ export class AgentLoop extends EventEmitter {
                 catch { /* non-fatal */ }
             }
             catch { /* non-fatal */ }
-            // SkillLearner: 성공적 에러 해결 시 새로운 스킬 학습
             if (this.skillLearner && result.reason === "GOAL_ACHIEVED") {
                 try {
                     let newSkillId = null;
                     const errorToolResults = this.allToolResults.filter((r) => !r.success);
                     if (errorToolResults.length > 0 && this.changedFiles.length > 0) {
-                        // 에러가 있었지만 결국 성공 → 학습 가능한 패턴
                         const runAnalysis = this.memoryUpdater.analyzeRun({
                             goal: userMessage,
                             termination: { reason: result.reason, summary: result.summary },
@@ -1487,27 +1523,17 @@ export class AgentLoop extends EventEmitter {
                         }
                     }
                 }
-                catch {
-                    // 학습 실패는 치명적이지 않음
-                }
+                catch { /* non-fatal */ }
             }
-            // Tool plan compliance check (non-blocking, for metrics)
             if (this.currentToolPlan && this.executedToolNames.length > 0) {
                 try {
                     this.toolPlanner.validateExecution(this.currentToolPlan, this.executedToolNames);
                 }
-                catch {
-                    // compliance check 실패는 치명적이지 않음
-                }
+                catch { /* non-fatal */ }
             }
-            // RepoKnowledgeGraph: 변경 파일 그래프 업데이트
             if (this.repoGraph && this.changedFiles.length > 0) {
-                this.repoGraph.updateFiles(this.changedFiles).catch(() => {
-                    // 그래프 업데이트 실패는 치명적이지 않음
-                });
+                this.repoGraph.updateFiles(this.changedFiles).catch(() => { });
             }
-            // BackgroundAgentManager: 정리 (stopAll은 abort 시에만)
-            // Background agents는 세션 간 지속되므로 여기서 stop하지 않음
             return result;
         }
         catch (err) {
@@ -1532,10 +1558,10 @@ export class AgentLoop extends EventEmitter {
      * - 성공/실패 패턴 학습
      */
     async updateMemoryAfterRun(userGoal, result, runDurationMs = 0) {
-        if (!this.enableMemory || !this.memoryManager)
+        // Gate by both memoryLoad (loading) and memoryIntent (saving)
+        if (!this.decision.core.memoryIntent.shouldSave || !this.memoryManager)
             return;
         try {
-            // MemoryUpdater로 풍부한 학습 추출
             const analysis = this.memoryUpdater.analyzeRun({
                 goal: userGoal,
                 termination: {
@@ -1558,16 +1584,13 @@ export class AgentLoop extends EventEmitter {
                 durationMs: runDurationMs,
                 iterations: this.iterationCount,
             });
-            // 추출된 학습을 MemoryManager에 저장
             const learnings = this.memoryUpdater.extractLearnings(analysis, userGoal);
             for (const learning of learnings) {
                 this.memoryManager.addLearning(learning.category, learning.content);
             }
-            // 감지된 컨벤션 저장 (기존에 추출만 되고 저장 안 되던 버그 수정)
             for (const convention of analysis.conventions) {
                 this.memoryManager.addConvention(convention);
             }
-            // 감지된 패턴 저장
             for (const pattern of analysis.toolPatterns) {
                 if (pattern.successRate > 0.7 && pattern.count >= 3) {
                     this.memoryManager.addPattern({
@@ -1578,25 +1601,18 @@ export class AgentLoop extends EventEmitter {
                     });
                 }
             }
-            // 에러로 종료된 경우 실패 기록도 추가
             if (result.reason === "ERROR") {
                 this.memoryManager.addFailedApproach(`Task: ${userGoal.slice(0, 80)}`, result.error ?? "Unknown error");
             }
-            // 오래된 항목 정리 (매 5회 실행마다)
             if (this.iterationCount % 5 === 0) {
                 this.memoryManager.prune();
             }
-            // 메모리 저장
             await this.memoryManager.save();
-            // PersonaManager — 유저 프로필 저장 (학습된 커뮤니케이션 스타일 유지)
             if (this.personaManager) {
                 await this.personaManager.saveProfile().catch(() => { });
             }
         }
-        catch {
-            // 메모리 저장 실패는 치명적이지 않음
-        }
-        // Reflexion: 실행 결과 반영 + 전략 추출
+        catch { /* non-fatal */ }
         if (this.reflexionEngine) {
             try {
                 const entry = this.reflexionEngine.reflect({
@@ -1610,7 +1626,6 @@ export class AgentLoop extends EventEmitter {
                     changedFiles: this.changedFiles,
                 });
                 await this.reflexionEngine.store.saveReflection(entry);
-                // 성공 시 전략 추출
                 if (entry.outcome === "success") {
                     const strategy = this.reflexionEngine.extractStrategy(entry, userGoal);
                     if (strategy) {
@@ -1618,9 +1633,7 @@ export class AgentLoop extends EventEmitter {
                     }
                 }
             }
-            catch {
-                // reflexion 저장 실패는 치명적이지 않음
-            }
+            catch { /* non-fatal */ }
         }
     }
     /**
@@ -1747,11 +1760,28 @@ export class AgentLoop extends EventEmitter {
             lines.push(`changed: ${files}`);
         }
         lines.push(`token_budget: ${remaining}% remaining`);
-        if (this.iterationSystemMsgCount < 5) {
-            this.contextManager.addMessage({ role: "system", content: lines.join(" | ") });
-            this.lastAgentStateInjection = iteration;
-            this.iterationSystemMsgCount++;
+        this.ephemeralHints.push(lines.join(" | "));
+        this.lastAgentStateInjection = iteration;
+    }
+    /**
+     * Phase B: flush collected ephemeral hints into context as system messages.
+     * Applies rate-limiting: max 7 hints, max 3000 tokens total (matching PromptRuntime compileEphemeral).
+     * Called at end of each iteration (before next LLM call) and before `continue` statements.
+     */
+    flushEphemeralHints() {
+        if (this.ephemeralHints.length === 0)
+            return;
+        const MAX_HINTS = 7;
+        const MAX_TOKENS = 3000;
+        let tokenCount = 0;
+        for (const hint of this.ephemeralHints.slice(0, MAX_HINTS)) {
+            const tokens = Math.ceil(hint.length / 3.5);
+            if (tokenCount + tokens > MAX_TOKENS)
+                break;
+            tokenCount += tokens;
+            this.contextManager.addMessage({ role: "system", content: hint });
         }
+        this.ephemeralHints = [];
     }
     /**
      * LLM 응답 텍스트에서 "Updated hypothesis:" 마커를 파싱해 hypothesis를 갱신한다.
@@ -1816,24 +1846,11 @@ export class AgentLoop extends EventEmitter {
      * - "moderate" 이상 → HierarchicalPlanner로 L1+L2 계획 수립
      */
     async maybeCreatePlan(userMessage) {
-        if (!this.planner || !this.enablePlanning)
+        if (!this.planner)
             return;
-        const complexity = await this.detectComplexity(userMessage);
-        this.currentComplexity = complexity;
-        // 임계값 미만이면 플래닝 스킵
-        // Bug 4 fix: extend thresholdOrder to include "massive" (4), so that when planningThreshold
-        // is "complex", both "complex" (3) and "massive" (4) trigger planning.
-        // Previously "massive" had no entry and fell through to undefined → NaN comparisons.
-        const thresholdOrder = { simple: 1, moderate: 2, complex: 3, massive: 4 };
-        const complexityOrder = {
-            trivial: 0, simple: 1, moderate: 2, complex: 3, massive: 4,
-        };
-        // Use the threshold for the configured level; "complex" threshold activates for complexity >= "complex"
-        const effectiveThreshold = thresholdOrder[this.planningThreshold] ?? 2;
-        if ((complexityOrder[complexity] ?? 0) < effectiveThreshold) {
+        if (!this.decision.core.planRequired)
             return;
-        }
-        this.emitSubagent("planner", "start", `task complexity ${complexity}. creating execution plan`);
+        this.emitSubagent("planner", "start", `task complexity ${this.currentComplexity}. creating execution plan`);
         try {
             const plan = await this.planner.createHierarchicalPlan(userMessage, this.llmClient);
             this.activePlan = plan;
@@ -1869,13 +1886,8 @@ export class AgentLoop extends EventEmitter {
             });
         }
     }
-    /**
-     * 사용자 메시지에서 태스크 복잡도를 휴리스틱으로 추정.
-     * LLM 호출 없이 빠르게 결정 (토큰 절약).
-     */
     /**
      * Detect the best test/verify command for the current project.
-     * Bug 3 fix: replaces the hardcoded "pnpm build" default.
      */
     detectTestCommand() {
         const projectPath = this.config.loop.projectPath;
@@ -1907,6 +1919,7 @@ export class AgentLoop extends EventEmitter {
         }
         return "pnpm build";
     }
+    /** @deprecated Use AgentDecisionContext.core.reasoning.complexity instead */
     _detectComplexityHeuristic(message) {
         const lower = message.toLowerCase();
         const len = message.length;
@@ -2011,10 +2024,9 @@ export class AgentLoop extends EventEmitter {
         return "massive";
     }
     /**
-     * Hybrid complexity detection: keyword heuristic for clear cases,
-     * LLM single-word classification for ambiguous borderline cases (score 1-3).
-     * This prevents both over-planning (trivial tasks) and under-planning
-     * (ambitious short requests that keywords miss across any language).
+     * @deprecated Use AgentDecisionContext.core.reasoning.complexity instead.
+     * Hybrid complexity detection: keyword heuristic + LLM fallback for borderline cases.
+     * Only called when Decision Engine is absent.
      */
     async detectComplexity(message) {
         const heuristic = this._detectComplexityHeuristic(message);
@@ -2117,11 +2129,7 @@ export class AgentLoop extends EventEmitter {
                         this.activePlan.tactical.push(modTask);
                     }
                 }
-                // 리플래닝 결과를 컨텍스트에 주입
-                this.contextManager.addMessage({
-                    role: "system",
-                    content: `[Re-plan] Strategy: ${result.strategy}. Reason: ${result.reason}.\nModified tasks: ${result.modifiedTasks.map((t) => t.description).join(", ")}`,
-                });
+                this.ephemeralHints.push(`[Re-plan] Strategy: ${result.strategy}. Reason: ${result.reason}.\nModified tasks: ${result.modifiedTasks.map((t) => t.description).join(", ")}`);
             }
             // Estimate replan token usage
             this.tokenBudgetManager.recordUsage("planner", 500, 500);
@@ -2178,22 +2186,18 @@ export class AgentLoop extends EventEmitter {
             this.iterationCount = iteration;
             dlog("AGENT-LOOP", `── iteration ${iteration} start ──`, { tokenUsageTotal: this.tokenUsage.total });
             const iterationStart = Date.now();
-            // Phase 6: Budget governor halt check
             dlog("AGENT-LOOP", `BUDGET_EXHAUSTED check`, { used: this.tokenUsage.total, budget: this.config.loop.totalTokenBudget });
             if (checkBudgetShouldHalt(this.budgetGovernorV2, this.sessionId ?? "default")) {
                 return { reason: "BUDGET_EXHAUSTED", tokensUsed: this.tokenUsage.total };
             }
-            // 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.ephemeralHints = [];
             this.pruneMessagesIfNeeded();
-            // Cap allToolResults (prevents unbounded memory growth)
             this.allToolResults = cap(this.allToolResults, BOUNDS.allToolResults);
             this.allToolResultsSinceLastReplan = cap(this.allToolResultsSinceLastReplan, BOUNDS.toolResultsSinceReplan);
-            // Proactive replanning check (every 10 iterations when plan is active)
             if (this.replanningEngine &&
                 this.activePlan &&
                 this.activeMilestones.length > 0 &&
@@ -2217,38 +2221,21 @@ export class AgentLoop extends EventEmitter {
                                     this.activePlan.tactical[idx] = modified;
                             }
                         }
-                        // Reset tool results accumulator after replan
                         this.allToolResultsSinceLastReplan = [];
-                        // Inject replan notice into context
-                        this.contextManager.addMessage({
-                            role: "system",
-                            content: `[Proactive Replan] ${replanResult.message}\nScope: ${replanResult.decision.scope}, Risk: ${replanResult.decision.urgency}`,
-                        });
+                        this.ephemeralHints.push(`[Proactive Replan] ${replanResult.message}\nScope: ${replanResult.decision.scope}, Risk: ${replanResult.decision.urgency}`);
                     }
                 }
-                catch {
-                    // Non-blocking — proactive replanning failures should not crash the agent
-                }
+                catch { /* non-fatal */ }
             }
-            // Plan progress injection — every 3 iterations or when task advances
             if (this.activePlan) {
                 this.injectPlanProgress(iteration);
             }
-            // NOTE: ExecutionPolicyEngine cost.maxTokensPerIteration check was removed.
-            // That check compared cumulative token totals against a per-iteration limit (50k default),
-            // causing premature BUDGET_EXHAUSTED at ~50k total tokens regardless of configured totalTokenBudget.
-            // Budget enforcement is correctly handled by BudgetGovernorV2 (taskBudget: 200k) above
-            // and the totalTokenBudget check at the end of each iteration.
-            // Soft context rollover:
-            // checkpoint first, then let ContextManager compact instead of aborting/throwing.
             const contextUsageRatio = this.contextManager.getUsageRatio();
-            // 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._contextSummarizationDone = true;
                 this.contextBudgetManager.importMessages(this.contextManager.getMessages());
                 if (this.contextBudgetManager.needsSummarization()) {
                     const budgetMgr = this.contextBudgetManager;
@@ -2263,13 +2250,9 @@ export class AgentLoop extends EventEmitter {
                                 content: `Context at ${Math.round(ratio * 100)}%: summarized ${summary.originalIds.length} old messages (${summary.originalTokens} → ${summary.summarizedTokens} tokens, ${Math.round(summary.compressionRatio * 100)}% ratio).`,
                             });
                         }
-                    }).catch(() => {
-                        // summarization failure is non-fatal
-                    });
+                    }).catch(() => { });
                 }
             }
-            // ContextCompressor block removed: prepareForLLM() already handles compression internally.
-            // Double compression (ContextCompressor + prepareForLLM) caused redundant message eviction.
             if (contextUsageRatio >= 0.85) {
                 if (!this.checkpointSaved) {
                     await this.saveAutoCheckpoint(iteration);
@@ -2281,9 +2264,6 @@ export class AgentLoop extends EventEmitter {
                         `Compressing conversation state and continuing.`,
                 });
             }
-            // Check file-pattern skill triggers based on changed files
-            // Guard: skip skill injection if over 80% token budget to preserve remaining budget
-            // Guard: max 3 active skills globally (Context Budget Rules)
             const fileTriggerBudgetRatio = this.config.loop.totalTokenBudget > 0
                 ? this.tokenUsage.total / this.config.loop.totalTokenBudget
                 : 0;
@@ -2294,19 +2274,14 @@ export class AgentLoop extends EventEmitter {
                 const fileSkills = this.pluginRegistry.findMatchingSkills({
                     filePath: lastFile,
                 });
-                // Max 2 skills per iteration, capped by global 3-skill limit
                 const slotsRemaining = AgentLoop.MAX_ACTIVE_SKILLS - this.activeSkillIds.length;
                 for (const skill of fileSkills.slice(0, Math.min(2, slotsRemaining))) {
                     if (this.activeSkillIds.includes(skill.id))
                         continue; // no duplicate
                     const parsed = this.skillLoader.loadTemplate(skill);
                     if (parsed) {
-                        this.contextManager.addMessage({
-                            role: "system",
-                            content: `[File Skill: ${skill.name}] ${parsed.domain ? `[${parsed.domain}] ` : ""}${skill.description}`,
-                        });
+                        this.ephemeralHints.push(`[File Skill: ${skill.name}] ${parsed.domain ? `[${parsed.domain}] ` : ""}${skill.description}`);
                         this.activeSkillIds.push(skill.id);
-                        this.iterationSystemMsgCount++;
                     }
                 }
             }
@@ -2468,10 +2443,9 @@ export class AgentLoop extends EventEmitter {
                                 role: "assistant",
                                 content: content || "",
                             });
-                            this.contextManager.addMessage({
-                                role: "system",
-                                content: `[Self-Reflection L2] Verification failed (score: ${deepResult.overallScore}, confidence: ${deepResult.confidence.toFixed(2)}). ${deepResult.selfCritique}${issuesList ? ` Issues: ${issuesList}` : ""}. Please address these before completing.`,
-                            });
+                            this.ephemeralHints.push(`[Self-Reflection L2] Verification failed (score: ${deepResult.overallScore}, confidence: ${deepResult.confidence.toFixed(2)}). ${deepResult.selfCritique}${issuesList ? ` Issues: ${issuesList}` : ""}. Please address these before completing.`);
+                            // Flush ephemeral hints before continue (next iteration resets them)
+                            this.flushEphemeralHints();
                             this.emitSubagent("verifier", "done", `deep verification failed, score ${deepResult.overallScore}. continuing to address issues`);
                             continue; // Don't return GOAL_ACHIEVED, continue the loop
                         }
@@ -2500,10 +2474,9 @@ export class AgentLoop extends EventEmitter {
                                         role: "assistant",
                                         content: content || "",
                                     });
-                                    this.contextManager.addMessage({
-                                        role: "system",
-                                        content: `[Debate] Multi-agent debate did not pass (score: ${debateResult.finalScore}). ${debateResult.summary}. Please address the identified issues.`,
-                                    });
+                                    this.ephemeralHints.push(`[Debate] Multi-agent debate did not pass (score: ${debateResult.finalScore}). ${debateResult.summary}. Please address the identified issues.`);
+                                    // Flush ephemeral hints before continue
+                                    this.flushEphemeralHints();
                                     this.emitEvent({
                                         kind: "agent:thinking",
                                         content: `Debate failed (score: ${debateResult.finalScore}). Continuing to address issues...`,
@@ -2536,7 +2509,6 @@ export class AgentLoop extends EventEmitter {
                         content: finalSummary,
                     });
                 }
-                // Task 2: QAPipeline "thorough" mode at final task completion (LLM review included)
                 if (this.changedFiles.length > 0 && this.config.loop.projectPath) {
                     try {
                         const thoroughQA = new QAPipeline({
@@ -2600,18 +2572,23 @@ export class AgentLoop extends EventEmitter {
             if (taskCompleteCall) {
                 const callArgs = this.parseToolArgs(taskCompleteCall.arguments);
                 const taskCompleteSummary = String(callArgs["summary"] ?? response.content ?? "Task completed.");
-                // Removed stale GOAL_ACHIEVED prevention — was causing recovery loops.
-                // Model decides whether to retry on its own.
-                // Save assistant message to context — filter task_complete from tool_calls.
-                // task_complete is an internal protocol signal; including it in LLM history without
-                // a matching role:"tool" result causes API 400 on the next turn.
+                if (this.decision.core.vetoFlags.verifyRequired && !this.verifyRanThisIteration) {
+                    this.ephemeralHints.push("[VERIFY REQUIRED] You must run build/test verification before completing. Run tsc, tests, or verification commands now.");
+                    // Don't return completion — continue loop so LLM runs verification first
+                    this.contextManager.addMessage({
+                        role: "assistant",
+                        content: response.content,
+                        tool_calls: response.toolCalls.filter((tc) => tc.name !== "task_complete"),
+                    });
+                    continue;
+                }
+                // Filter task_complete from tool_calls — internal protocol signal without matching tool result
                 const nonProtocolCalls = response.toolCalls.filter((tc) => tc.name !== "task_complete");
                 this.contextManager.addMessage({
                     role: "assistant",
                     content: response.content,
                     tool_calls: nonProtocolCalls.length > 0 ? nonProtocolCalls : undefined,
                 });
-                // FIX: Emit tool_result so TUI marks task_complete as "success" (stops BlinkingDot + LiveElapsed)
                 this.emitEvent({
                     kind: "agent:tool_result",
                     tool: "task_complete",
@@ -2649,18 +2626,12 @@ export class AgentLoop extends EventEmitter {
             }
             // 4. 도구 실행
             const { results: toolResults, deferredFixPrompts } = await this.executeTools(response.toolCalls);
-            // Reflexion: 도구 결과 수집
             this.allToolResults.push(...toolResults);
             const failedResults = toolResults.filter(r => !r.success);
-            // Tool failures are already in tool result messages — LLM sees them naturally.
-            // Removed forced retry logic that caused recovery loops.
-            // Phase 6: Record tool outcomes in capability graph
             for (const tr of toolResults) {
                 recordToolOutcomeInGraph(this.capabilityGraph, tr.name, tr.success);
             }
-            // Accumulate tool results for proactive replanning evaluation
             this.allToolResultsSinceLastReplan.push(...toolResults);
-            // Tool plan tracking: 실행된 도구 이름 기록
             for (const result of toolResults) {
                 this.executedToolNames.push(result.name);
             }
@@ -2718,7 +2689,6 @@ export class AgentLoop extends EventEmitter {
                     content: fixPrompt,
                 });
             }
-            // Task 2: QAPipeline — run "quick" (structural only) after any WRITE tool call this iteration
             const projectPath = this.config.loop.projectPath;
             const qaMode = this.overheadGovernor.shouldRunQaPipeline(this.buildTriggerContext());
             if (this.iterationWriteToolPaths.length > 0 && projectPath && qaMode !== "OFF") {
@@ -2749,25 +2719,19 @@ export class AgentLoop extends EventEmitter {
                         issues: qaIssues,
                     });
                     // Only inject into LLM context in BLOCKING mode (SHADOW = observe only)
-                    if (qaMode === "BLOCKING" && failedChecks.length > 0 && this.iterationSystemMsgCount < 5) {
+                    if (qaMode === "BLOCKING" && failedChecks.length > 0) {
                         const checkSummary = failedChecks
                             .slice(0, 5)
                             .map((c) => `  - [${c.severity}] ${c.name}: ${c.message}`)
                             .join("\n");
-                        this.contextManager.addMessage({
-                            role: "system",
-                            content: `[QA Quick Check] ${failedChecks.length} issue(s) detected in modified files:\n${checkSummary}`,
-                        });
-                        this.iterationSystemMsgCount++;
+                        this.ephemeralHints.push(`[QA Quick Check] ${failedChecks.length} issue(s) detected in modified files:\n${checkSummary}`);
                     }
                 }
                 catch {
                     // QAPipeline failure is non-fatal
                 }
             }
-            // 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);
@@ -2784,8 +2748,6 @@ export class AgentLoop extends EventEmitter {
                 }
                 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;
@@ -2813,15 +2775,11 @@ export class AgentLoop extends EventEmitter {
                                 content: `Auto-TSC: TypeScript errors found after editing ${tscFilesThisIteration.join(", ")}.`,
                             });
                             // Only inject into LLM context in BLOCKING mode
-                            if (tscMode === "BLOCKING" && this.iterationSystemMsgCount < 5) {
+                            if (tscMode === "BLOCKING") {
                                 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++;
+                                this.ephemeralHints.push(`[Auto-TSC] TypeScript errors detected after modifying ${tscFilesThisIteration.length} files:\n\`\`\`\n${truncated}\n\`\`\`\nPlease fix these type errors.`);
                             }
                         }
                         else {
@@ -2879,12 +2837,8 @@ export class AgentLoop extends EventEmitter {
                         (iterReflection.reflection.whatFailed.length > 0
                             ? iterReflection.reflection.whatFailed.slice(0, 2).join("; ")
                             : null);
-                    if (insight && insight.length > 10 && this.iterationSystemMsgCount < 5) {
-                        this.contextManager.addMessage({
-                            role: "system",
-                            content: `[Reflection] ${insight}`,
-                        });
-                        this.iterationSystemMsgCount++;
+                    if (insight && insight.length > 10) {
+                        this.ephemeralHints.push(`[Reflection] ${insight}`);
                     }
                 }
                 catch {
@@ -2910,10 +2864,7 @@ export class AgentLoop extends EventEmitter {
                             .filter(([, dim]) => dim.issues.length > 0)
                             .flatMap(([, dim]) => dim.issues);
                         if (issues.length > 0) {
-                            this.contextManager.addMessage({
-                                role: "system",
-                                content: `[Self-Reflection L1] Issues detected: ${issues.join(", ")}. Confidence: ${quickResult.confidence}`,
-                            });
+                            this.ephemeralHints.push(`[Self-Reflection L1] Issues detected: ${issues.join(", ")}. Confidence: ${quickResult.confidence}`);
                             this.emitSubagent("verifier", "done", `quick verification flagged ${issues.length} issues, confidence ${quickResult.confidence.toFixed(2)}`);
                         }
                         else {
@@ -2960,7 +2911,7 @@ export class AgentLoop extends EventEmitter {
                         source: "agent",
                     });
                 }
-                else if (this.iterationSystemMsgCount < 5) {
+                else {
                     // retry, approach_change, scope_reduce → 복구 프롬프트 주입
                     // Context Budget: consolidated error guidance (recovery + debug in one message)
                     const recoveryPrompt = this.failureRecovery.buildRecoveryPrompt(decision, {
@@ -2978,7 +2929,6 @@ export class AgentLoop extends EventEmitter {
                         const rootCauseAnalysis = this.selfDebugLoop.analyzeError(errorSummary);
                         if (rootCauseAnalysis.confidence >= 0.5) {
                             const debugStrategy = this.selfDebugLoop.selectStrategy(iteration - 2, []);
-                            // Bug 3 fix: use dynamic test command detection instead of hardcoded "pnpm build"
                             const testCmd = this.config.loop.testCommand
                                 ?? this.detectTestCommand();
                             const debugPrompt = this.selfDebugLoop.buildFixPrompt(debugStrategy, {
@@ -2990,7 +2940,6 @@ export class AgentLoop extends EventEmitter {
                                 currentStrategy: debugStrategy,
                             });
                             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({
@@ -3017,11 +2966,20 @@ export class AgentLoop extends EventEmitter {
                             }
                         }
                     }
-                    this.contextManager.addMessage({
-                        role: "system",
-                        content: recoveryPrompt + debugSuffix,
-                    });
-                    this.iterationSystemMsgCount++;
+                    this.ephemeralHints.push(recoveryPrompt + debugSuffix);
+                }
+                // CausalChainResolver: root cause analysis for code-related errors
+                if (this.failureSigMemory && projectPath) {
+                    try {
+                        const resolver = new CausalChainResolver(this.failureSigMemory);
+                        const causal = await resolver.resolve(errorSummary, this.changedFiles, projectPath);
+                        if (causal && causal.confidence > 0.5) {
+                            this.ephemeralHints.push(`[ROOT_CAUSE] ${causal.suspectedRootCause} (confidence: ${causal.confidence.toFixed(2)})` +
+                                (causal.affectedFiles.length > 0 ? `\nAffected: ${causal.affectedFiles.join(", ")}` : "") +
+                                (causal.recommendedStrategy ? `\nStrategy: ${causal.recommendedStrategy}` : ""));
+                        }
+                    }
+                    catch { /* CausalChainResolver failure is non-fatal */ }
                 }
                 // HierarchicalPlanner 리플래닝도 시도
                 if (this.activePlan) {
@@ -3032,7 +2990,7 @@ export class AgentLoop extends EventEmitter {
                     ? this.tokenUsage.total / this.config.loop.totalTokenBudget
                     : 0;
                 // Context Budget: skip all optional injections at 85%+ budget
-                if (errorTriggerBudgetRatio <= 0.85 && this.iterationSystemMsgCount < 5) {
+                if (errorTriggerBudgetRatio <= 0.85) {
                     // SkillLearner: 학습된 스킬 중 현재 에러에 매칭되는 것 주입
                     if (this.skillLearner && this.activeSkillIds.length < AgentLoop.MAX_ACTIVE_SKILLS) {
                         try {
@@ -3043,22 +3001,17 @@ export class AgentLoop extends EventEmitter {
                             for (const skill of relevantSkills.slice(0, 1)) {
                                 if (this.activeSkillIds.includes(skill.id))
                                     continue;
-                                this.contextManager.addMessage({
-                                    role: "system",
-                                    content: `[Learned Skill: ${skill.id}] Diagnosis: ${skill.diagnosis}\nStrategy: ${skill.strategy}\nTools: ${skill.toolSequence.join(" → ")}`,
-                                });
+                                this.ephemeralHints.push(`[Learned Skill: ${skill.id}] Diagnosis: ${skill.diagnosis}\nStrategy: ${skill.strategy}\nTools: ${skill.toolSequence.join(" → ")}`);
                                 this.activeSkillIds.push(skill.id);
-                                this.iterationSystemMsgCount++;
                                 this.skillLearner.updateConfidence(skill.id, false);
                             }
                         }
                         catch {
-                            // 학습 스킬 매칭 실패는 치명적이지 않음
+                            /* non-fatal */
                         }
                     }
                     // Plugin trigger matching — match errors/context to plugin skills
-                    if (this.activeSkillIds.length < AgentLoop.MAX_ACTIVE_SKILLS &&
-                        this.iterationSystemMsgCount < 5) {
+                    if (this.activeSkillIds.length < AgentLoop.MAX_ACTIVE_SKILLS) {
                         const triggerMatches = this.pluginRegistry.matchTriggers({
                             errorMessage: errorSummary,
                             taskDescription: "",
@@ -3076,12 +3029,8 @@ export class AgentLoop extends EventEmitter {
                                     if (resolved.length > MAX_SKILL_INJECT_CHARS) {
                                         resolved = resolved.slice(0, MAX_SKILL_INJECT_CHARS) + "\n[...truncated for token budget]";
                                     }
-                                    this.contextManager.addMessage({
-                                        role: "system",
-                                        content: `[Plugin Skill: ${bestMatch.pluginId}/${bestMatch.skill.name}]\n${resolved}`,
-                                    });
+                                    this.ephemeralHints.push(`[Plugin Skill: ${bestMatch.pluginId}/${bestMatch.skill.name}]\n${resolved}`);
                                     this.activeSkillIds.push(bestMatch.skill.id);
-                                    this.iterationSystemMsgCount++;
                                     this.emitEvent({
                                         kind: "agent:thinking",
                                         content: `Activated plugin skill: ${bestMatch.skill.name} from ${bestMatch.pluginId}`,
@@ -3116,9 +3065,7 @@ export class AgentLoop extends EventEmitter {
                         createdAt: new Date(),
                     });
                 }
-                catch {
-                    // Checkpoint failure is non-fatal
-                }
+                catch { /* non-fatal */ }
             }
             // ContinuousReflection: 매 5 iteration마다 비상 체크포인트 트리거
             // (정기 타이머 외에 iteration 기반 추가 안전망)
@@ -3128,9 +3075,7 @@ export class AgentLoop extends EventEmitter {
                 try {
                     await this.continuousReflection.emergencyCheckpoint();
                 }
-                catch {
-                    // reflection 체크포인트 실패는 치명적이지 않음
-                }
+                catch { /* non-fatal */ }
             }
             // complex/massive task + 다중 변경 파일일 때만 aggregate impact hint 1회 주입
             if (!this.impactHintInjected &&
@@ -3139,6 +3084,7 @@ export class AgentLoop extends EventEmitter {
                 (this.currentComplexity === "complex" || this.currentComplexity === "massive")) {
                 await this.maybeInjectAggregateImpactHint();
             }
+            this.flushEphemeralHints();
             // 예산 초과 체크
             if (this.tokenUsage.total >= this.config.loop.totalTokenBudget) {
                 return {
@@ -3297,7 +3243,245 @@ export class AgentLoop extends EventEmitter {
         const args = this.parseToolArgs(toolCall.arguments);
         const allDefinitions = [...this.config.loop.tools, ...this.mcpToolDefinitions, SPAWN_SUB_AGENT_TOOL];
         const matchedDefinition = allDefinitions.find((t) => t.name === toolCall.name);
-        // Governor: 안전성 검증
+        // Security gate — deterministic pattern check (shell injection, credential leaks, etc.)
+        {
+            const secResult = securityCheck(toolCall.name, args);
+            if (secResult.verdict === "BLOCK") {
+                this.ephemeralHints.push(`[SECURITY] Blocked: ${secResult.reason}`);
+                // Log security block event to .yuan/logs/security-events.jsonl (non-fatal)
+                try {
+                    const { mkdirSync, appendFileSync } = await import("node:fs");
+                    const logDir = pathJoin(this.config.loop.projectPath, ".yuan", "logs");
+                    mkdirSync(logDir, { recursive: true });
+                    const logPath = pathJoin(logDir, "security-events.jsonl");
+                    appendFileSync(logPath, JSON.stringify({
+                        tool: toolCall.name,
+                        verdict: "BLOCK",
+                        reason: secResult.reason,
+                        pattern: secResult.pattern,
+                        timestamp: Date.now(),
+                    }) + "\n");
+                }
+                catch { /* non-fatal */ }
+                const blockResult = {
+                    tool_call_id: toolCall.id,
+                    name: toolCall.name,
+                    output: `[SECURITY_BLOCKED] ${secResult.reason}. This operation is not allowed.`,
+                    success: false,
+                    durationMs: 0,
+                };
+                return { result: blockResult, deferredFixPrompt: null };
+            }
+            if (secResult.verdict === "WARN") {
+                this.ephemeralHints.push(`[SECURITY WARNING] ${secResult.reason} — proceeding with caution`);
+            }
+        }
+        // Workspace Mutation Policy — path-level safety zones (after security gate)
+        if (this.mutationPolicy && (toolCall.name === "file_edit" || toolCall.name === "file_write")) {
+            const filePath = String(args.path ?? args.file_path ?? "");
+            const mutation = this.mutationPolicy.check(filePath);
+            if (!mutation.allowed) {
+                return {
+                    result: {
+                        tool_call_id: toolCall.id,
+                        name: toolCall.name,
+                        output: `[MUTATION_BLOCKED] ${mutation.reason}`,
+                        success: false,
+                        durationMs: 0,
+                    },
+                    deferredFixPrompt: null,
+                };
+            }
+            if (mutation.requiresApproval) {
+                this.ephemeralHints.push(`[MUTATION] ${filePath} is in ${mutation.zone} zone — approval recommended`);
+            }
+        }
+        // Judgment rules — deterministic rule-based tool approval (loaded from .yuan/judgment-rules.json)
+        if (this.judgmentRegistry) {
+            const judgment = this.judgmentRegistry.evaluate(toolCall.name, args);
+            if (judgment.action === "BLOCK") {
+                const judgmentResult = {
+                    tool_call_id: toolCall.id,
+                    name: toolCall.name,
+                    output: `[JUDGMENT_BLOCKED] ${judgment.reason}`,
+                    success: false,
+                    durationMs: 0,
+                };
+                return { result: judgmentResult, deferredFixPrompt: null };
+            }
+            if (judgment.action === "WARN") {
+                this.ephemeralHints.push(`[JUDGMENT] ${judgment.reason}`);
+            }
+            if (judgment.action === "REQUIRE_APPROVAL") {
+                this.ephemeralHints.push(`[JUDGMENT] ${judgment.reason} — approval recommended`);
+            }
+        }
+        // ToolGate enforcement — block tools based on Decision Engine gate level
+        {
+            const gate = this.decision.core.toolGate;
+            if (gate.blockedTools.includes(toolCall.name)) {
+                const gateResult = {
+                    tool_call_id: toolCall.id,
+                    name: toolCall.name,
+                    output: `[TOOL_GATE] ${toolCall.name} is blocked in ${gate.level} mode.`,
+                    success: false,
+                    durationMs: 0,
+                };
+                return { result: gateResult, deferredFixPrompt: null };
+            }
+        }
+        {
+            const vetoFlags = this.decision.core.vetoFlags;
+            // editVetoed → block file_edit/file_write tools
+            if (vetoFlags.editVetoed && (toolCall.name === "file_edit" || toolCall.name === "file_write")) {
+                const vetoResult = {
+                    tool_call_id: toolCall.id,
+                    name: toolCall.name,
+                    output: "[Decision Engine] Edit vetoed: patch risk is too high without a plan. Please create a plan first or ask the user for clarification.",
+                    success: false,
+                    durationMs: 0,
+                };
+                return { result: vetoResult, deferredFixPrompt: null };
+            }
+        }
+        // Pre-edit quality gate: remind LLM to verify before writing
+        {
+            const cq = this.decision.core.codeQuality;
+            if (cq.preEditVerify && (toolCall.name === "file_edit" || toolCall.name === "file_write")) {
+                if (this.toolUsageCounter.edits === 0) {
+                    this.ephemeralHints.push(`[Code Quality] This is a ${cq.codeTaskType} task. ` +
+                        `Primary risk: ${cq.primaryRisk}. ` +
+                        `Verify your change is complete and correct before proceeding to the next file.`);
+                }
+            }
+        }
+        // Dependency guard — detect package installs and manifest changes
+        {
+            const depResult = checkDependencyChange(toolCall.name, args);
+            if (depResult.isDependencyChange) {
+                this.ephemeralHints.push(`[DEP CHANGE] ${depResult.reason}. Verify after: ${depResult.verifyAfter}`);
+                if (depResult.requiresApproval) {
+                    this.ephemeralHints.push(`[DEP APPROVAL] Dependency change requires careful review. Budget multiplier: ${depResult.budgetMultiplier}x`);
+                }
+                if (depResult.kind) {
+                    const depFilePath = String(args.path ?? args.file_path ?? args.command ?? "");
+                    this.emitEvent({
+                        kind: "agent:dependency_change_detected",
+                        depKind: depResult.kind,
+                        path: depFilePath.slice(0, 200),
+                        requiresApproval: depResult.requiresApproval,
+                    });
+                }
+            }
+        }
+        {
+            const budget = this.decision.core.toolBudget;
+            const counter = this.toolUsageCounter;
+            const toolName = toolCall.name;
+            if (toolName === "file_read")
+                counter.reads++;
+            else if (toolName === "file_edit" || toolName === "file_write") {
+                counter.edits++;
+                const filePath = String(args.path ?? args.file ?? "");
+                if (filePath) {
+                    const prev = counter.sameFileEdits.get(filePath) ?? 0;
+                    counter.sameFileEdits.set(filePath, prev + 1);
+                    if (prev + 1 > budget.maxSameFileEdits) {
+                        this.emitEvent({
+                            kind: "agent:budget_warning",
+                            tool: toolName,
+                            used: prev + 1,
+                            limit: budget.maxSameFileEdits,
+                        });
+                        this.contextManager.addMessage({
+                            role: "system",
+                            content: `[Budget Warning] Same-file edit limit approaching for ${filePath} (${prev + 1}/${budget.maxSameFileEdits}). Consider a different approach.`,
+                        });
+                    }
+                }
+            }
+            else if (toolName === "shell_exec" || toolName === "bash") {
+                counter.shells++;
+                const cmd = String(args.command ?? "").toLowerCase();
+                if (/\b(test|jest|vitest|mocha|pytest|cargo test|go test)\b/.test(cmd)) {
+                    counter.tests++;
+                }
+                // CommandPlanCompiler — validate LLM-proposed shell commands against deterministic compiled plan
+                const rawCmd = String(args.command ?? "");
+                const classified = classifyCommand(rawCmd);
+                if (classified.purpose && this.config.loop.projectPath) {
+                    const compilerInput = {
+                        verifyDepth: this.decision.core.verifyDepth,
+                        packageManager: this.worldState?.deps?.packageManager ?? "npm",
+                        testFramework: "unknown",
+                        buildTool: "tsc",
+                        hasStrictMode: false,
+                        monorepo: false,
+                    };
+                    let compiled;
+                    if (classified.purpose === "verify")
+                        compiled = compileVerifyCommands(compilerInput);
+                    else if (classified.purpose === "build")
+                        compiled = compileVerifyCommands({ ...compilerInput, verifyDepth: "thorough" });
+                    else
+                        compiled = null;
+                    if (compiled && compiled.commands.length > 0) {
+                        const validation = validateProposedCommand(rawCmd, compiled);
+                        if (validation.recommendation === "use_compiled") {
+                            this.ephemeralHints.push(`[CMD_PLAN] Command mismatch: ${validation.deviation}. Compiled: ${compiled.commands[0]}`);
+                        }
+                        else if (validation.recommendation === "warn") {
+                            this.ephemeralHints.push(`[CMD_PLAN] Note: ${validation.deviation ?? "Minor deviation from compiled command"}`);
+                        }
+                    }
+                }
+            }
+            else if (toolName === "grep" || toolName === "glob" || toolName === "file_search")
+                counter.searches++;
+            else if (toolName === "web_search" || toolName === "parallel_web_search")
+                counter.webLookups++;
+            else if (toolName === "test_run" || toolName === "run_tests")
+                counter.tests++;
+            const checks = [
+                { name: "file_read", used: counter.reads, limit: budget.maxFileReads },
+                { name: "file_edit", used: counter.edits, limit: budget.maxEdits },
+                { name: "shell_exec", used: counter.shells, limit: budget.maxShellExecs },
+                { name: "search", used: counter.searches, limit: budget.maxSearches },
+                { name: "web_lookup", used: counter.webLookups, limit: budget.maxWebLookups },
+                { name: "test_run", used: counter.tests, limit: budget.maxTestRuns },
+            ];
+            for (const check of checks) {
+                if (check.limit <= 0)
+                    continue;
+                const ratio = check.used / check.limit;
+                if (ratio >= 1.0) {
+                    this.emitEvent({ kind: "agent:budget_exceeded", tool: check.name });
+                    const budgetResult = {
+                        tool_call_id: toolCall.id,
+                        name: toolCall.name,
+                        output: `[Decision Engine] Tool budget exceeded for ${check.name} (${check.used}/${check.limit}). Try a different approach or wrap up.`,
+                        success: false,
+                        durationMs: 0,
+                    };
+                    return { result: budgetResult, deferredFixPrompt: null };
+                }
+                if (ratio >= 0.8) {
+                    this.emitEvent({
+                        kind: "agent:budget_warning",
+                        tool: check.name,
+                        used: check.used,
+                        limit: check.limit,
+                    });
+                    if (this.iterationSystemMsgCount < 5) {
+                        this.contextManager.addMessage({
+                            role: "system",
+                            content: `[Budget Warning] ${check.name} usage at ${Math.round(ratio * 100)}% (${check.used}/${check.limit}). Consider wrapping up or using fewer ${check.name} calls.`,
+                        });
+                        this.iterationSystemMsgCount++;
+                    }
+                }
+            }
+        }
         try {
             this.governor.validateToolCall(toolCall);
         }
@@ -3307,7 +3491,7 @@ export class AgentLoop extends EventEmitter {
                 if (approvalResult) {
                     return { result: approvalResult, deferredFixPrompt: null };
                 }
-                // 승인됨 → 계속 실행
+                // Approved — continue execution
             }
             // Generic tool-definition approval gate
             if (matchedDefinition?.requiresApproval) {
@@ -3336,7 +3520,6 @@ export class AgentLoop extends EventEmitter {
                 throw err;
             }
         }
-        // ApprovalManager: 추가 승인 체크
         const approvalRequest = this.approvalManager.checkApproval(toolCall.name, args);
         if (approvalRequest) {
             const approvalResult = await this.handleApprovalRequest(toolCall, approvalRequest);
@@ -3344,7 +3527,6 @@ export class AgentLoop extends EventEmitter {
                 return { result: approvalResult, deferredFixPrompt: null };
             }
         }
-        // Plugin Tool Approval Gate
         const pluginTools = this.pluginRegistry.getAllTools();
         const matchedPluginTool = pluginTools.find((pt) => pt.tool.name === toolCall.name);
         if (matchedPluginTool &&
@@ -3365,12 +3547,10 @@ export class AgentLoop extends EventEmitter {
                 return { result: pluginApprovalResult, deferredFixPrompt: null };
             }
         }
-        // spawn_sub_agent 도구 호출 — SubAgent로 위임
         if (toolCall.name === "spawn_sub_agent") {
             const subAgentResult = await this.executeSpawnSubAgent(toolCall, args);
             return { result: subAgentResult, deferredFixPrompt: null };
         }
-        // MCP 도구 호출 확인
         if (this.mcpClient && this.isMCPTool(toolCall.name)) {
             // Emit tool_start before execution (required for trace, QA pipeline, replay)
             this.emitEvent({
@@ -3380,7 +3560,6 @@ export class AgentLoop extends EventEmitter {
                 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({
@@ -3394,7 +3573,43 @@ export class AgentLoop extends EventEmitter {
             this.emitEvent({ kind: "agent:reasoning_delta", text: `tool finished: ${toolCall.name}` });
             return { result: finalResult, deferredFixPrompt: null };
         }
-        // 도구 실행
+        // Pre-write validator — quality gate before actual file write (after all gates)
+        if ((toolCall.name === "file_edit" || toolCall.name === "file_write") && this.decision.core.codeQuality.strictMode) {
+            const filePath = String(args.path ?? args.file_path ?? "");
+            const content = String(args.content ?? args.new_string ?? "");
+            if (content) {
+                const fileRole = detectFileRole(filePath);
+                const validation = validateBeforeWrite(content, { path: filePath, fileRole, changedHunksOnly: true });
+                if (!validation.valid) {
+                    this.ephemeralHints.push(`[QUALITY_BLOCK] ${validation.blockedReason}: ${validation.issues.filter(i => i.severity === "error").map(i => i.message).join("; ")}`);
+                    // Record weakness patterns for learning
+                    if (this.weaknessTracker) {
+                        for (const issue of validation.issues.filter(i => i.severity === "error")) {
+                            const pattern = issue.message.includes("TODO") ? "todo_in_code"
+                                : issue.message.includes("empty function") ? "empty_function_body"
+                                    : issue.message.includes("any") ? "any_type_usage"
+                                        : issue.message.includes("console") ? "console_log_leak"
+                                            : issue.message.includes("stub") ? "stub_implementation"
+                                                : "unknown_quality_issue";
+                            this.weaknessTracker.record(pattern, `CRITICAL: ${issue.message}. Fix this BEFORE writing.`);
+                        }
+                    }
+                    return {
+                        result: {
+                            tool_call_id: toolCall.id,
+                            name: toolCall.name,
+                            output: `[QUALITY_BLOCKED] ${validation.blockedReason}. Fix these issues and try again.`,
+                            success: false,
+                            durationMs: 0,
+                        },
+                        deferredFixPrompt: null,
+                    };
+                }
+                if (validation.issues.length > 0) {
+                    this.ephemeralHints.push(`[QUALITY_WARN] ${validation.issues.map(i => i.message).join("; ")}`);
+                }
+            }
+        }
         const startTime = Date.now();
         const toolAbort = new AbortController();
         this.interruptManager.registerToolAbort(toolAbort);
@@ -3403,6 +3618,10 @@ export class AgentLoop extends EventEmitter {
                 args.file;
             if (candidatePath) {
                 const filePathStr = String(candidatePath);
+                // Record before snapshot in patch journal for atomic rollback
+                if (this.patchJournal) {
+                    this.patchJournal.recordBefore(toolCall.name, filePathStr);
+                }
                 if (!this.originalSnapshots.has(filePathStr)) {
                     try {
                         const { readFile } = await import("node:fs/promises");
@@ -3416,7 +3635,6 @@ export class AgentLoop extends EventEmitter {
                 }
             }
         }
-        // Emit search_start for web search tools so TUI can show search progress
         const isSearchTool = toolCall.name === "web_search" || toolCall.name === "parallel_web_search";
         if (isSearchTool) {
             const searchArgs = typeof toolCall.arguments === "string"
@@ -3437,7 +3655,6 @@ export class AgentLoop extends EventEmitter {
         try {
             const result = await this.toolExecutor.execute(toolCall, toolAbort?.signal);
             this.interruptManager.clearToolAbort();
-            // Emit search_result after completion
             if (isSearchTool && result.success) {
                 const searchArgs = typeof toolCall.arguments === "string"
                     ? (() => { try {
@@ -3484,7 +3701,6 @@ export class AgentLoop extends EventEmitter {
             });
             this.reasoningTree.add("tool", `success: ${toolCall.name}`);
             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}`);
                 }
@@ -3494,45 +3710,79 @@ export class AgentLoop extends EventEmitter {
                 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)) {
                     this.iterationWriteToolPaths.push(filePathStr);
                 }
-                // Task 3: track TS/TSX files modified this iteration for auto-tsc
                 if (filePathStr.match(/\.[cm]?tsx?$/) && !this.iterationTsFilesModified.includes(filePathStr)) {
                     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
+                // SemanticDiffReviewer — classify change meaning and recommend verification depth
+                if (this.originalSnapshots.has(filePathStr)) {
+                    try {
+                        const { readFile } = await import("node:fs/promises");
+                        const newContent = await readFile(filePathStr, "utf-8");
+                        const oldContent = this.originalSnapshots.get(filePathStr) ?? "";
+                        const review = reviewFileDiff({
+                            path: filePathStr,
+                            oldContent,
+                            newContent,
+                            language: filePathStr.match(/\.[cm]?tsx?$/) ? "typescript" : undefined,
+                        });
+                        if (review.recommendedRiskBoost > 0) {
+                            this.ephemeralHints.push(`[SEMANTIC_DIFF] ${filePathStr}: ${review.changes.join(", ")} — risk +${review.recommendedRiskBoost.toFixed(2)}, recommend verify=${review.recommendedVerifyDepth}`);
+                        }
+                    }
+                    catch { /* non-fatal — file may have been deleted */ }
+                }
                 if (this.config.loop.projectPath) {
                     const wsProjectPath = this.config.loop.projectPath;
                     new WorldStateCollector({ projectPath: wsProjectPath, skipTest: true })
                         .collect()
                         .then((snapshot) => { this.worldState = snapshot; })
-                        .catch(() => {
-                        // Non-fatal: world state update failure should not interrupt tool execution
-                    });
+                        .catch(() => { });
                 }
                 if (this.impactAnalyzer) {
-                    this.analyzeFileImpact(filePathStr).catch((err) => {
-                        // Non-fatal: impact analysis failure should not interrupt tool execution
-                        const msg = err instanceof Error ? err.message : String(err);
-                        // file-only log — console.warn corrupts Ink TUI
+                    this.analyzeFileImpact(filePathStr).catch(() => { });
+                }
+                // Auto-create rollback point based on Decision failureSurface
+                if (this.patchJournal && this.patchJournal.shouldCreateRollbackPoint(this.decision.core.failureSurface.patchRisk, this.changedFiles.length)) {
+                    const point = this.patchJournal.createRollbackPoint(`patchRisk=${this.decision.core.failureSurface.patchRisk}, files=${this.changedFiles.length}`);
+                    this.emitEvent({
+                        kind: "agent:rollback_point_created",
+                        pointId: point.id,
+                        reason: point.reason,
                     });
                 }
+                // Patch scope tracking (after successful file mutation)
+                if (this.patchScopeController) {
+                    const content = String(args.content ?? args.new_string ?? "");
+                    const isProtected = this.mutationPolicy?.check(filePathStr).zone === "PROTECTED" || this.mutationPolicy?.check(filePathStr).zone === "CAUTION";
+                    this.patchScopeController.recordChange(filePathStr, content.split("\n").length, 0, isProtected ?? false);
+                    const scopeCheck = this.patchScopeController.check();
+                    if (!scopeCheck.allowed) {
+                        this.ephemeralHints.push(`[SCOPE_LIMIT] ${scopeCheck.reason}. Consider splitting into smaller tasks or requesting plan escalation.`);
+                    }
+                }
+            }
+            // Verifier rules — deterministic check of tool output for success/failure patterns
+            {
+                const verification = verifyToolResult(toolCall.name, args, result.output, result.success);
+                if (verification.verdict === "FAIL") {
+                    this.ephemeralHints.push(`[VERIFY FAIL] ${verification.reason}. Suggested: ${verification.suggestedAction}`);
+                }
+                if (verification.verdict === "WARN") {
+                    this.ephemeralHints.push(`[VERIFY WARN] ${verification.reason}`);
+                }
             }
-            // StateUpdater: sync world model with actual tool execution result
             if (this.stateUpdater && result.success) {
                 this.stateUpdater.applyToolResult(toolCall.name, args, result).catch(() => { });
             }
-            // Extract edited file path so auto-fix can lint only the changed file
             const editedFilePath = args?.path
                 ?? args?.file_path
                 ?? undefined;
@@ -3853,10 +4103,6 @@ export class AgentLoop extends EventEmitter {
             };
         }
     }
-    /**
-     * Governor의 ApprovalRequiredError를 ApprovalManager로 처리.
-     * 승인되면 null 반환 (실행 계속), 거부되면 ToolResult 반환 (실행 차단).
-     */
     async handleApproval(toolCall, args, err) {
         const request = {
             id: randomUUID(),
@@ -3896,20 +4142,15 @@ export class AgentLoop extends EventEmitter {
      * 실패 시 수정 프롬프트를 대화 히스토리에 추가.
      */
     async validateAndFeedback(toolName, result, filePath) {
-        // file_write/file_edit/shell_exec만 검증
         if (!["file_write", "file_edit", "shell_exec"].includes(toolName)) {
             return null;
         }
         const validation = await this.autoFixLoop.validateResult(toolName, result.output, result.success, this.config.loop.projectPath, filePath);
         if (validation.passed) {
-            // 검증 통과 → 수정 시도 기록 초기화
             this.autoFixLoop.resetAttempts();
             return null;
         }
-        // 검증 실패 → 에러 피드백
         if (!this.autoFixLoop.canRetry()) {
-            // 재시도 한도 초과 → 에러 event emit + reset + 에이전트에게 피드백 반환
-            // (return null 대신 피드백 프롬프트를 반환하여 에이전트가 다른 접근법 시도 가능)
             const failMsg = validation.failures
                 .map((f) => `[${f.type}] ${f.message}`)
                 .join("; ");
@@ -3920,14 +4161,11 @@ export class AgentLoop extends EventEmitter {
             this.autoFixLoop.resetAttempts();
             return `[LINT VALIDATION FAILED after 3 auto-fix attempts — SKIP lint for this file and continue with the main task. Do NOT retry fixing lint errors. Move on to the next step.]\nFailures: ${failMsg}`;
         }
-        // 수정 프롬프트 생성 — 히스토리 추가는 caller가 tool result 추가 후 수행
         const errorMsg = validation.failures
             .map((f) => `[${f.type}] ${f.message}\n${f.rawOutput}`)
             .join("\n\n");
         const fixPrompt = this.autoFixLoop.buildFixPrompt(errorMsg, `After ${toolName} execution on project at ${this.config.loop.projectPath}`);
-        // 수정 시도 기록
         this.autoFixLoop.recordAttempt(errorMsg, "Requesting LLM fix", false, 0);
-        // fixPrompt를 반환 — caller가 tool result 메시지 추가 후 context에 넣음
         return fixPrompt;
     }
     /**
@@ -3948,11 +4186,6 @@ export class AgentLoop extends EventEmitter {
         }
         return args;
     }
-    // ─── Continuation Helpers ───
-    /**
-     * 토큰 예산 소진 임박 시 자동 체크포인트를 저장한다.
-     * 현재 진행 상태, 변경 파일, 에러 등을 직렬화.
-     */
     async saveAutoCheckpoint(iteration) {
         if (!this.continuationEngine)
             return;
@@ -3985,14 +4218,8 @@ export class AgentLoop extends EventEmitter {
                 });
             }
         }
-        catch {
-            // 체크포인트 저장 실패는 치명적이지 않음
-        }
+        catch { /* non-fatal */ }
     }
-    /**
-     * 매 iteration 시작 시 현재 플랜 진행 상황을 컨텍스트에 주입.
-     * 같은 태스크 인덱스라면 3 iteration마다만 주입 (컨텍스트 bloat 방지).
-     */
     injectPlanProgress(iteration) {
         if (!this.activePlan)
             return;
@@ -4030,16 +4257,8 @@ export class AgentLoop extends EventEmitter {
         else {
             lines.push(`\nAll tasks complete — verify and wrap up.`);
         }
-        this.contextManager.addMessage({
-            role: "system",
-            content: lines.join("\n"),
-        });
-        this.iterationSystemMsgCount++;
+        this.ephemeralHints.push(lines.join("\n"));
     }
-    /**
-     * 현재 태스크의 targetFiles가 changedFiles에 포함됐는지 확인해
-     * 완료 감지 시 다음 태스크로 자동 전진.
-     */
     tryAdvancePlanTask() {
         if (!this.activePlan)
             return;
@@ -4148,12 +4367,6 @@ export class AgentLoop extends EventEmitter {
     getWorldState() {
         return this.worldState;
     }
-    // ─── Interrupt Helpers ───
-    /**
-     * InterruptManager 이벤트를 AgentLoop에 연결한다.
-     * - soft interrupt: 피드백을 user 메시지로 주입
-     * - hard interrupt: 루프 즉시 중단
-     */
     setupInterruptListeners() {
         // soft interrupt: 피드백을 대화 히스토리에 주입
         this.interruptManager.on("interrupt:feedback", (feedback) => {
@@ -4167,10 +4380,6 @@ export class AgentLoop extends EventEmitter {
             this.aborted = true;
         });
     }
-    /**
-     * pause 상태일 때 resume 시그널을 대기한다.
-     * resume 또는 hard interrupt가 올 때까지 블로킹.
-     */
     waitForResume() {
         return new Promise((resolve) => {
             // 이미 resume 상태이면 즉시 반환
@@ -4192,11 +4401,6 @@ export class AgentLoop extends EventEmitter {
             this.interruptManager.on("interrupt:hard", onHard);
         });
     }
-    // ─── Impact Analysis ───
-    /**
-     * Returns a cached ImpactReport if the same files were already analyzed,
-     * otherwise computes and caches a fresh report.
-     */
     async getOrComputeImpact(files) {
         if (!this.impactAnalyzer || files.length === 0)
             return null;
@@ -4229,12 +4433,8 @@ export class AgentLoop extends EventEmitter {
                 kind: "agent:thinking",
                 content: `Impact analysis: ${report.riskLevel} risk. ${report.affectedFiles.length} affected files, ${report.breakingChanges.length} breaking changes.`,
             });
-            // 고위험 변경 정보를 LLM에 주입
             const impactPrompt = this.impactAnalyzer.formatForPrompt(report);
-            this.contextManager.addMessage({
-                role: "system",
-                content: impactPrompt,
-            });
+            this.ephemeralHints.push(impactPrompt);
         }
     }
     /**
@@ -4269,10 +4469,7 @@ export class AgentLoop extends EventEmitter {
             if (planPreview) {
                 hintLines.push("", "Suggested refactor order:", planPreview);
             }
-            this.contextManager.addMessage({
-                role: "system",
-                content: hintLines.join("\n"),
-            });
+            this.ephemeralHints.push(hintLines.join("\n"));
             this.impactHintInjected = true;
             this.emitEvent({
                 kind: "agent:thinking",
@@ -4281,14 +4478,8 @@ export class AgentLoop extends EventEmitter {
                     `${report.deadCodeCandidates.length} dead code candidates.`,
             });
         }
-        catch {
-            // aggregate impact 실패는 치명적이지 않음
-        }
+        catch { /* non-fatal */ }
     }
-    /**
-     * 종료 직전 최종 impact 요약 생성.
-     * assistant final summary에만 붙이고 system prompt 오염은 하지 않는다.
-     */
     async buildFinalImpactSummary() {
         if (!this.impactAnalyzer || this.changedFiles.length === 0)
             return null;
@@ -4340,14 +4531,6 @@ 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)
@@ -4378,11 +4561,6 @@ export class AgentLoop extends EventEmitter {
         });
         return JSON.stringify(structured, null, 2);
     }
-    /**
-     * ContinuousReflection overflow signal을 soft rollover로 처리한다.
-     * 절대 abort하지 않고, 체크포인트 저장 후 다음 iteration에서
-     * ContextManager가 압축된 컨텍스트를 사용하도록 둔다.
-     */
     async handleSoftContextOverflow() {
         try {
             await this.saveAutoCheckpoint(this.iterationCount);
@@ -4409,7 +4587,6 @@ export class AgentLoop extends EventEmitter {
         }
         this.traceRecorder?.stop();
     }
-    // ─── Helpers ───
     /**
      * Builds a Map<filePath, toolOutput> for all changed files from write/edit tool results.
      * Used by selfReflection deepVerify and quickVerify.
@@ -4463,11 +4640,6 @@ 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;
@@ -4481,10 +4653,6 @@ export class AgentLoop extends EventEmitter {
             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
@@ -4517,16 +4685,10 @@ export class AgentLoop extends EventEmitter {
                     if (hasErrors) {
                         // 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++;
-                        }
+                        const truncated = result.output.length > 1000
+                            ? result.output.slice(0, 1000) + "\n[truncated]"
+                            : result.output;
+                        this.ephemeralHints.push(`[Verify Phase] TypeScript errors found:\n\`\`\`\n${truncated}\n\`\`\`\nPlease fix before completion.`);
                         return false;
                     }
                 }
@@ -4537,11 +4699,6 @@ export class AgentLoop extends EventEmitter {
         }
         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;
@@ -4565,10 +4722,6 @@ export class AgentLoop extends EventEmitter {
             }
         }
         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",
@@ -4579,13 +4732,11 @@ export class AgentLoop extends EventEmitter {
             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 빌드.
      */
@@ -4624,15 +4775,8 @@ export class AgentLoop extends EventEmitter {
             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)