@yuaone/core 0.3.2 → 0.4.0

package/dist/agent-loop.js

@@ -30,6 +30,17 @@ import { FailureRecovery } from "./failure-recovery.js";
 import { ExecutionPolicyEngine } from "./execution-policy-engine.js";
 import { CostOptimizer } from "./cost-optimizer.js";
 import { ImpactAnalyzer } from "./impact-analyzer.js";
+import { SelfReflection } from "./self-reflection.js";
+import { DebateOrchestrator } from "./debate-orchestrator.js";
+import { ContinuousReflection, } from "./continuous-reflection.js";
+import { PluginRegistry } from "./plugin-registry.js";
+import { SkillLoader } from "./skill-loader.js";
+import { SpecialistRegistry } from "./specialist-registry.js";
+import { ToolPlanner } from "./tool-planner.js";
+import { SelfDebugLoop } from "./self-debug-loop.js";
+import { SkillLearner } from "./skill-learner.js";
+import { RepoKnowledgeGraph } from "./repo-knowledge-graph.js";
+import { BackgroundAgentManager } from "./background-agent.js";
 /**
  * AgentLoop — YUAN 에이전트의 핵심 실행 루프.
  *
@@ -93,11 +104,35 @@ export class AgentLoop extends EventEmitter {
     worldState = null;
     costOptimizer;
     impactAnalyzer = null;
+    selfReflection = null;
+    debateOrchestrator = null;
+    continuousReflection = null;
+    enableSelfReflection;
+    enableDebate;
+    currentComplexity = "simple";
     policyOverrides;
     checkpointSaved = false;
     iterationCount = 0;
     originalSnapshots = new Map();
     previousStrategies = [];
+    pluginRegistry;
+    skillLoader;
+    specialistRegistry;
+    toolPlanner;
+    selfDebugLoop;
+    skillLearner = null;
+    repoGraph = null;
+    backgroundAgentManager = null;
+    enableToolPlanning;
+    enableSkillLearning;
+    enableBackgroundAgents;
+    currentToolPlan = null;
+    executedToolNames = [];
+    /** 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;
     tokenUsage = {
         input: 0,
         output: 0,
@@ -112,6 +147,8 @@ export class AgentLoop extends EventEmitter {
         this.enablePlanning = options.enablePlanning !== false;
         this.planningThreshold = options.planningThreshold ?? "moderate";
         this.environment = options.environment;
+        this.enableSelfReflection = options.enableSelfReflection !== false;
+        this.enableDebate = options.enableDebate !== false;
         // BYOK LLM 클라이언트 생성
         this.llmClient = new BYOKClient(options.config.byok);
         // Governor 생성
@@ -145,6 +182,16 @@ export class AgentLoop extends EventEmitter {
         // 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",
@@ -260,6 +307,40 @@ export class AgentLoop extends EventEmitter {
         if (projectPath) {
             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, {
+                enableDeepVerify: true,
+                enableMonologue: true,
+                enableLearning: true,
+                minScoreToPass: 70,
+                criticalDimensions: ["correctness", "security"],
+            });
+            // 메모리에서 기존 학습 복원
+            if (this.memoryManager) {
+                try {
+                    const memory = await this.memoryManager.load();
+                    this.selfReflection.loadFromMemory(memory);
+                }
+                catch {
+                    // 학습 복원 실패는 치명적이지 않음
+                }
+            }
+        }
+        // DebateOrchestrator 생성 (complex/massive 태스크에서 multi-agent debate)
+        if (this.enableDebate && projectPath) {
+            this.debateOrchestrator = new DebateOrchestrator({
+                projectPath,
+                maxRounds: 3,
+                qualityThreshold: 80,
+                verifyBetweenRounds: true,
+                byokConfig: this.config.byok,
+                toolExecutor: this.toolExecutor,
+                maxTokensPerCall: 16384,
+                totalTokenBudget: Math.floor(this.config.loop.totalTokenBudget * 0.3),
+            });
+        }
         // 향상된 시스템 프롬프트 생성
         const enhancedPrompt = buildSystemPrompt({
             projectStructure,
@@ -289,6 +370,152 @@ export class AgentLoop extends EventEmitter {
                 }
             }
         }
+        // SkillLearner 초기화 (경험에서 학습된 스킬 자동 로드)
+        if (this.enableSkillLearning && projectPath) {
+            try {
+                this.skillLearner = new SkillLearner(projectPath);
+                await this.skillLearner.init();
+                // 학습된 스킬 중 관련 있는 것을 플러그인 레지스트리에 등록
+                const learnedSkills = this.skillLearner.getAllSkills();
+                if (learnedSkills.length > 0) {
+                    const skillNames = learnedSkills
+                        .filter((s) => s.confidence >= 0.3)
+                        .map((s) => s.id);
+                    if (skillNames.length > 0) {
+                        this.contextManager.addMessage({
+                            role: "system",
+                            content: `[Learned Skills: ${skillNames.join(", ")}] — Auto-activate on matching error patterns.`,
+                        });
+                    }
+                }
+            }
+            catch {
+                // SkillLearner 초기화 실패는 치명적이지 않음
+                this.skillLearner = null;
+            }
+        }
+        // RepoKnowledgeGraph 초기화 (코드 구조 그래프 — 비동기 빌드)
+        if (projectPath) {
+            try {
+                this.repoGraph = new RepoKnowledgeGraph(projectPath);
+                // 백그라운드에서 그래프 빌드 (블로킹하지 않음)
+                this.repoGraph.buildFromProject(projectPath).catch(() => {
+                    // 그래프 빌드 실패는 치명적이지 않음
+                });
+            }
+            catch {
+                this.repoGraph = null;
+            }
+        }
+        // BackgroundAgentManager 초기화 (opt-in)
+        if (this.enableBackgroundAgents && projectPath) {
+            try {
+                this.backgroundAgentManager = new BackgroundAgentManager();
+                this.backgroundAgentManager.createDefaults(projectPath);
+                // Background events → agent loop events
+                for (const agent of this.backgroundAgentManager.list()) {
+                    const bgAgent = this.backgroundAgentManager.get(agent.id);
+                    if (bgAgent) {
+                        bgAgent.on("event", (event) => {
+                            if (event.type === "error" || event.type === "warning") {
+                                this.emitEvent({
+                                    kind: "agent:thinking",
+                                    content: `[Background: ${event.agentId}] ${event.message}`,
+                                });
+                            }
+                        });
+                    }
+                }
+            }
+            catch {
+                this.backgroundAgentManager = null;
+            }
+        }
+        // Inject active plugin skills into system prompt (lazy: names only)
+        // Full skill content is loaded on-demand when triggered (file-pattern or error match)
+        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.`,
+            });
+        }
+        // ContinuousReflection 생성 (1분 간격 체크포인트 + 자기검증 + 컨텍스트 모니터)
+        this.continuousReflection = new ContinuousReflection({
+            getState: () => this.getStateSnapshot(),
+            checkpoint: async (state, emergency) => {
+                if (!this.continuationEngine)
+                    return;
+                const checkpoint = {
+                    sessionId: crypto.randomUUID(),
+                    goal: state.goal,
+                    progress: {
+                        completedTasks: state.completedTasks,
+                        currentTask: state.currentTask,
+                        remainingTasks: state.remainingTasks,
+                    },
+                    changedFiles: state.changedFiles.map((path) => ({ path, diff: "" })),
+                    workingMemory: state.workingMemory,
+                    yuanMdUpdates: [],
+                    errors: state.errors,
+                    contextUsageAtSave: state.contextUsagePercent,
+                    totalTokensUsed: state.totalTokensUsed,
+                    iterationsCompleted: state.iteration,
+                    createdAt: new Date(),
+                };
+                await this.continuationEngine.saveCheckpoint(checkpoint);
+            },
+            selfVerify: async (prompt) => {
+                // 경량 LLM 호출 (~200 토큰)로 자기검증
+                try {
+                    const response = await this.llmClient.chat([{ role: "user", content: prompt }], []);
+                    const text = typeof response.content === "string"
+                        ? response.content
+                        : "";
+                    const parsed = JSON.parse(text);
+                    return {
+                        onTrack: Boolean(parsed.onTrack),
+                        needsCorrection: Boolean(parsed.needsCorrection),
+                        issue: String(parsed.issue ?? ""),
+                        suggestion: String(parsed.suggestion ?? ""),
+                        confidence: Number(parsed.confidence ?? 0.5),
+                    };
+                }
+                catch {
+                    return {
+                        onTrack: true,
+                        needsCorrection: false,
+                        issue: "",
+                        suggestion: "",
+                        confidence: 0.5,
+                    };
+                }
+            },
+        });
+        // Wire ContinuousReflection events to agent loop
+        this.continuousReflection.on("reflection:feedback", (feedback) => {
+            this.contextManager.addMessage({
+                role: "system",
+                content: `[ContinuousReflection] ${feedback}`,
+            });
+        });
+        this.continuousReflection.on("reflection:context_warning", (usagePercent) => {
+            this.emitEvent({
+                kind: "agent:thinking",
+                content: `Context usage at ${Math.round(usagePercent * 100)}% — emergency checkpoint saved.`,
+            });
+        });
+        this.continuousReflection.on("reflection:context_overflow", () => {
+            // Trigger abort — the continuation checkpoint is already saved
+            this.emitEvent({
+                kind: "agent:thinking",
+                content: "Context usage at 95%+ — saving state and stopping.",
+            });
+            this.abort();
+        });
     }
     /**
      * MemoryManager의 학습/실패 기록을 시스템 메시지로 변환.
@@ -333,6 +560,8 @@ export class AgentLoop extends EventEmitter {
         this.iterationCount = 0;
         this.originalSnapshots.clear();
         this.previousStrategies = [];
+        this.activeSkillIds = [];
+        this.iterationSystemMsgCount = 0;
         this.failureRecovery.reset();
         this.costOptimizer.reset();
         this.tokenBudgetManager.reset();
@@ -383,11 +612,94 @@ export class AgentLoop extends EventEmitter {
                     content: classificationHint,
                 });
             }
+            // Specialist routing: 태스크 타입에 맞는 전문 에이전트 설정 주입
+            if (classification.specialistDomain) {
+                const specialistMatch = this.specialistRegistry.findSpecialist(classification.specialistDomain);
+                if (specialistMatch && specialistMatch.confidence >= 0.5) {
+                    this.contextManager.addMessage({
+                        role: "system",
+                        content: `[Specialist: ${specialistMatch.specialist.name}] ${specialistMatch.specialist.systemPrompt.slice(0, 500)}`,
+                    });
+                }
+            }
+            // Tool Planning: 태스크 타입에 맞는 도구 실행 계획 힌트 주입
+            if (this.enableToolPlanning && classification.confidence >= 0.3) {
+                const planContext = {
+                    userMessage,
+                };
+                this.currentToolPlan = this.toolPlanner.planForTask(classification.type, planContext);
+                this.executedToolNames = [];
+                if (this.currentToolPlan.confidence >= 0.5) {
+                    const planHint = this.toolPlanner.formatPlanHint(this.currentToolPlan);
+                    this.contextManager.addMessage({
+                        role: "system",
+                        content: planHint,
+                    });
+                }
+            }
             // 복잡도 감지 → 필요 시 자동 플래닝
             await this.maybeCreatePlan(userMessage);
-            const result = await this.executeLoop();
+            // ContinuousReflection 시작 (1분 간격 체크포인트/자기검증/컨텍스트모니터)
+            if (this.continuousReflection) {
+                this.continuousReflection.start();
+            }
+            let result;
+            try {
+                result = await this.executeLoop();
+            }
+            finally {
+                // ContinuousReflection 정지 (루프 종료 시 반드시 정리)
+                if (this.continuousReflection) {
+                    this.continuousReflection.stop();
+                }
+            }
             // 실행 완료 후 메모리 자동 업데이트
             await this.updateMemoryAfterRun(userMessage, result, Date.now() - runStartTime);
+            // SkillLearner: 성공적 에러 해결 시 새로운 스킬 학습
+            if (this.skillLearner && result.reason === "GOAL_ACHIEVED") {
+                try {
+                    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 },
+                            toolResults: this.allToolResults.map((r) => ({
+                                name: r.name,
+                                success: r.success,
+                                output: r.output.slice(0, 500),
+                            })),
+                            changedFiles: this.changedFiles,
+                            messages: [],
+                            tokensUsed: this.tokenUsage.total,
+                            durationMs: Date.now() - runStartTime,
+                            iterations: this.iterationCount,
+                        });
+                        this.skillLearner.extractSkillFromRun(runAnalysis, `session-${Date.now()}`);
+                        await this.skillLearner.save();
+                    }
+                }
+                catch {
+                    // 학습 실패는 치명적이지 않음
+                }
+            }
+            // 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 실패는 치명적이지 않음
+                }
+            }
+            // RepoKnowledgeGraph: 변경 파일 그래프 업데이트
+            if (this.repoGraph && this.changedFiles.length > 0) {
+                this.repoGraph.updateFiles(this.changedFiles).catch(() => {
+                    // 그래프 업데이트 실패는 치명적이지 않음
+                });
+            }
+            // BackgroundAgentManager: 정리 (stopAll은 abort 시에만)
+            // Background agents는 세션 간 지속되므로 여기서 stop하지 않음
             return result;
         }
         catch (err) {
@@ -504,6 +816,68 @@ export class AgentLoop extends EventEmitter {
     getTokenUsage() {
         return { ...this.tokenUsage };
     }
+    /** Get the plugin registry for external management */
+    getPluginRegistry() {
+        return this.pluginRegistry;
+    }
+    /** Get the specialist registry for custom specialist registration */
+    getSpecialistRegistry() {
+        return this.specialistRegistry;
+    }
+    /** Get the skill learner for inspection */
+    getSkillLearner() {
+        return this.skillLearner;
+    }
+    /** Get the repo knowledge graph */
+    getRepoGraph() {
+        return this.repoGraph;
+    }
+    /** Get background agent manager */
+    getBackgroundAgentManager() {
+        return this.backgroundAgentManager;
+    }
+    /**
+     * ContinuousReflection이 사용하는 에이전트 상태 스냅샷을 생성한다.
+     * 읽기 전용 — reflection tick마다 호출된다.
+     */
+    getStateSnapshot() {
+        const userMsg = this.contextManager.getMessages().find((m) => m.role === "user");
+        const goal = typeof userMsg?.content === "string" ? userMsg.content : "";
+        const progress = this.extractProgress();
+        const recentTools = this.allToolResults.slice(-3).map((r) => ({
+            tool: r.name,
+            input: typeof r.tool_call_id === "string" ? r.tool_call_id : "",
+            output: r.output.slice(0, 200),
+        }));
+        const errors = this.allToolResults
+            .filter((r) => !r.success)
+            .slice(-5)
+            .map((r) => `${r.name}: ${r.output.slice(0, 200)}`);
+        return {
+            goal,
+            iteration: this.iterationCount,
+            maxIteration: this.config.loop.maxIterations,
+            changedFiles: [...this.changedFiles],
+            recentToolCalls: recentTools,
+            errors,
+            contextUsagePercent: this.config.loop.totalTokenBudget > 0
+                ? this.tokenUsage.total / this.config.loop.totalTokenBudget
+                : 0,
+            sessionId: crypto.randomUUID(),
+            totalTokensUsed: this.tokenUsage.total,
+            workingMemory: this.buildWorkingMemorySummary(),
+            completedTasks: progress.completedTasks,
+            currentTask: progress.currentTask,
+            remainingTasks: progress.remainingTasks,
+        };
+    }
+    /**
+     * ContinuousReflection 인스턴스를 반환한다.
+     * 외부에서 ESC 토글(pause/resume) 또는 이벤트 구독에 사용.
+     */
+    getContinuousReflection() {
+        return this.continuousReflection;
+    }
     /**
      * 대화 히스토리를 반환.
      */
@@ -544,6 +918,7 @@ export class AgentLoop extends EventEmitter {
         if (!this.planner || !this.enablePlanning)
             return;
         const complexity = this.detectComplexity(userMessage);
+        this.currentComplexity = complexity;
         // 임계값 미만이면 플래닝 스킵
         const thresholdOrder = { simple: 1, moderate: 2, complex: 3 };
         const complexityOrder = {
@@ -771,6 +1146,36 @@ export class AgentLoop extends EventEmitter {
             iteration++;
             this.iterationCount = iteration;
             const iterationStart = Date.now();
+            this.iterationSystemMsgCount = 0; // Reset per-iteration system message counter
+            // 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;
+            if (this.changedFiles.length > 0 &&
+                fileTriggerBudgetRatio <= 0.8 &&
+                this.activeSkillIds.length < AgentLoop.MAX_ACTIVE_SKILLS) {
+                const lastFile = this.changedFiles[this.changedFiles.length - 1];
+                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.activeSkillIds.push(skill.id);
+                        this.iterationSystemMsgCount++;
+                    }
+                }
+            }
             // 1. 컨텍스트 준비
             const messages = this.contextManager.prepareForLLM();
             // 2. LLM 호출 (streaming)
@@ -832,6 +1237,106 @@ export class AgentLoop extends EventEmitter {
             // 3. 응답 처리
             if (response.toolCalls.length === 0) {
                 const content = response.content ?? "";
+                // Level 2: Deep verification before declaring completion
+                if (this.selfReflection && this.changedFiles.length > 0) {
+                    try {
+                        const changedFilesMap = new Map();
+                        for (const filePath of this.changedFiles) {
+                            const lastWrite = this.allToolResults
+                                .filter((r) => r.name === "file_write" || r.name === "file_edit")
+                                .find((r) => r.output.includes(filePath));
+                            if (lastWrite) {
+                                changedFilesMap.set(filePath, lastWrite.output);
+                            }
+                        }
+                        const verifyFn = async (prompt) => {
+                            const verifyResponse = await this.llmClient.chat([
+                                { role: "system", content: "You are a meticulous code reviewer." },
+                                { role: "user", content: prompt },
+                            ]);
+                            this.tokenBudgetManager.recordUsage("validator", verifyResponse.usage.input, verifyResponse.usage.output);
+                            return verifyResponse.content ?? "";
+                        };
+                        const deepResult = await this.selfReflection.deepVerify(content || "Complete the task", changedFilesMap, this.originalSnapshots, [], // projectPatterns — could be enhanced with YUAN.md rules
+                        verifyFn);
+                        if (deepResult.verdict === "fail" && deepResult.confidence >= 0.5) {
+                            // Not confident enough — inject feedback and continue loop
+                            const issuesList = deepResult.suggestedFixes
+                                .map((f) => `[${f.severity}] ${f.description}`)
+                                .join("; ");
+                            this.contextManager.addMessage({
+                                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.emitEvent({
+                                kind: "agent:thinking",
+                                content: `Deep verification failed (score: ${deepResult.overallScore}). Continuing to address issues...`,
+                            });
+                            continue; // Don't return GOAL_ACHIEVED, continue the loop
+                        }
+                        // Level 3: Multi-agent debate for complex/massive tasks
+                        if (this.debateOrchestrator &&
+                            ["complex", "massive"].includes(this.currentComplexity) &&
+                            deepResult.verdict !== "pass") {
+                            try {
+                                this.emitEvent({
+                                    kind: "agent:thinking",
+                                    content: `Triggering multi-agent debate for ${this.currentComplexity} task verification...`,
+                                });
+                                const debateContext = [
+                                    `Changed files: ${this.changedFiles.join(", ")}`,
+                                    `Self-reflection score: ${deepResult.overallScore}/100`,
+                                    `Concerns: ${deepResult.selfCritique}`,
+                                ].join("\n");
+                                const debateResult = await this.debateOrchestrator.debate(content || "Verify task completion", debateContext);
+                                // Track debate token usage (split roughly 60/40 input/output)
+                                const debateInput = Math.round(debateResult.totalTokensUsed * 0.6);
+                                const debateOutput = debateResult.totalTokensUsed - debateInput;
+                                this.tokenUsage.input += debateInput;
+                                this.tokenUsage.output += debateOutput;
+                                this.tokenUsage.total += debateResult.totalTokensUsed;
+                                if (!debateResult.success) {
+                                    this.contextManager.addMessage({
+                                        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.emitEvent({
+                                        kind: "agent:thinking",
+                                        content: `Debate failed (score: ${debateResult.finalScore}). Continuing to address issues...`,
+                                    });
+                                    continue; // Continue loop to address debate feedback
+                                }
+                                this.emitEvent({
+                                    kind: "agent:thinking",
+                                    content: `Debate passed (score: ${debateResult.finalScore}). Proceeding to completion.`,
+                                });
+                            }
+                            catch {
+                                // Debate failure is non-fatal — proceed with completion
+                            }
+                        }
+                        // Persist learnings from self-reflection
+                        if (this.memoryManager) {
+                            try {
+                                await this.selfReflection.persistLearnings(this.memoryManager);
+                            }
+                            catch {
+                                // Learning persistence failure is non-fatal
+                            }
+                        }
+                    }
+                    catch {
+                        // Deep verification failure is non-fatal — proceed with completion
+                    }
+                }
                 if (content) {
                     this.contextManager.addMessage({
                         role: "assistant",
@@ -861,9 +1366,13 @@ export class AgentLoop extends EventEmitter {
                 });
             }
             // 4. 도구 실행
-            const toolResults = await this.executeTools(response.toolCalls);
+            const { results: toolResults, deferredFixPrompts } = await this.executeTools(response.toolCalls);
             // Reflexion: 도구 결과 수집
             this.allToolResults.push(...toolResults);
+            // Tool plan tracking: 실행된 도구 이름 기록
+            for (const result of toolResults) {
+                this.executedToolNames.push(result.name);
+            }
             // 5. 도구 결과를 히스토리에 추가 (살균 + 압축)
             for (const result of toolResults) {
                 // Prompt injection 방어: 도구 출력 살균
@@ -883,6 +1392,14 @@ export class AgentLoop extends EventEmitter {
                     tool_call_id: result.tool_call_id,
                 });
             }
+            // AutoFix: deferred fix prompts를 tool results 뒤에 추가
+            // (tool results 전에 넣으면 OpenAI 400 에러 발생 — tool_calls 뒤에 tool 메시지가 바로 와야 함)
+            for (const fixPrompt of deferredFixPrompts) {
+                this.contextManager.addMessage({
+                    role: "user",
+                    content: fixPrompt,
+                });
+            }
             // iteration 이벤트
             this.emitEvent({
                 kind: "agent:iteration",
@@ -890,6 +1407,47 @@ export class AgentLoop extends EventEmitter {
                 tokensUsed: response.usage.input + response.usage.output,
                 durationMs: Date.now() - iterationStart,
             });
+            // Level 1: Quick verification after every 3rd iteration
+            if (this.selfReflection && iteration % 3 === 0) {
+                try {
+                    const changedFilesMap = new Map();
+                    for (const filePath of this.changedFiles) {
+                        // Collect changed file contents from tool results
+                        const lastWrite = this.allToolResults
+                            .filter((r) => r.name === "file_write" || r.name === "file_edit")
+                            .find((r) => r.output.includes(filePath));
+                        if (lastWrite) {
+                            changedFilesMap.set(filePath, lastWrite.output);
+                        }
+                    }
+                    const quickResult = await this.selfReflection.quickVerify(changedFilesMap, async (prompt) => {
+                        const verifyResponse = await this.llmClient.chat([
+                            { role: "system", content: "You are a code verification assistant." },
+                            { role: "user", content: prompt },
+                        ]);
+                        this.tokenBudgetManager.recordUsage("validator", verifyResponse.usage.input, verifyResponse.usage.output);
+                        return verifyResponse.content ?? "";
+                    });
+                    if (quickResult.verdict !== "pass") {
+                        const issues = Object.entries(quickResult.dimensions)
+                            .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.emitEvent({
+                                kind: "agent:thinking",
+                                content: `Self-reflection flagged ${issues.length} issues (confidence: ${quickResult.confidence.toFixed(2)})`,
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // Quick verification failure is non-fatal
+                }
+            }
             // 에러가 많으면 FailureRecovery + 리플래닝 시도
             const errorResults = toolResults.filter((r) => !r.success);
             if (errorResults.length > 0) {
@@ -926,8 +1484,9 @@ export class AgentLoop extends EventEmitter {
                         content: `Rolled back changes. ${decision.reason}`,
                     });
                 }
-                else {
+                else if (this.iterationSystemMsgCount < 5) {
                     // retry, approach_change, scope_reduce → 복구 프롬프트 주입
+                    // Context Budget: consolidated error guidance (recovery + debug in one message)
                     const recoveryPrompt = this.failureRecovery.buildRecoveryPrompt(decision, {
                         error: errorSummary,
                         attemptNumber: iteration,
@@ -936,15 +1495,97 @@ export class AgentLoop extends EventEmitter {
                         originalSnapshots: this.originalSnapshots,
                         previousStrategies: this.previousStrategies,
                     });
+                    // SelfDebugLoop: merge debug strategy into recovery message (not separate system msg)
+                    let debugSuffix = "";
+                    if (iteration >= 3) {
+                        const rootCauseAnalysis = this.selfDebugLoop.analyzeError(errorSummary);
+                        if (rootCauseAnalysis.confidence >= 0.5) {
+                            const debugStrategy = this.selfDebugLoop.selectStrategy(iteration - 2, []);
+                            const debugPrompt = this.selfDebugLoop.buildFixPrompt(debugStrategy, {
+                                testCommand: "pnpm build",
+                                errorOutput: errorSummary,
+                                changedFiles: this.changedFiles,
+                                originalSnapshots: this.originalSnapshots,
+                                previousAttempts: [],
+                                currentStrategy: debugStrategy,
+                            });
+                            debugSuffix = `\n\n[SelfDebug L${Math.min(iteration - 2, 5)}] Strategy: ${debugStrategy}\n${debugPrompt}`;
+                        }
+                    }
                     this.contextManager.addMessage({
                         role: "system",
-                        content: recoveryPrompt,
+                        content: recoveryPrompt + debugSuffix,
                     });
+                    this.iterationSystemMsgCount++;
                 }
                 // HierarchicalPlanner 리플래닝도 시도
                 if (this.activePlan) {
                     await this.attemptReplan(errorSummary);
                 }
+                // 에러 트리거 예산 비율 계산 (SkillLearner + Plugin 모두 사용)
+                const errorTriggerBudgetRatio = this.config.loop.totalTokenBudget > 0
+                    ? this.tokenUsage.total / this.config.loop.totalTokenBudget
+                    : 0;
+                // Context Budget: skip all optional injections at 85%+ budget
+                if (errorTriggerBudgetRatio <= 0.85 && this.iterationSystemMsgCount < 5) {
+                    // SkillLearner: 학습된 스킬 중 현재 에러에 매칭되는 것 주입
+                    if (this.skillLearner && this.activeSkillIds.length < AgentLoop.MAX_ACTIVE_SKILLS) {
+                        try {
+                            const relevantSkills = this.skillLearner.getRelevantSkills({
+                                errorMessage: errorSummary,
+                                language: undefined,
+                            });
+                            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.activeSkillIds.push(skill.id);
+                                this.iterationSystemMsgCount++;
+                                this.skillLearner.updateConfidence(skill.id, false);
+                            }
+                        }
+                        catch {
+                            // 학습 스킬 매칭 실패는 치명적이지 않음
+                        }
+                    }
+                    // Plugin trigger matching — match errors/context to plugin skills
+                    if (this.activeSkillIds.length < AgentLoop.MAX_ACTIVE_SKILLS &&
+                        this.iterationSystemMsgCount < 5) {
+                        const triggerMatches = this.pluginRegistry.matchTriggers({
+                            errorMessage: errorSummary,
+                            taskDescription: "",
+                        });
+                        if (triggerMatches.length > 0) {
+                            const bestMatch = triggerMatches[0];
+                            if (bestMatch.skill && !this.activeSkillIds.includes(bestMatch.skill.id)) {
+                                const skillTemplate = this.skillLoader.loadTemplate(bestMatch.skill);
+                                if (skillTemplate) {
+                                    let resolved = this.skillLoader.resolveTemplate(skillTemplate.content, {
+                                        error: errorSummary,
+                                        files: this.changedFiles,
+                                    });
+                                    const MAX_SKILL_INJECT_CHARS = 2000;
+                                    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.activeSkillIds.push(bestMatch.skill.id);
+                                    this.iterationSystemMsgCount++;
+                                    this.emitEvent({
+                                        kind: "agent:thinking",
+                                        content: `Activated plugin skill: ${bestMatch.skill.name} from ${bestMatch.pluginId}`,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
             }
             // 체크포인트 저장: 토큰 예산 80% 이상 사용 시 자동 저장 (1회만)
             if (!this.checkpointSaved &&
@@ -952,6 +1593,18 @@ export class AgentLoop extends EventEmitter {
                 await this.saveAutoCheckpoint(iteration);
                 this.checkpointSaved = true;
             }
+            // ContinuousReflection: 매 5 iteration마다 비상 체크포인트 트리거
+            // (정기 타이머 외에 iteration 기반 추가 안전망)
+            if (this.continuousReflection?.isRunning() &&
+                iteration > 0 &&
+                iteration % 5 === 0) {
+                try {
+                    await this.continuousReflection.emergencyCheckpoint();
+                }
+                catch {
+                    // reflection 체크포인트 실패는 치명적이지 않음
+                }
+            }
             // 예산 초과 체크
             if (this.tokenUsage.total >= this.config.loop.totalTokenBudget) {
                 return {
@@ -1050,6 +1703,7 @@ export class AgentLoop extends EventEmitter {
      */
     async executeTools(toolCalls) {
         const results = [];
+        const deferredFixPrompts = [];
         for (const toolCall of toolCalls) {
             // Governor: 안전성 검증
             try {
@@ -1081,6 +1735,29 @@ export class AgentLoop extends EventEmitter {
                 }
                 // 승인됨 → 계속 실행
             }
+            // Plugin Tool Approval Gate: check plugin tools requiring approval
+            const pluginTools = this.pluginRegistry.getAllTools();
+            const matchedPluginTool = pluginTools.find((pt) => pt.tool.name === toolCall.name);
+            if (matchedPluginTool &&
+                (matchedPluginTool.tool.requiresApproval === true ||
+                    matchedPluginTool.tool.sideEffectLevel === "destructive")) {
+                const pluginApprovalReq = {
+                    id: `plugin-approval-${toolCall.id}`,
+                    toolName: toolCall.name,
+                    arguments: args,
+                    reason: `Plugin tool "${toolCall.name}" (from ${matchedPluginTool.pluginId}) requires approval (${matchedPluginTool.tool.sideEffectLevel === "destructive"
+                        ? "destructive side effect"
+                        : "requiresApproval=true"})`,
+                    riskLevel: matchedPluginTool.tool.riskLevel === "high" ? "high" : "medium",
+                    timeout: 120_000,
+                };
+                const pluginApprovalResult = await this.handleApprovalRequest(toolCall, pluginApprovalReq);
+                if (pluginApprovalResult) {
+                    results.push(pluginApprovalResult);
+                    continue;
+                }
+                // Approved → proceed with execution
+            }
             // MCP 도구 호출 확인
             if (this.mcpClient && this.isMCPTool(toolCall.name)) {
                 const mcpResult = await this.executeMCPTool(toolCall);
@@ -1143,8 +1820,11 @@ export class AgentLoop extends EventEmitter {
                         this.analyzeFileImpact(filePathStr).catch(() => { });
                     }
                 }
-                // AutoFixLoop: 결과 검증
-                await this.validateAndFeedback(toolCall.name, result);
+                // AutoFixLoop: 결과 검증 (fix prompt는 tool results 추가 후 context에 넣음)
+                const fixPrompt = await this.validateAndFeedback(toolCall.name, result);
+                if (fixPrompt) {
+                    deferredFixPrompts.push(fixPrompt);
+                }
             }
             catch (err) {
                 this.interruptManager.clearToolAbort();
@@ -1163,8 +1843,18 @@ export class AgentLoop extends EventEmitter {
                         message: `Tool ${toolCall.name} cancelled by interrupt`,
                         retryable: false,
                     });
-                    // soft interrupt: 남은 tool calls 건너뛰고 루프 계속
-                    // hard interrupt: aborted=true로 루프 종료됨
+                    // 남은 tool calls에 대해 placeholder result 추가 (OpenAI 400 방지)
+                    const currentIdx = toolCalls.indexOf(toolCall);
+                    for (let i = currentIdx + 1; i < toolCalls.length; i++) {
+                        results.push({
+                            tool_call_id: toolCalls[i].id,
+                            name: toolCalls[i].name,
+                            output: `[SKIPPED] Previous tool was interrupted.`,
+                            success: false,
+                            durationMs: 0,
+                        });
+                    }
+                    // soft interrupt: 루프 계속 / hard interrupt: aborted=true로 종료
                     break;
                 }
                 const errorMessage = err instanceof Error ? err.message : String(err);
@@ -1182,7 +1872,7 @@ export class AgentLoop extends EventEmitter {
                 });
             }
         }
-        return results;
+        return { results, deferredFixPrompts };
     }
     /**
      * Governor의 ApprovalRequiredError를 ApprovalManager로 처리.
@@ -1229,13 +1919,13 @@ export class AgentLoop extends EventEmitter {
     async validateAndFeedback(toolName, result) {
         // file_write/file_edit만 검증 (다른 도구는 스킵)
         if (!["file_write", "file_edit"].includes(toolName)) {
-            return;
+            return null;
         }
         const validation = await this.autoFixLoop.validateResult(toolName, result.output, result.success, this.config.loop.projectPath);
         if (validation.passed) {
             // 검증 통과 → 수정 시도 기록 초기화
             this.autoFixLoop.resetAttempts();
-            return;
+            return null;
         }
         // 검증 실패 → 에러 피드백
         if (!this.autoFixLoop.canRetry()) {
@@ -1245,20 +1935,17 @@ export class AgentLoop extends EventEmitter {
                 message: `Auto-fix exhausted (${this.autoFixLoop.getAttempts().length} attempts): ${validation.failures[0]?.message ?? "Unknown error"}`,
                 retryable: false,
             });
-            return;
+            return null;
         }
-        // 수정 프롬프트 생성 → 대화 히스토리에 user 메시지로 추가
+        // 수정 프롬프트 생성 — 히스토리 추가는 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);
-        // 피드백을 히스토리에 추가 (다음 LLM 호출에서 수정 시도)
-        this.contextManager.addMessage({
-            role: "user",
-            content: fixPrompt,
-        });
+        // fixPrompt를 반환 — caller가 tool result 메시지 추가 후 context에 넣음
+        return fixPrompt;
     }
     /**
      * 도구 인자를 파싱하는 헬퍼.