@yuaone/core 0.4.4 → 0.4.6

package/dist/agent-loop.js

@@ -45,6 +45,9 @@ import { RepoKnowledgeGraph } from "./repo-knowledge-graph.js";
 import { BackgroundAgentManager } from "./background-agent.js";
 import { ReasoningAggregator } from "./reasoning-aggregator.js";
 import { ReasoningTree } from "./reasoning-tree.js";
+import { ContextCompressor } from "./context-compressor.js";
+import { DependencyAnalyzer } from "./dependency-analyzer.js";
+import { CrossFileRefactor } from "./cross-file-refactor.js";
 /**
  * AgentLoop — YUAN 에이전트의 핵심 실행 루프.
  *
@@ -746,6 +749,57 @@ export class AgentLoop extends EventEmitter {
                     });
                 }
             }
+            // CrossFileRefactor: detect rename/move intent and inject preview hint
+            if (this.config.loop.projectPath) {
+                try {
+                    const renameMatch = userMessage.match(/\brename\s+[`'"]?(\w[\w.]*)[`'"]?\s+to\s+[`'"]?(\w[\w.]*)[`'"]/i);
+                    const moveMatch = userMessage.match(/\bmove\s+[`'"]?([\w./\\-]+)[`'"]?\s+to\s+[`'"]?([\w./\\-]+)[`'"]/i);
+                    if (renameMatch) {
+                        const [, symbolName, newName] = renameMatch;
+                        const refactor = new CrossFileRefactor(this.config.loop.projectPath);
+                        const preview = await refactor.renameSymbol(symbolName, newName);
+                        if (preview.totalChanges > 0) {
+                            const affectedList = preview.affectedFiles
+                                .map((f) => `  - ${f.file} (${f.changes.length} change(s))`)
+                                .join("\n");
+                            this.contextManager.addMessage({
+                                role: "system",
+                                content: `[CrossFileRefactor] Rename "${symbolName}" → "${newName}" preview:\n` +
+                                    `Risk: ${preview.riskLevel}, Files affected: ${preview.affectedFiles.length}\n` +
+                                    affectedList +
+                                    (preview.warnings.length > 0
+                                        ? `\nWarnings: ${preview.warnings.join("; ")}`
+                                        : ""),
+                            });
+                            this.iterationSystemMsgCount++;
+                        }
+                    }
+                    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
+                                .map((f) => `  - ${f.file} (${f.changes.length} change(s))`)
+                                .join("\n");
+                            this.contextManager.addMessage({
+                                role: "system",
+                                content: `[CrossFileRefactor] Move "${symbolOrFile}" → "${destination}" preview:\n` +
+                                    `Risk: ${preview.riskLevel}, Files affected: ${preview.affectedFiles.length}\n` +
+                                    affectedList +
+                                    (preview.warnings.length > 0
+                                        ? `\nWarnings: ${preview.warnings.join("; ")}`
+                                        : ""),
+                            });
+                            this.iterationSystemMsgCount++;
+                        }
+                    }
+                }
+                catch {
+                    // CrossFileRefactor preview failure is non-fatal
+                }
+            }
             // 복잡도 감지 → 필요 시 자동 플래닝
             await this.maybeCreatePlan(userMessage);
             // ContinuousReflection 시작 (1분 간격 체크포인트/자기검증/컨텍스트모니터)
@@ -868,10 +922,29 @@ export class AgentLoop extends EventEmitter {
             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({
+                        name: `tool:${pattern.tool}`,
+                        description: `success ${Math.round(pattern.successRate * 100)}%, avg ${pattern.avgDurationMs}ms`,
+                        files: this.changedFiles.slice(0, 5),
+                        frequency: pattern.count,
+                    });
+                }
+            }
             // 에러로 종료된 경우 실패 기록도 추가
             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();
         }
@@ -1045,11 +1118,16 @@ export class AgentLoop extends EventEmitter {
         const complexity = this.detectComplexity(userMessage);
         this.currentComplexity = complexity;
         // 임계값 미만이면 플래닝 스킵
-        const thresholdOrder = { simple: 1, moderate: 2, complex: 3 };
+        // 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,
         };
-        if ((complexityOrder[complexity] ?? 0) < thresholdOrder[this.planningThreshold]) {
+        // Use the threshold for the configured level; "complex" threshold activates for complexity >= "complex"
+        const effectiveThreshold = thresholdOrder[this.planningThreshold] ?? 2;
+        if ((complexityOrder[complexity] ?? 0) < effectiveThreshold) {
             return;
         }
         this.emitSubagent("planner", "start", `task complexity ${complexity}. creating execution plan`);
@@ -1078,6 +1156,40 @@ 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;
+        try {
+            const { existsSync } = require("node:fs");
+            // Check for package.json with a "test" script
+            const pkgPath = `${projectPath}/package.json`;
+            if (existsSync(pkgPath)) {
+                try {
+                    const pkg = JSON.parse(require("node:fs").readFileSync(pkgPath, "utf-8"));
+                    const scripts = pkg.scripts;
+                    if (scripts?.test && scripts.test !== "echo \"Error: no test specified\" && exit 1") {
+                        // Prefer pnpm if pnpm-lock.yaml exists
+                        const usesPnpm = existsSync(`${projectPath}/pnpm-lock.yaml`);
+                        return usesPnpm ? "pnpm test" : "npm test";
+                    }
+                }
+                catch {
+                    // package.json parse failure — fall through
+                }
+            }
+            // Check for tsconfig.json → TypeScript type check
+            if (existsSync(`${projectPath}/tsconfig.json`)) {
+                return "npx tsc --noEmit";
+            }
+        }
+        catch {
+            // Require/existsSync failure in unusual environments — use default
+        }
+        return "pnpm build";
+    }
     detectComplexity(message) {
         const lower = message.toLowerCase();
         const len = message.length;
@@ -1280,6 +1392,39 @@ export class AgentLoop extends EventEmitter {
             // Soft context rollover:
             // checkpoint first, then let ContextManager compact instead of aborting/throwing.
             const contextUsageRatio = this.contextManager.getUsageRatio();
+            // Bug 5 fix: use ContextCompressor as an alternative when context pressure is high (>70%)
+            // At 70-84% we apply intelligent priority-based compression before falling back to truncation.
+            if (contextUsageRatio >= 0.70 && contextUsageRatio < 0.85) {
+                try {
+                    // Estimate maxTokens from the usage ratio and current message count
+                    // contextUsageRatio = estimatedTokens / (maxTokens - outputReserve)
+                    // We use a conservative 128_000 as a safe upper bound
+                    const estimatedMaxTokens = 128_000;
+                    const contextCompressor = new ContextCompressor({
+                        maxTokens: estimatedMaxTokens,
+                        reserveTokens: Math.ceil(estimatedMaxTokens * 0.15),
+                    });
+                    const currentMessages = this.contextManager.getMessages();
+                    const currentTokenEstimate = Math.ceil(estimatedMaxTokens * contextUsageRatio);
+                    const compressed = contextCompressor.compress(currentMessages, currentTokenEstimate);
+                    if (compressed.evicted > 0 || compressed.summarized > 0) {
+                        // Replace messages in contextManager with compressed version
+                        // by clearing and re-adding (contextManager.addMessages is the public API)
+                        const internalMessages = this.contextManager.messages;
+                        if (internalMessages) {
+                            internalMessages.length = 0;
+                            internalMessages.push(...compressed.messages);
+                        }
+                        this.emitEvent({
+                            kind: "agent:thinking",
+                            content: `Context pressure ${Math.round(contextUsageRatio * 100)}%: ContextCompressor applied (evicted ${compressed.evicted}, summarized ${compressed.summarized} messages).`,
+                        });
+                    }
+                }
+                catch {
+                    // ContextCompressor failure is non-fatal; ContextManager will handle via compactHistory
+                }
+            }
             if (contextUsageRatio >= 0.85) {
                 if (!this.checkpointSaved) {
                     await this.saveAutoCheckpoint(iteration);
@@ -1659,8 +1804,11 @@ 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, {
-                                testCommand: "pnpm build",
+                                testCommand: testCmd,
                                 errorOutput: errorSummary,
                                 changedFiles: this.changedFiles,
                                 originalSnapshots: this.originalSnapshots,
@@ -1668,6 +1816,30 @@ 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.selfDebugLoop.debug({
+                                    testCommand: testCmd,
+                                    errorOutput: errorSummary,
+                                    changedFiles: this.changedFiles,
+                                    originalSnapshots: this.originalSnapshots,
+                                    toolExecutor: this.toolExecutor,
+                                    llmFixer: async (prompt) => {
+                                        try {
+                                            const response = await this.llmClient.chat([
+                                                { role: "system", content: "You are an expert debugging assistant. Analyze the error and provide tool calls to fix it." },
+                                                { role: "user", content: prompt },
+                                            ], []);
+                                            return response.content ?? "";
+                                        }
+                                        catch {
+                                            return "";
+                                        }
+                                    },
+                                }).catch(() => {
+                                    // selfDebugLoop.debug() failures are non-fatal — recovery continues
+                                });
+                            }
                         }
                     }
                     this.contextManager.addMessage({
@@ -1921,256 +2093,345 @@ export class AgentLoop extends EventEmitter {
      * 3. 도구 실행
      * 4. AutoFixLoop 결과 검증 → 실패 시 에러 피드백 메시지 추가
      */
-    async executeTools(toolCalls) {
-        if (toolCalls.length > 1)
-            this.emitReasoning(`parallel tool batch started (${toolCalls.length} tools)`);
-        const results = [];
-        const deferredFixPrompts = [];
-        for (const toolCall of toolCalls) {
-            const args = this.parseToolArgs(toolCall.arguments);
-            const allDefinitions = [...this.config.loop.tools, ...this.mcpToolDefinitions];
-            const matchedDefinition = allDefinitions.find((t) => t.name === toolCall.name);
-            // Governor: 안전성 검증
-            try {
-                this.governor.validateToolCall(toolCall);
-            }
-            catch (err) {
-                if (err instanceof ApprovalRequiredError) {
-                    // Governor가 위험 감지 → ApprovalManager로 승인 프로세스 위임
-                    const approvalResult = await this.handleApproval(toolCall, args, err);
-                    if (approvalResult) {
-                        results.push(approvalResult);
-                        continue;
-                    }
-                    // 승인됨 → 계속 실행
-                }
-                // Generic tool-definition approval gate
-                if (matchedDefinition?.requiresApproval) {
-                    const definitionApprovalReq = {
-                        id: `definition-approval-${toolCall.id}`,
-                        toolName: toolCall.name,
-                        arguments: args,
-                        reason: matchedDefinition.source === "mcp"
-                            ? `MCP tool "${toolCall.name}" requires approval`
-                            : `Tool "${toolCall.name}" requires approval`,
-                        riskLevel: matchedDefinition.riskLevel === "critical" ||
-                            matchedDefinition.riskLevel === "high"
-                            ? "high"
-                            : "medium",
-                        timeout: 120_000,
-                    };
-                    const definitionApprovalResult = await this.handleApprovalRequest(toolCall, definitionApprovalReq);
-                    if (definitionApprovalResult) {
-                        results.push(definitionApprovalResult);
-                        continue;
-                    }
-                }
-                else {
-                    throw err;
-                }
-            }
-            // ApprovalManager: 추가 승인 체크 (Governor가 못 잡은 규칙)
-            const approvalRequest = this.approvalManager.checkApproval(toolCall.name, args);
-            if (approvalRequest) {
-                const approvalResult = await this.handleApprovalRequest(toolCall, approvalRequest);
+    /**
+     * Execute a single tool call (extracted helper for parallel execution support).
+     */
+    async executeSingleTool(toolCall, toolCalls) {
+        const args = this.parseToolArgs(toolCall.arguments);
+        const allDefinitions = [...this.config.loop.tools, ...this.mcpToolDefinitions];
+        const matchedDefinition = allDefinitions.find((t) => t.name === toolCall.name);
+        // Governor: 안전성 검증
+        try {
+            this.governor.validateToolCall(toolCall);
+        }
+        catch (err) {
+            if (err instanceof ApprovalRequiredError) {
+                const approvalResult = await this.handleApproval(toolCall, args, err);
                 if (approvalResult) {
-                    results.push(approvalResult);
-                    continue;
+                    return { result: approvalResult, deferredFixPrompt: null };
                 }
                 // 승인됨 → 계속 실행
             }
-            // 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}`,
+            // Generic tool-definition approval gate
+            if (matchedDefinition?.requiresApproval) {
+                const definitionApprovalReq = {
+                    id: `definition-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",
+                    reason: matchedDefinition.source === "mcp"
+                        ? `MCP tool "${toolCall.name}" requires approval`
+                        : `Tool "${toolCall.name}" requires approval`,
+                    riskLevel: matchedDefinition.riskLevel === "critical" ||
+                        matchedDefinition.riskLevel === "high"
+                        ? "high"
+                        : "medium",
                     timeout: 120_000,
                 };
-                const pluginApprovalResult = await this.handleApprovalRequest(toolCall, pluginApprovalReq);
-                if (pluginApprovalResult) {
-                    results.push(pluginApprovalResult);
-                    continue;
+                const definitionApprovalResult = await this.handleApprovalRequest(toolCall, definitionApprovalReq);
+                if (definitionApprovalResult) {
+                    return { result: definitionApprovalResult, deferredFixPrompt: null };
                 }
-                // Approved → proceed with execution
             }
-            // MCP 도구 호출 확인
-            if (this.mcpClient && this.isMCPTool(toolCall.name)) {
-                const mcpResult = await this.executeMCPTool(toolCall);
-                results.push(mcpResult);
-                this.emitEvent({
-                    kind: "agent:tool_result",
-                    tool: toolCall.name,
-                    output: mcpResult.output.length > 200
-                        ? mcpResult.output.slice(0, 200) + "..."
-                        : mcpResult.output,
-                    durationMs: mcpResult.durationMs,
-                });
-                this.emitEvent({
-                    kind: "agent:reasoning_delta",
-                    text: `tool finished: ${toolCall.name}`,
-                });
-                continue;
+            else if (err instanceof ApprovalRequiredError) {
+                // already handled above
             }
-            // 도구 실행 — AbortController를 InterruptManager에 등록
-            const startTime = Date.now();
-            const toolAbort = new AbortController();
-            this.interruptManager.registerToolAbort(toolAbort);
-            // rollback용 원본 스냅샷은 실행 전에 저장
-            if (["file_write", "file_edit"].includes(toolCall.name)) {
-                const candidatePath = args.path ??
-                    args.file;
-                if (candidatePath) {
-                    const filePathStr = String(candidatePath);
-                    if (!this.originalSnapshots.has(filePathStr)) {
-                        try {
-                            const { readFile } = await import("node:fs/promises");
-                            const original = await readFile(filePathStr, "utf-8");
-                            this.originalSnapshots.set(filePathStr, original);
-                        }
-                        catch (err) {
-                            if (err.code !== "ENOENT") {
-                                throw err;
-                            }
-                        }
-                    }
-                }
+            else {
+                throw err;
             }
-            try {
-                const result = await this.toolExecutor.execute(toolCall, toolAbort?.signal);
-                this.interruptManager.clearToolAbort();
-                // Learned skill confidence feedback
-                // 성공한 실행 결과/도구명/출력에 매칭되는 learned skill이 있으면 confidence 갱신
-                if (this.skillLearner) {
+        }
+        // ApprovalManager: 추가 승인 체크
+        const approvalRequest = this.approvalManager.checkApproval(toolCall.name, args);
+        if (approvalRequest) {
+            const approvalResult = await this.handleApprovalRequest(toolCall, approvalRequest);
+            if (approvalResult) {
+                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 &&
+            (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) {
+                return { result: pluginApprovalResult, deferredFixPrompt: null };
+            }
+        }
+        // MCP 도구 호출 확인
+        if (this.mcpClient && this.isMCPTool(toolCall.name)) {
+            const mcpResult = await this.executeMCPTool(toolCall);
+            this.emitEvent({
+                kind: "agent:tool_result",
+                tool: toolCall.name,
+                output: mcpResult.output.length > 200
+                    ? mcpResult.output.slice(0, 200) + "..."
+                    : mcpResult.output,
+                durationMs: mcpResult.durationMs,
+            });
+            this.emitEvent({ kind: "agent:reasoning_delta", text: `tool finished: ${toolCall.name}` });
+            return { result: mcpResult, deferredFixPrompt: null };
+        }
+        // 도구 실행
+        const startTime = Date.now();
+        const toolAbort = new AbortController();
+        this.interruptManager.registerToolAbort(toolAbort);
+        if (["file_write", "file_edit"].includes(toolCall.name)) {
+            const candidatePath = args.path ??
+                args.file;
+            if (candidatePath) {
+                const filePathStr = String(candidatePath);
+                if (!this.originalSnapshots.has(filePathStr)) {
                     try {
-                        const relevantSkills = this.skillLearner.getRelevantSkills({
-                            errorMessage: `${toolCall.name}\n${result.output}`,
-                            filePath: typeof args.path === "string"
-                                ? args.path
-                                : typeof args.file === "string"
-                                    ? args.file
-                                    : undefined,
-                        });
-                        for (const skill of relevantSkills.slice(0, 1)) {
-                            this.skillLearner.updateConfidence(skill.id, result.success);
-                        }
+                        const { readFile } = await import("node:fs/promises");
+                        const original = await readFile(filePathStr, "utf-8");
+                        this.originalSnapshots.set(filePathStr, original);
                     }
-                    catch { }
-                }
-                results.push(result);
-                this.emitEvent({
-                    kind: "agent:tool_result",
-                    tool: toolCall.name,
-                    output: result.output.length > 200
-                        ? result.output.slice(0, 200) + "..."
-                        : result.output,
-                    durationMs: result.durationMs,
-                });
-                this.emitReasoning(`success: ${toolCall.name}`);
-                this.reasoningTree.add("tool", `success: ${toolCall.name}`);
-                // 파일 변경 이벤트 + 추적
-                if (["file_write", "file_edit"].includes(toolCall.name) &&
-                    result.success) {
-                    const filePath = args.path ??
-                        args.file ??
-                        "unknown";
-                    const filePathStr = String(filePath);
-                    // 변경 파일 추적 (메모리 업데이트용)
-                    if (!this.changedFiles.includes(filePathStr)) {
-                        this.changedFiles.push(filePathStr);
+                    catch (err) {
+                        if (err.code !== "ENOENT")
+                            throw err;
                     }
-                    this.emitEvent({
-                        kind: "agent:file_change",
-                        path: filePathStr,
-                        diff: result.output,
-                    });
-                    // ImpactAnalyzer: 변경 영향 분석 (비동기, 실패 무시)
-                    if (this.impactAnalyzer) {
-                        this.analyzeFileImpact(filePathStr).catch(() => { });
-                    }
-                }
-                // AutoFixLoop: 결과 검증 (fix prompt는 tool results 추가 후 context에 넣음)
-                const fixPrompt = await this.validateAndFeedback(toolCall.name, result);
-                if (fixPrompt) {
-                    deferredFixPrompts.push(fixPrompt);
                 }
             }
-            catch (err) {
-                this.interruptManager.clearToolAbort();
-                const durationMs = Date.now() - startTime;
-                // AbortError인 경우 (인터럽트로 취소됨)
-                if (toolAbort.signal.aborted) {
-                    results.push({
-                        tool_call_id: toolCall.id,
-                        name: toolCall.name,
-                        output: `[INTERRUPTED] Tool execution was cancelled by user interrupt.`,
-                        success: false,
-                        durationMs,
-                    });
-                    this.emitEvent({
-                        kind: "agent:error",
-                        message: `Tool ${toolCall.name} cancelled by interrupt`,
-                        retryable: false,
+        }
+        try {
+            const result = await this.toolExecutor.execute(toolCall, toolAbort?.signal);
+            this.interruptManager.clearToolAbort();
+            if (this.skillLearner) {
+                try {
+                    const relevantSkills = this.skillLearner.getRelevantSkills({
+                        errorMessage: `${toolCall.name}\n${result.output}`,
+                        filePath: typeof args.path === "string"
+                            ? args.path
+                            : typeof args.file === "string"
+                                ? args.file
+                                : undefined,
                     });
-                    // 남은 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,
-                        });
+                    for (const skill of relevantSkills.slice(0, 1)) {
+                        this.skillLearner.updateConfidence(skill.id, result.success);
                     }
-                    // soft interrupt: 루프 계속 / hard interrupt: aborted=true로 종료
-                    break;
                 }
-                const errorMessage = err instanceof Error ? err.message : String(err);
-                // Learned skill confidence feedback (failure path)
-                if (this.skillLearner) {
-                    try {
-                        const relevantSkills = this.skillLearner.getRelevantSkills({
-                            errorMessage: `${toolCall.name}\n${errorMessage}`,
-                            filePath: typeof args.path === "string"
-                                ? args.path
-                                : typeof args.file === "string"
-                                    ? args.file
-                                    : undefined,
-                        });
-                        for (const skill of relevantSkills.slice(0, 1)) {
-                            this.skillLearner.updateConfidence(skill.id, false);
-                        }
-                    }
-                    catch { }
+                catch { }
+            }
+            this.emitEvent({
+                kind: "agent:tool_result",
+                tool: toolCall.name,
+                output: result.output.length > 200
+                    ? result.output.slice(0, 200) + "..."
+                    : result.output,
+                durationMs: result.durationMs,
+            });
+            this.emitReasoning(`success: ${toolCall.name}`);
+            this.reasoningTree.add("tool", `success: ${toolCall.name}`);
+            if (["file_write", "file_edit"].includes(toolCall.name) && result.success) {
+                const filePath = args.path ??
+                    args.file ??
+                    "unknown";
+                const filePathStr = String(filePath);
+                if (!this.changedFiles.includes(filePathStr)) {
+                    this.changedFiles.push(filePathStr);
                 }
-                results.push({
+                this.emitEvent({ kind: "agent:file_change", path: filePathStr, diff: result.output });
+                if (this.impactAnalyzer) {
+                    this.analyzeFileImpact(filePathStr).catch(() => { });
+                }
+            }
+            const fixPrompt = await this.validateAndFeedback(toolCall.name, result);
+            return { result, deferredFixPrompt: fixPrompt ?? null };
+        }
+        catch (err) {
+            this.interruptManager.clearToolAbort();
+            const durationMs = Date.now() - startTime;
+            if (toolAbort.signal.aborted) {
+                const abortResult = {
                     tool_call_id: toolCall.id,
                     name: toolCall.name,
-                    output: `Error: ${errorMessage}`,
+                    output: `[INTERRUPTED] Tool execution was cancelled by user interrupt.`,
                     success: false,
                     durationMs,
-                });
+                };
                 this.emitEvent({
                     kind: "agent:error",
-                    message: `Tool ${toolCall.name} failed: ${errorMessage}`,
-                    retryable: true,
-                });
-                this.emitEvent({
-                    kind: "agent:reasoning_delta",
-                    text: `failed: ${toolCall.name}`,
+                    message: `Tool ${toolCall.name} cancelled by interrupt`,
+                    retryable: false,
                 });
-                this.reasoningTree.add("tool", `failed: ${toolCall.name}`);
+                return { result: abortResult, deferredFixPrompt: null };
+            }
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            if (this.skillLearner) {
+                try {
+                    const relevantSkills = this.skillLearner.getRelevantSkills({
+                        errorMessage: `${toolCall.name}\n${errorMessage}`,
+                        filePath: typeof args.path === "string"
+                            ? args.path
+                            : typeof args.file === "string"
+                                ? args.file
+                                : undefined,
+                    });
+                    for (const skill of relevantSkills.slice(0, 1)) {
+                        this.skillLearner.updateConfidence(skill.id, false);
+                    }
+                }
+                catch { }
+            }
+            const errorResult = {
+                tool_call_id: toolCall.id,
+                name: toolCall.name,
+                output: `Error: ${errorMessage}`,
+                success: false,
+                durationMs,
+            };
+            this.emitEvent({
+                kind: "agent:error",
+                message: `Tool ${toolCall.name} failed: ${errorMessage}`,
+                retryable: true,
+            });
+            this.emitEvent({ kind: "agent:reasoning_delta", text: `failed: ${toolCall.name}` });
+            this.reasoningTree.add("tool", `failed: ${toolCall.name}`);
+            return { result: errorResult, deferredFixPrompt: null };
+        }
+    }
+    async executeTools(toolCalls) {
+        // Reorder write tool calls using DependencyAnalyzer so files with no deps run first
+        const writeToolNames = new Set(['file_write', 'file_edit']);
+        const writeToolCalls = toolCalls.filter((tc) => writeToolNames.has(tc.name));
+        if (writeToolCalls.length > 1 && this.config.loop.projectPath) {
+            try {
+                const depAnalyzer = new DependencyAnalyzer();
+                const depGraph = await depAnalyzer.analyze(this.config.loop.projectPath);
+                const writeFilePaths = writeToolCalls
+                    .map((tc) => {
+                    const args = this.parseToolArgs(tc.arguments);
+                    return typeof args.path === "string" ? args.path : null;
+                })
+                    .filter((p) => p !== null);
+                if (writeFilePaths.length > 1) {
+                    const groups = depAnalyzer.groupIndependentFiles(depGraph, writeFilePaths);
+                    // Build ordered list of file paths: independent groups first, dependent files after
+                    const orderedPaths = [];
+                    for (const group of groups) {
+                        for (const f of group.files) {
+                            if (!orderedPaths.includes(f))
+                                orderedPaths.push(f);
+                        }
+                    }
+                    // Reorder writeToolCalls according to orderedPaths
+                    const reordered = [];
+                    for (const filePath of orderedPaths) {
+                        const tc = writeToolCalls.find((c) => {
+                            const args = this.parseToolArgs(c.arguments);
+                            return args.path === filePath;
+                        });
+                        if (tc)
+                            reordered.push(tc);
+                    }
+                    // Add any write calls that didn't match a path (shouldn't happen, but be safe)
+                    for (const tc of writeToolCalls) {
+                        if (!reordered.includes(tc))
+                            reordered.push(tc);
+                    }
+                    // Rebuild toolCalls preserving non-write tools in their original positions,
+                    // replacing write tools with dependency-ordered sequence
+                    const reorderedAll = [];
+                    let writeIdx = 0;
+                    for (const tc of toolCalls) {
+                        if (writeToolNames.has(tc.name)) {
+                            reorderedAll.push(reordered[writeIdx++] ?? tc);
+                        }
+                        else {
+                            reorderedAll.push(tc);
+                        }
+                    }
+                    toolCalls = reorderedAll;
+                }
+            }
+            catch {
+                // DependencyAnalyzer failure is non-fatal — fall through to original ordering
             }
         }
+        // Group tool calls: read-only can run in parallel, write tools run sequentially
+        const readOnlyTools = new Set(['file_read', 'grep', 'glob', 'code_search']);
+        const batches = [];
+        let currentBatch = [];
+        for (const toolCall of toolCalls) {
+            if (readOnlyTools.has(toolCall.name)) {
+                currentBatch.push(toolCall);
+            }
+            else {
+                if (currentBatch.length > 0) {
+                    batches.push(currentBatch);
+                    currentBatch = [];
+                }
+                batches.push([toolCall]); // write tools run solo
+            }
+        }
+        if (currentBatch.length > 0)
+            batches.push(currentBatch);
+        if (toolCalls.length > 1)
+            this.emitReasoning(`parallel tool batch started (${toolCalls.length} tools)`);
+        const results = [];
+        const deferredFixPrompts = [];
+        for (const batch of batches) {
+            if (batch.length === 1) {
+                // Sequential single tool execution
+                const { result, deferredFixPrompt } = await this.executeSingleTool(batch[0], toolCalls);
+                if (result)
+                    results.push(result);
+                if (deferredFixPrompt)
+                    deferredFixPrompts.push(deferredFixPrompt);
+                // Check for interrupt result — stop processing remaining batches
+                if (result && result.output.startsWith('[INTERRUPTED]')) {
+                    // Add placeholder results for remaining unexecuted tool calls
+                    const executedIds = new Set(results.map(r => r.tool_call_id));
+                    for (const tc of toolCalls) {
+                        if (!executedIds.has(tc.id)) {
+                            results.push({
+                                tool_call_id: tc.id,
+                                name: tc.name,
+                                output: `[SKIPPED] Previous tool was interrupted.`,
+                                success: false,
+                                durationMs: 0,
+                            });
+                        }
+                    }
+                    break;
+                }
+            }
+            else {
+                // Parallel execution for read-only tools in this batch
+                this.emitReasoning(`running ${batch.length} read-only tools in parallel`);
+                const batchResults = await Promise.allSettled(batch.map(tc => this.executeSingleTool(tc, toolCalls)));
+                for (const settled of batchResults) {
+                    if (settled.status === 'fulfilled') {
+                        if (settled.value.result)
+                            results.push(settled.value.result);
+                        if (settled.value.deferredFixPrompt)
+                            deferredFixPrompts.push(settled.value.deferredFixPrompt);
+                    }
+                    else {
+                        // Parallel tool failure — record as error result
+                        const tc = batch[batchResults.indexOf(settled)];
+                        results.push({
+                            tool_call_id: tc?.id ?? 'unknown',
+                            name: tc?.name ?? 'unknown',
+                            output: `Error: ${settled.reason instanceof Error ? settled.reason.message : String(settled.reason)}`,
+                            success: false,
+                            durationMs: 0,
+                        });
+                    }
+                } // end for (const settled of batchResults)
+            } // end else (parallel batch)
+        } // end for (const batch of batches)
         return { results, deferredFixPrompts };
     }
     /**