@yuaone/core 0.4.2 → 0.4.3

package/dist/execution-engine.js

@@ -28,6 +28,7 @@
  */
 import { EventEmitter } from "node:events";
 import { readFile } from "node:fs/promises";
+import path from "node:path";
 import { BYOKClient } from "./llm-client.js";
 import { AgentLoop } from "./agent-loop.js";
 import { AgentLogger } from "./agent-logger.js";
@@ -46,6 +47,12 @@ import { SecurityScanner } from "./security-scanner.js";
 import { DocIntelligence } from "./doc-intelligence.js";
 import { IntentInferenceEngine } from "./intent-inference.js";
 import { SpeculativeExecutor } from "./speculative-executor.js";
+import { SubAgent } from "./sub-agent.js";
+import { routeSubAgent } from "./sub-agent-router.js";
+import { DAGOrchestrator } from "./dag-orchestrator.js";
+import { WorkspaceLock } from "./workspace-lock.js";
+import { SkillLoader, } from "./skill-loader.js";
+import { SkillLearner, } from "./skill-learner.js";
 // ─── Defaults ────────────────────────────────────────────────────
 const ENGINE_DEFAULTS = {
     maxIterations: 100,
@@ -82,6 +89,7 @@ export class ExecutionEngine extends EventEmitter {
     reflection;
     codebaseContext;
     vectorIndex;
+    embeddingCache;
     stateMachine;
     abortController;
     changedFiles;
@@ -97,6 +105,8 @@ export class ExecutionEngine extends EventEmitter {
     parallelStepResults;
     /** DAG 기반 병렬 실행이 완료되었는지 */
     parallelExecutionDone;
+    dagOrchestrator = null;
+    workspaceLock;
     /** MCP server configurations (stored from constructor config) */
     mcpServerConfigs;
     /** MCP Client — external tool bridge (null if disabled) */
@@ -105,10 +115,32 @@ export class ExecutionEngine extends EventEmitter {
     mcpToolDefinitions = [];
     /** Performance optimizer (null if disabled) */
     perfOptimizer = null;
+    /**
+     * step / sub-agent 단위 토큰 예산 SSOT.
+     * - 최소 5k 보장
+     * - 병렬도 고려해서 전체 예산을 안전하게 분할
+     */
+    getSubAgentTokenBudget() {
+        const divisor = Math.max(1, this.config.maxParallelAgents + 1);
+        return Math.max(5000, Math.floor(this.config.totalTokenBudget / divisor));
+    }
     /** Sandbox manager for tool call validation (null if disabled) */
     sandboxManager = null;
+    /** Skill loader */
+    skillLoader;
+    /** Skill learner */
+    skillLearner;
+    /** Static + learned skill definitions */
+    skills;
+    /** Run-level skill context */
+    activeSkillContext = null;
+    /** Step resolved skills */
+    resolvedSkillsByStepId = new Map();
+    /** Global complexity inferred during analyze phase */
+    globalComplexity = "moderate";
     constructor(config) {
         super();
+        this.setMaxListeners(200);
         this.config = {
             byokConfig: config.byokConfig,
             projectPath: config.projectPath,
@@ -155,6 +187,15 @@ export class ExecutionEngine extends EventEmitter {
         });
         this.codebaseContext = null;
         this.vectorIndex = null;
+        const memoryCache = new Map();
+        this.embeddingCache = {
+            async get(key) {
+                return memoryCache.get(key) ?? null;
+            },
+            async set(key, embedding) {
+                memoryCache.set(key, embedding);
+            },
+        };
         this.stateMachine = null;
         this.planGraph = null;
         this.abortController = new AbortController();
@@ -163,6 +204,28 @@ export class ExecutionEngine extends EventEmitter {
         this.lastTermination = { reason: "USER_CANCELLED" };
         this.parallelStepResults = new Map();
         this.parallelExecutionDone = false;
+        this.skillLoader = new SkillLoader();
+        this.skillLearner = new SkillLearner(this.config.projectPath);
+        this.skills = config.skills ?? [];
+        this.activeSkillContext = null;
+        this.resolvedSkillsByStepId = new Map();
+        this.workspaceLock = new WorkspaceLock();
+        // Agent DAG orchestrator
+        this.dagOrchestrator = new DAGOrchestrator({
+            maxParallelAgents: this.config.maxParallelAgents,
+            maxRetries: 2,
+            tokenBudget: this.config.totalTokenBudget,
+            wallTimeLimit: 600000,
+            spawnAgent: this.spawnAgent.bind(this),
+        });
+        this.dagOrchestrator.on("dag:agent_reasoning", (e) => {
+            this.emit("agent:event", {
+                kind: "agent:reasoning_timeline",
+                source: "dag",
+                taskId: e.taskId,
+                text: e.text,
+            });
+        });
         // Store MCP server configs for use in execute()
         this.mcpServerConfigs = config.mcpServerConfigs ?? [];
         // Initialize PerfOptimizer if enabled
@@ -229,10 +292,21 @@ export class ExecutionEngine extends EventEmitter {
         this.planGraph = null;
         this.parallelStepResults = new Map();
         this.parallelExecutionDone = false;
+        this.resolvedSkillsByStepId.clear();
+        this.activeSkillContext = {
+            taskDescription: goal,
+        };
         this.emit("engine:start", goal);
         this._logger.logInput(goal);
         this.reflection.think("start", `Goal received: "${goal}"`);
         try {
+            // 0.5 Load learned skills
+            try {
+                await this.skillLearner.init();
+            }
+            catch (err) {
+                this._logger.warn("system", `SkillLearner init failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
+            }
             // 0. Intent inference pre-processing (refine ambiguous goals)
             if (this.config.enableIntentInference) {
                 try {
@@ -247,6 +321,10 @@ export class ExecutionEngine extends EventEmitter {
                         this._logger.info("system", `Intent inference: ambiguous input refined — "${goal}" → "${intentResult.refinedGoal}" (category: ${intentResult.category}, confidence: ${intentResult.confidence.toFixed(2)})`);
                         this.reflection.think("analyze", `Intent inference refined ambiguous goal: "${goal}" → "${intentResult.refinedGoal}" [${intentResult.category}, confidence=${intentResult.confidence.toFixed(2)}]`);
                         goal = intentResult.refinedGoal;
+                        this.activeSkillContext = {
+                            ...(this.activeSkillContext ?? {}),
+                            taskDescription: goal,
+                        };
                     }
                     else {
                         this._logger.info("system", `Intent inference: input is clear (category: ${intentResult.category}, confidence: ${intentResult.confidence.toFixed(2)})`);
@@ -267,24 +345,39 @@ export class ExecutionEngine extends EventEmitter {
                 this._logger.info("system", `Codebase indexed: ${stats.totalFiles} files, ${stats.totalSymbols} symbols`);
                 this.reflection.think("analyze", `Index built: ${stats.totalFiles} files, ${stats.totalSymbols} symbols`);
             }
-            // 1b. Conditional VectorIndex initialization (requires pgvector)
+            // 1b. VectorIndex initialization (pgvector semantic search)
             if (this.config.enableVectorSearch && !this.vectorIndex) {
-                // VectorIndex requires a real SQLExecutor and EmbeddingProvider.
-                // When no DB is available, create a no-op stub so the engine
-                // doesn't crash — vector search simply returns empty results.
-                const noopSqlExecutor = {
-                    query: async () => ({ rows: [] }),
-                };
-                const noopEmbeddingProvider = {
-                    embed: async (texts) => texts.map(() => []),
-                    dimension: 1536,
-                };
-                this.vectorIndex = new VectorIndex({
-                    projectId: this.config.projectPath,
-                    sqlExecutor: noopSqlExecutor,
-                    embeddingProvider: noopEmbeddingProvider,
-                });
-                this._logger.info("system", "VectorIndex initialized (no-op stub — supply real DB for pgvector search)");
+                try {
+                    const sqlExecutor = {
+                        query: async (sql, params) => {
+                            return this.config.toolExecutor.executeSQL
+                                ? await this.config.toolExecutor.executeSQL(sql, params)
+                                : { rows: [] };
+                        },
+                    };
+                    const embeddingProvider = {
+                        dimension: 1536,
+                        embed: async (texts) => {
+                            const results = [];
+                            for (const text of texts) {
+                                const resp = await this.llmClient.embed(text);
+                                results.push(resp.embedding);
+                            }
+                            return results;
+                        },
+                    };
+                    this.vectorIndex = new VectorIndex({
+                        projectId: path.basename(this.config.projectPath),
+                        sqlExecutor,
+                        embeddingProvider,
+                        embeddingCache: this.embeddingCache
+                    });
+                    await this.vectorIndex.initialize();
+                    this._logger.info("system", "VectorIndex initialized (pgvector semantic search enabled)");
+                }
+                catch (err) {
+                    this._logger.warn("system", `VectorIndex initialization failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
             }
             // 1c. MCP Client initialization (optional — connect to external MCP servers)
             if (this.mcpServerConfigs.length > 0) {
@@ -463,9 +556,19 @@ export class ExecutionEngine extends EventEmitter {
         if (complexityMatch) {
             complexity = complexityMatch[1].toLowerCase();
         }
+        this.globalComplexity =
+            complexity;
         this._logger.logDecision("Goal complexity assessment", ["trivial", "simple", "moderate", "complex", "massive"], complexity, `LLM analysis determined complexity based on goal and codebase context`);
         this.reflection.think("analyze", `Analysis complete — complexity: ${complexity}`);
+        this.activeSkillContext = {
+            ...(this.activeSkillContext ?? {}),
+            taskDescription: goal,
+        };
         exitAnalyze();
+        this.activeSkillContext = {
+            ...(this.activeSkillContext ?? {}),
+            taskDescription: goal,
+        };
         return { complexity, context: content };
     }
     /**
@@ -557,6 +660,28 @@ Exactly one approach should have recommended=true.`;
                 `${hPlan.totalEstimatedIterations} estimated iterations, ` +
                 `${hPlan.parallelizableGroups.length} parallel groups`);
             const executionPlan = planner.toExecutionPlan(hPlan);
+            for (const step of executionPlan.steps) {
+                const stepSkillContext = {
+                    ...(this.activeSkillContext ?? {}),
+                    taskDescription: step.goal,
+                    filePath: step.targetFiles[0],
+                };
+                const matched = this.skillLoader.matchTriggers(this.skills, stepSkillContext);
+                const learned = this.skillLearner
+                    .getRelevantSkills({
+                    filePath: step.targetFiles[0],
+                })
+                    .map((s) => this.skillLearner.toSkillDefinition(s));
+                const combined = [...matched, ...learned];
+                const deduped = new Map();
+                for (const skill of combined) {
+                    deduped.set(skill.id, skill);
+                }
+                const resolvedSkills = [...deduped.values()].map((skill) => this.skillLoader.loadTemplate(skill));
+                step.skillIds = resolvedSkills.map((s) => s.definition.id);
+                step.resolvedSkills = resolvedSkills;
+                this.resolvedSkillsByStepId.set(step.id, resolvedSkills);
+            }
             // Initialize PlanGraphManager for step progress tracking
             this.planGraph = PlanGraphManager.fromExecutionPlan(this.sessionId, executionPlan);
             this._logger.info("system", `PlanGraph initialized: ${executionPlan.steps.length} nodes, ${this.planGraph.getState().parallelGroups.length} parallel groups`);
@@ -574,7 +699,10 @@ Exactly one approach should have recommended=true.`;
                     id: "step-1",
                     goal: `${approach.description}: ${goal}`,
                     targetFiles: [],
+                    role: "coder",
                     readFiles: [],
+                    skillIds: [],
+                    resolvedSkills: [],
                     tools: ["file_read", "file_write", "file_edit", "grep", "glob"],
                     estimatedIterations: 10,
                     dependsOn: [],
@@ -582,6 +710,25 @@ Exactly one approach should have recommended=true.`;
             ],
             estimatedTokens: 50_000,
         };
+        {
+            const step = fallbackPlan.steps[0];
+            const stepSkillContext = {
+                ...(this.activeSkillContext ?? {}),
+                taskDescription: step.goal,
+            };
+            const matched = this.skillLoader.matchTriggers(this.skills, stepSkillContext);
+            const learned = this.skillLearner
+                .getRelevantSkills({})
+                .map((s) => this.skillLearner.toSkillDefinition(s));
+            const combined = [...matched, ...learned];
+            const deduped = new Map();
+            for (const skill of combined)
+                deduped.set(skill.id, skill);
+            const resolvedSkills = [...deduped.values()].map((skill) => this.skillLoader.loadTemplate(skill));
+            step.skillIds = resolvedSkills.map((s) => s.definition.id);
+            step.resolvedSkills = resolvedSkills;
+            this.resolvedSkillsByStepId.set(step.id, resolvedSkills);
+        }
         // Initialize PlanGraphManager for fallback plan too
         this.planGraph = PlanGraphManager.fromExecutionPlan(this.sessionId, fallbackPlan);
         this._logger.info("system", `PlanGraph initialized (fallback): 1 node`);
@@ -629,7 +776,47 @@ Exactly one approach should have recommended=true.`;
             };
         }
         // First call triggers full DAG execution for ALL steps
-        await this.executeStepsWithDAG(plan, state);
+        if (!this.dagOrchestrator) {
+            throw new Error("DAGOrchestrator not initialized");
+        }
+        const agentPlan = {
+            tasks: plan.steps.map((s, i) => ({
+                id: s.id,
+                goal: s.goal,
+                targetFiles: s.targetFiles,
+                readFiles: s.readFiles,
+                tools: s.tools,
+                estimatedIterations: s.estimatedIterations,
+                priority: plan.steps.length - i,
+                complexity: state.workingMemory.get("complexity") ?? "moderate",
+                role: s.role ?? "coder",
+                skillIds: s.skillIds ?? [],
+                resolvedSkills: s.resolvedSkills ?? this.resolvedSkillsByStepId.get(s.id) ?? [],
+            })),
+            estimatedTokens: plan.estimatedTokens,
+            estimatedDurationMs: plan.steps.reduce((sum, s) => sum + s.estimatedIterations * 1000, 0),
+            dependencies: plan.steps.flatMap((s) => (s.dependsOn ?? []).map((dep) => [dep, s.id])),
+            maxParallelAgents: this.config.maxParallelAgents,
+        };
+        const dagResult = await this.dagOrchestrator.execute(agentPlan, {
+            overallGoal: plan.goal,
+            projectPath: this.config.projectPath,
+            projectStructure: this.config.projectPath,
+        });
+        for (const task of dagResult.completedTasks) {
+            const stepIndex = plan.steps.findIndex(s => s.id === task.taskId);
+            if (stepIndex >= 0) {
+                this.parallelStepResults.set(stepIndex, {
+                    stepIndex,
+                    phase: "implement",
+                    success: true,
+                    output: task.summary,
+                    changedFiles: task.changedFiles.map((f) => f.path),
+                    tokensUsed: task.tokensUsed,
+                    durationMs: 0
+                });
+            }
+        }
         this.parallelExecutionDone = true;
         // Return this step's result from cache
         const result = this.parallelStepResults.get(stepIndex);
@@ -758,6 +945,11 @@ Exactly one approach should have recommended=true.`;
         }
         const exitImplement = this._logger.enterLayer("implement", `Step ${stepIndex + 1}/${plan.steps.length}: "${step.goal}"`);
         this.reflection.think("implement", `Executing step ${stepIndex + 1}/${plan.steps.length}: "${step.goal}"`);
+        const stepSkillContext = {
+            ...(this.activeSkillContext ?? {}),
+            taskDescription: step.goal,
+            filePath: step.targetFiles[0],
+        };
         // Mark step as running in PlanGraph
         const stepId = step.id;
         if (this.planGraph) {
@@ -793,12 +985,21 @@ Exactly one approach should have recommended=true.`;
                     "speculative:approach:complete",
                     "speculative:evaluation",
                     "speculative:complete",
+                    "speculative:timeline",
                 ];
                 for (const eventName of specEvents) {
                     specExecutor.on(eventName, (...args) => {
                         this.emit(eventName, ...args);
                     });
                 }
+                specExecutor.on("speculative:timeline", (payload) => {
+                    this.emit("agent:event", {
+                        kind: "agent:reasoning_timeline",
+                        source: "speculative",
+                        taskId: payload.taskId,
+                        text: payload.text,
+                    });
+                });
                 // Build codebase context summary for speculative executor
                 let codebaseContextSummary = "";
                 if (this.codebaseContext) {
@@ -848,40 +1049,88 @@ Exactly one approach should have recommended=true.`;
             }
         }
         // ─── Normal AgentLoop Execution ─────────────────────────────
-        // Build step-specific system prompt
-        const systemPrompt = this.buildStepPrompt(plan, step, stepIndex);
-        // Create and run AgentLoop for this step
-        const loop = this.createAgentLoop(systemPrompt);
-        this.wireAgentLoopEvents(loop);
+        // ─────────────────────────────────────────
+        // SubAgent execution
+        // ─────────────────────────────────────────
         const startMs = Date.now();
-        const termination = await loop.run(step.goal);
+        const routing = routeSubAgent({
+            role: step.role ?? "coder",
+            complexity: state.workingMemory.get("complexity") ?? "moderate",
+            fileCount: step.targetFiles.length,
+            hasTests: step.tools.includes("test_run"),
+            isCriticalPath: false,
+            previousFailures: 0,
+            parentModelTier: "NORMAL"
+        });
+        const role = step.role ?? "coder";
+        const tier = routing.tier;
+        const subAgent = new SubAgent({
+            taskId: step.id,
+            goal: step.goal,
+            targetFiles: step.targetFiles,
+            readFiles: step.readFiles,
+            maxIterations: this.config.maxIterations,
+            totalTokenBudget: this.getSubAgentTokenBudget(),
+            projectPath: this.config.projectPath,
+            byokConfig: this.config.byokConfig,
+            tools: step.tools,
+            createToolExecutor: () => this.config.toolExecutor,
+            role,
+            parentModelTier: tier,
+        });
+        const agentRole = subAgent.role;
+        // ─────────────────────────────────────────
+        // SubAgent lifecycle forwarding (CLI stream)
+        // ─────────────────────────────────────────
+        subAgent.on("subagent:phase", (_taskId, phase) => {
+            this.emit("agent:subagent_phase", {
+                role: agentRole,
+                phase,
+                taskId: step.id,
+                goal: step.goal,
+            });
+        });
+        // ─────────────────────────────────────────
+        // Forward SubAgent events → ExecutionEngine
+        // ─────────────────────────────────────────
+        subAgent.on("event", (event) => {
+            this.emit("agent:event", event);
+        });
+        const subResult = await subAgent.run({
+            overallGoal: plan.goal,
+            taskGoal: step.goal,
+            targetFiles: step.targetFiles,
+            readFiles: step.readFiles,
+            projectStructure: this.config.projectPath,
+            skillContext: stepSkillContext,
+            resolvedSkills: step.resolvedSkills ?? this.resolvedSkillsByStepId.get(step.id) ?? [],
+            totalTasks: plan.steps.length,
+            completedTasks: [],
+            runningTasks: [],
+        });
         const durationMs = Date.now() - startMs;
-        // Track last termination
-        this.lastTermination = termination;
-        // Collect changed files from loop
-        const loopUsage = loop.getTokenUsage();
-        const stepChangedFiles = [];
-        // Extract changed files from agent events (tracked via tool results)
-        // The changedFiles set is updated via wireAgentLoopEvents
+        const stepChangedFiles = new Set(subResult.changedFiles.map((f) => typeof f === "string" ? f : f.path));
+        const loopUsage = {
+            input: subResult.tokensUsed?.input ?? 0,
+            output: subResult.tokensUsed?.output ?? 0,
+        };
+        const success = subResult.success;
         for (const file of this.changedFiles) {
-            if (step.targetFiles.includes(file) || step.targetFiles.length === 0) {
-                stepChangedFiles.push(file);
+            if (step.targetFiles.length === 0)
+                continue;
+            if (step.targetFiles.some(f => file.endsWith(f))) {
+                stepChangedFiles.add(file);
             }
         }
-        const success = termination.reason === "GOAL_ACHIEVED";
         // Update PlanGraph with step outcome
         if (this.planGraph) {
             try {
                 if (success) {
-                    this.planGraph.markCompleted(stepId, termination.reason === "GOAL_ACHIEVED"
-                        ? termination.summary
-                        : "completed", stepChangedFiles, { input: loopUsage.input, output: loopUsage.output });
+                    this.planGraph.markCompleted(stepId, subResult.summary, [...stepChangedFiles], { input: loopUsage.input, output: loopUsage.output });
                     this._logger.info("system", `PlanGraph: node "${stepId}" → completed`);
                 }
                 else {
-                    const errorMsg = termination.reason === "ERROR"
-                        ? termination.error
-                        : `Step failed: ${termination.reason}`;
+                    const errorMsg = subResult.error ?? "SubAgent failed";
                     this.planGraph.markFailed(stepId, errorMsg);
                     this._logger.info("system", `PlanGraph: node "${stepId}" → failed`);
                 }
@@ -893,10 +1142,8 @@ Exactly one approach should have recommended=true.`;
             const progress = this.planGraph.getProgress();
             this._logger.info("system", `PlanGraph progress: ${progress.completed}/${progress.total} (${progress.percent}%)`);
         }
-        this._logger.logDecision(`Step ${stepIndex + 1} outcome`, ["succeeded", "failed"], success ? "succeeded" : "failed", `AgentLoop terminated with reason: ${termination.reason}`);
-        this.reflection.think("implement", `Step ${stepIndex + 1} ${success ? "succeeded" : "failed"}: ${termination.reason === "GOAL_ACHIEVED"
-            ? termination.summary
-            : termination.reason}`);
+        this._logger.logDecision(`Step ${stepIndex + 1} outcome`, ["succeeded", "failed"], success ? "succeeded" : "failed", `SubAgent execution result`);
+        this.reflection.think("implement", `Step ${stepIndex + 1} ${success ? "succeeded" : "failed"}: ${subResult.summary}`);
         // Checkpoint after step completes (success or failure)
         await this.checkpoint(stepIndex);
         exitImplement();
@@ -904,12 +1151,8 @@ Exactly one approach should have recommended=true.`;
             stepIndex,
             phase: "implement",
             success,
-            output: termination.reason === "GOAL_ACHIEVED"
-                ? termination.summary
-                : termination.reason === "ERROR"
-                    ? termination.error
-                    : `Terminated: ${termination.reason}`,
-            changedFiles: stepChangedFiles,
+            output: subResult.summary,
+            changedFiles: [...stepChangedFiles],
             tokensUsed: loopUsage.input + loopUsage.output,
             durationMs,
         };
@@ -1109,6 +1352,28 @@ Exactly one approach should have recommended=true.`;
             }
         }
         exitVerify();
+        // Best-effort learned skill persistence hook
+        try {
+            const syntheticAnalysis = {
+                errorPatterns: deepResult.suggestedFixes
+                    .filter((f) => !!f.description)
+                    .map((f) => ({
+                    message: f.description,
+                    resolution: f.description,
+                    frequency: 1,
+                    type: "VerificationIssue",
+                    tool: "verify",
+                })),
+                toolPatterns: [],
+            };
+            const learned = this.skillLearner.extractSkillFromRun(syntheticAnalysis, this.sessionId);
+            if (learned) {
+                await this.skillLearner.save();
+            }
+        }
+        catch (err) {
+            this._logger.warn("system", `Skill learn/save failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
+        }
         // Map DeepVerifyResult → VerifyResult
         return this.mapVerifyResult(deepResult);
     }
@@ -1277,6 +1542,62 @@ ${[...this.changedFiles].join(", ")}
             }
         }
     }
+    /**
+     * DAGOrchestrator가 호출하는 Agent worker
+     */
+    async spawnAgent(task, context, _signal) {
+        const routing = routeSubAgent({
+            role: task.role ?? "coder",
+            complexity: this.globalComplexity,
+            fileCount: task.targetFiles.length,
+            hasTests: task.tools?.includes("test_run") ?? false,
+            isCriticalPath: false,
+            previousFailures: 0,
+            parentModelTier: "NORMAL"
+        });
+        const role = task.role ?? "coder";
+        const subAgent = new SubAgent({
+            taskId: task.id,
+            goal: task.goal,
+            targetFiles: task.targetFiles,
+            readFiles: task.readFiles,
+            maxIterations: this.config.maxIterations,
+            totalTokenBudget: this.getSubAgentTokenBudget(),
+            projectPath: this.config.projectPath,
+            byokConfig: this.config.byokConfig,
+            tools: task.tools,
+            createToolExecutor: () => this.config.toolExecutor,
+            role,
+            parentModelTier: routing.tier,
+        });
+        const result = await subAgent.run({
+            overallGoal: context.overallGoal,
+            taskGoal: context.taskGoal ?? task.goal,
+            targetFiles: context.targetFiles ?? task.targetFiles,
+            readFiles: context.readFiles ?? task.readFiles,
+            projectStructure: context.projectStructure,
+            skillContext: context.skillContext ?? {
+                taskDescription: task.goal,
+                filePath: task.targetFiles[0],
+            },
+            resolvedSkills: context.resolvedSkills ?? task.resolvedSkills ?? [],
+            totalTasks: 1,
+            completedTasks: [],
+            runningTasks: [],
+        });
+        return {
+            taskId: task.id,
+            summary: result.summary,
+            changedFiles: result.changedFiles.map((file) => ({
+                path: typeof file === "string" ? file : file.path,
+                diff: "",
+            })),
+            tokensUsed: (result.tokensUsed?.input ?? 0) +
+                (result.tokensUsed?.output ?? 0),
+            iterations: this.config.maxIterations,
+            usedSkillIds: task.skillIds ?? [],
+        };
+    }
     /**
      * 개별 step 실행을 위한 AgentLoop 인스턴스를 생성한다.
      *
@@ -1285,9 +1606,12 @@ ${[...this.changedFiles].join(", ")}
      */
     createAgentLoop(systemPrompt) {
         // Merge base tool definitions with MCP tool definitions
+        // Tool filtering to avoid token explosion
+        const baseTools = this.config.toolExecutor.definitions;
+        const mcpToolsFiltered = this.mcpToolDefinitions.filter((t) => true);
         const tools = [
-            ...this.config.toolExecutor.definitions,
-            ...this.mcpToolDefinitions,
+            ...baseTools,
+            ...mcpToolsFiltered,
         ];
         // Wrap tool executor to add sandbox validation and MCP tool routing
         const baseExecutor = this.config.toolExecutor;
@@ -1297,44 +1621,77 @@ ${[...this.changedFiles].join(", ")}
         const wrappedExecutor = {
             definitions: tools,
             execute: async (call, abortSignal) => {
-                // Parse arguments to object if needed
-                let args;
+                let args = {};
+                let release = null;
                 try {
-                    args = typeof call.arguments === "string"
-                        ? JSON.parse(call.arguments)
-                        : call.arguments;
-                }
-                catch {
-                    return {
-                        tool_call_id: call.id,
-                        name: call.name,
-                        output: `[Error] Invalid JSON in tool arguments: ${String(call.arguments).slice(0, 200)}`,
-                        success: false,
-                        durationMs: 0,
-                    };
-                }
-                // Sandbox pre-validation
-                if (sandboxMgr) {
-                    const validation = sandboxMgr.validateToolCall(call.name, args);
-                    if (!validation.allowed) {
+                    // Parse arguments to object if needed
+                    try {
+                        args = typeof call.arguments === "string"
+                            ? JSON.parse(call.arguments)
+                            : call.arguments;
+                    }
+                    catch {
                         return {
                             tool_call_id: call.id,
                             name: call.name,
-                            output: `[Sandbox blocked] ${validation.violations.join("; ")}`,
+                            output: "[Error] invalid tool arguments JSON",
                             success: false,
                             durationMs: 0,
                         };
                     }
+                    const targetFile = typeof args?.path === "string"
+                        ? args.path
+                        : typeof args?.file === "string"
+                            ? args.file
+                            : null;
+                    if (targetFile && this.isFileMutationTool(call.name)) {
+                        release = await this.workspaceLock.acquire(targetFile);
+                    }
+                    // Sandbox pre-validation
+                    if (sandboxMgr) {
+                        const validation = sandboxMgr.validateToolCall(call.name, args);
+                        if (!validation.allowed) {
+                            return {
+                                tool_call_id: call.id,
+                                name: call.name,
+                                output: `[Sandbox blocked] ${validation.violations.join("; ")}`,
+                                success: false,
+                                durationMs: 0,
+                            };
+                        }
+                    }
+                    // Route MCP tool calls to MCPClient (check MCP registry, not string pattern)
+                    if (mcpCli && mcpToolDefs.some((t) => t.name === call.name)) {
+                        const MCP_TIMEOUT = 20000;
+                        const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("MCP timeout")), MCP_TIMEOUT));
+                        try {
+                            return (await Promise.race([
+                                mcpCli.callToolAsYuan(call.name, args, call.id),
+                                timeout,
+                            ]));
+                        }
+                        catch (err) {
+                            return {
+                                tool_call_id: call.id,
+                                name: call.name,
+                                output: `[MCP error] ${err instanceof Error ? err.message : String(err)}`,
+                                success: false,
+                                durationMs: MCP_TIMEOUT,
+                            };
+                        }
+                    }
+                    // Default: use base executor
+                    return await baseExecutor.execute(call, abortSignal);
                 }
-                // Route MCP tool calls to MCPClient (check MCP registry, not string pattern)
-                if (mcpCli && mcpToolDefs.some((t) => t.name === call.name)) {
-                    return mcpCli.callToolAsYuan(call.name, args, call.id);
+                finally {
+                    if (release) {
+                        release();
+                    }
                 }
-                // Default: use base executor
-                return baseExecutor.execute(call, abortSignal);
             },
         };
         return new AgentLoop({
+            abortSignal: this.abortController.signal,
             config: {
                 byok: this.config.byokConfig,
                 loop: {
@@ -1491,6 +1848,17 @@ Then provide your analysis.`;
             confidence: deep.confidence,
         };
     }
+    isFileMutationTool(toolName) {
+        const mutationTools = new Set([
+            "file_write",
+            "file_edit",
+            "file_delete",
+            "file_move",
+            "file_rename",
+            "apply_patch",
+        ]);
+        return mutationTools.has(toolName);
+    }
     /**
      * StateMachine 최종 상태에서 ExecutionResult를 생성한다.
      *
@@ -1546,13 +1914,15 @@ Then provide your analysis.`;
             return fenced[1].trim();
         }
         // Find first JSON array or object
-        const arrayMatch = content.match(/\[[\s\S]*\]/);
-        if (arrayMatch) {
-            return arrayMatch[0];
+        const start = content.indexOf("[");
+        const end = content.lastIndexOf("]");
+        if (start !== -1 && end !== -1 && end > start) {
+            return content.slice(start, end + 1);
         }
-        const objectMatch = content.match(/\{[\s\S]*\}/);
-        if (objectMatch) {
-            return objectMatch[0];
+        const objStart = content.indexOf("{");
+        const objEnd = content.lastIndexOf("}");
+        if (objStart !== -1 && objEnd !== -1 && objEnd > objStart) {
+            return content.slice(objStart, objEnd + 1);
         }
         return content.trim();
     }