@yuaone/core 0.9.30 → 0.9.32

package/dist/agent-loop.js

@@ -47,6 +47,7 @@ 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";
+import { SubAgent } from "./sub-agent.js";
 import { ReasoningAggregator } from "./reasoning-aggregator.js";
 import { ReasoningTree } from "./reasoning-tree.js";
 import { ContextCompressor } from "./context-compressor.js";
@@ -112,6 +113,52 @@ import { dlog, dlogSep } from "./debug-logger.js";
  */
 /** Minimum confidence for classification-based hints/routing to activate */
 const CLASSIFICATION_CONFIDENCE_THRESHOLD = 0.6;
+/** spawn_sub_agent tool definition — allows the LLM to delegate tasks to sub-agents */
+const SPAWN_SUB_AGENT_TOOL = {
+    name: "spawn_sub_agent",
+    description: "Spawn a sub-agent to work on a delegated task in parallel. " +
+        "The sub-agent runs an independent agent loop with its own tool access, " +
+        "inheriting the same LLM configuration. Use this for tasks that can be " +
+        "broken down (e.g., implement one module while you work on another, " +
+        "run a review pass, verify changes).",
+    parameters: {
+        type: "object",
+        properties: {
+            goal: {
+                type: "string",
+                description: "The specific task goal for the sub-agent to accomplish.",
+            },
+            role: {
+                type: "string",
+                enum: ["coder", "critic", "verifier", "specialist"],
+                description: "Sub-agent role. 'coder' writes code, 'critic' reviews for issues, " +
+                    "'verifier' checks correctness, 'specialist' handles domain tasks. " +
+                    "Defaults to 'coder'.",
+            },
+        },
+        required: ["goal"],
+        additionalProperties: false,
+    },
+    source: "builtin",
+    readOnly: false,
+    requiresApproval: false,
+    riskLevel: "medium",
+};
+/** Map user-facing sub-agent roles to internal SubAgentRole */
+function mapToSubAgentRole(role) {
+    switch (role) {
+        case "critic":
+            return "reviewer";
+        case "verifier":
+            return "tester";
+        case "specialist":
+            return "coder";
+        case "coder":
+            return "coder";
+        default:
+            return "coder";
+    }
+}
 export class AgentLoop extends EventEmitter {
     abortSignal;
     llmClient;
@@ -140,6 +187,7 @@ export class AgentLoop extends EventEmitter {
     changedFiles = [];
     aborted = false;
     initialized = false;
+    partialInit = false;
     continuationEngine = null;
     mcpClient = null;
     mcpToolDefinitions = [];
@@ -202,6 +250,12 @@ export class AgentLoop extends EventEmitter {
     iterationTsFilesModified = [];
     /** Task 3: Whether tsc was run in the previous iteration (skip cooldown) */
     tscRanLastIteration = false;
+    /** Tracks whether the last tool call in the most recent iteration failed */
+    _lastToolFailed = false;
+    /** Per-tool-call retry counter: tool_call_id → retry count (max 2) */
+    _toolRetryCount = new Map();
+    /** Count of consecutive iterations where LLM returned text-only (no tool calls, no task_complete) */
+    _consecutiveTextOnlyIterations = 0;
     // ─── OverheadGovernor — subsystem execution policy ──────────────────────
     overheadGovernor;
     /** Writes since last verify ran (for QA/quickVerify trigger) */
@@ -399,7 +453,10 @@ export class AgentLoop extends EventEmitter {
     async init() {
         if (this.initialized)
             return;
-        this.initialized = true;
+        // Guard against concurrent re-entry while init is already running
+        if (this.partialInit)
+            return;
+        this.partialInit = true;
         // Task 1: Initialize ContextBudgetManager with the total token budget
         this.contextBudgetManager = new ContextBudgetManager({
             totalBudget: this.config.loop.totalTokenBudget,
@@ -625,7 +682,7 @@ export class AgentLoop extends EventEmitter {
         const enhancedPrompt = buildSystemPrompt({
             projectStructure,
             yuanMdContent,
-            tools: [...this.config.loop.tools, ...this.mcpToolDefinitions],
+            tools: [...this.config.loop.tools, ...this.mcpToolDefinitions, SPAWN_SUB_AGENT_TOOL],
             projectPath,
             environment: this.environment,
         });
@@ -879,6 +936,10 @@ export class AgentLoop extends EventEmitter {
         this.continuousReflection.on("reflection:context_overflow", () => {
             void this.handleSoftContextOverflow();
         });
+        // Mark fully initialized — partialInit is cleared so timeout-interrupted
+        // runs can detect that init completed (partialInit=false + initialized=true).
+        this.initialized = true;
+        this.partialInit = false;
     }
     /**
      * MemoryManager의 학습/실패 기록을 시스템 메시지로 변환.
@@ -944,6 +1005,9 @@ export class AgentLoop extends EventEmitter {
             // Task 1: reset context summarization guard per run
             this._contextSummarizationDone = false;
             this._unfulfilledContinuations = 0;
+            this._lastToolFailed = false;
+            this._toolRetryCount.clear();
+            this._consecutiveTextOnlyIterations = 0;
         }
         // Reset resumedFromSession flag after consuming it — prevents stale state
         // from leaking into subsequent runs when the same AgentLoop instance is reused.
@@ -957,11 +1021,15 @@ export class AgentLoop extends EventEmitter {
         dlog("AGENT-LOOP", `emitting agent:start, sessionId=${this.sessionId}`);
         this.emitEvent({ kind: "agent:start", goal: userMessage });
         // 첫 실행 시 메모리/프로젝트 컨텍스트 자동 로드
-        // init은 최대 2초만 블로킹 — Ollama/analyzeProject 등 느린 작업은 백그라운드 계속
+        // init은 최대 5초만 블로킹 — Ollama/analyzeProject 등 느린 작업은 백그라운드 계속
         await Promise.race([
             this.init(),
-            new Promise(resolve => setTimeout(resolve, 2_000)),
+            new Promise(resolve => setTimeout(resolve, 5_000)),
         ]);
+        // If init timed out (partialInit still true), allow retry on next run
+        if (this.partialInit && !this.initialized) {
+            this.partialInit = false;
+        }
         // Always generate a fresh sessionId per run — prevents BudgetGovernorV2
         // from accumulating exhausted task budget across multiple runs on the same instance.
         this.sessionId = randomUUID();
@@ -2248,9 +2316,11 @@ export class AgentLoop extends EventEmitter {
                 response = await this.callLLMStreaming(messages);
             }
             catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                dlog("AGENT-LOOP", `run() LLM error`, { reason: "ERROR", error: errMsg, tokensUsed: this.tokenUsage.total, iterations: this.iterationCount });
+                this.emit("event", { kind: "agent:error", message: errMsg, retryable: false });
                 if (err instanceof LLMError) {
-                    dlog("AGENT-LOOP", `run() terminating`, { reason: "ERROR", tokensUsed: this.tokenUsage.total, iterations: this.iterationCount });
-                    return { reason: "ERROR", error: err.message };
+                    return { reason: "ERROR", error: errMsg };
                 }
                 throw err;
             }
@@ -2337,16 +2407,20 @@ export class AgentLoop extends EventEmitter {
             if (response.toolCalls.length === 0) {
                 const content = response.content ?? "";
                 let finalSummary = content || "Task completed.";
+                // Track consecutive text-only iterations
+                this._consecutiveTextOnlyIterations++;
                 // If LLM outputs text with no tool calls and hasn't signalled completion via task_complete,
-                // remind it once to use tools or call task_complete.
-                if (this._unfulfilledContinuations < 2) {
-                    this._unfulfilledContinuations++;
+                // remind it to use tools or call task_complete.
+                // Nudge on: first 2 unfulfilled continuations, OR every 2 consecutive text-only iterations.
+                if (this._unfulfilledContinuations < 2 || (this._consecutiveTextOnlyIterations >= 2 && this._consecutiveTextOnlyIterations % 2 === 0)) {
+                    if (this._unfulfilledContinuations < 2)
+                        this._unfulfilledContinuations++;
                     this.contextManager.addMessage({ role: "assistant", content });
                     this.contextManager.addMessage({
                         role: "user",
-                        content: "Please complete your task: either use the available tools to take action, or call task_complete if you are done.",
+                        content: "Continue working. Use tools to make progress, or call task_complete if done.",
                     });
-                    this.emitEvent({ kind: "agent:thinking", content: `[nudge ${this._unfulfilledContinuations}/2] reminding LLM to use tools or call task_complete` });
+                    this.emitEvent({ kind: "agent:thinking", content: `[nudge ${this._unfulfilledContinuations}/2, text-only: ${this._consecutiveTextOnlyIterations}] reminding LLM to use tools or call task_complete` });
                     continue;
                 }
                 // Do NOT reset _unfulfilledContinuations here — counter stays spent to prevent infinite nudge loop
@@ -2529,6 +2603,23 @@ export class AgentLoop extends EventEmitter {
             if (taskCompleteCall) {
                 const callArgs = this.parseToolArgs(taskCompleteCall.arguments);
                 const taskCompleteSummary = String(callArgs["summary"] ?? response.content ?? "Task completed.");
+                // Stale GOAL_ACHIEVED prevention: if the last tool call failed, don't accept
+                // completion — nudge the LLM to fix the issue first.
+                if (this._lastToolFailed) {
+                    this._lastToolFailed = false; // reset so it doesn't block forever
+                    const nonProtocolCalls = response.toolCalls.filter((tc) => tc.name !== "task_complete");
+                    this.contextManager.addMessage({
+                        role: "assistant",
+                        content: response.content,
+                        tool_calls: nonProtocolCalls.length > 0 ? nonProtocolCalls : undefined,
+                    });
+                    this.contextManager.addMessage({
+                        role: "user",
+                        content: "The last tool call failed. Fix the issue before completing the task.",
+                    });
+                    this.emitEvent({ kind: "agent:thinking", content: "[stale-completion guard] last tool failed, rejecting task_complete" });
+                    continue;
+                }
                 // Save assistant message to context — filter task_complete from tool_calls.
                 // task_complete is an internal protocol signal; including it in LLM history without
                 // a matching role:"tool" result causes API 400 on the next turn.
@@ -2578,6 +2669,23 @@ export class AgentLoop extends EventEmitter {
             const { results: toolResults, deferredFixPrompts } = await this.executeTools(response.toolCalls);
             // Reflexion: 도구 결과 수집
             this.allToolResults.push(...toolResults);
+            // Track whether any tool call failed this iteration (for stale GOAL_ACHIEVED prevention)
+            const failedResults = toolResults.filter(r => !r.success);
+            this._lastToolFailed = failedResults.length > 0;
+            // Tool calls were made — reset consecutive text-only counter
+            this._consecutiveTextOnlyIterations = 0;
+            // Tool call failure auto-retry: inject error as user message so LLM can self-correct
+            // (max 2 retries per tool_call_id to prevent infinite retry loops)
+            for (const failed of failedResults) {
+                const retryKey = failed.tool_call_id ?? failed.name;
+                const retryCount = this._toolRetryCount.get(retryKey) ?? 0;
+                if (retryCount < 2) {
+                    this._toolRetryCount.set(retryKey, retryCount + 1);
+                    // The error is already in the tool result message added below;
+                    // no extra injection needed — the LLM will see the failure and retry naturally.
+                    dlog("AGENT-LOOP", `tool failure auto-retry eligible`, { tool: failed.name, retryCount: retryCount + 1, maxRetries: 2 });
+                }
+            }
             // Phase 6: Record tool outcomes in capability graph
             for (const tr of toolResults) {
                 recordToolOutcomeInGraph(this.capabilityGraph, tr.name, tr.success);
@@ -3087,7 +3195,7 @@ export class AgentLoop extends EventEmitter {
         const toolCalls = [];
         let usage = { input: 0, output: 0 };
         let finishReason = "stop";
-        const allTools = [...this.config.loop.tools, ...this.mcpToolDefinitions];
+        const allTools = [...this.config.loop.tools, ...this.mcpToolDefinitions, SPAWN_SUB_AGENT_TOOL];
         const stream = this.llmClient.chatStream(messages, allTools, this.abortSignal ?? undefined);
         // 텍스트 버퍼링 — 1토큰씩 emit하지 않고 청크 단위로 모아서 emit
         let textBuffer = "";
@@ -3223,7 +3331,7 @@ export class AgentLoop extends EventEmitter {
      */
     async executeSingleTool(toolCall, toolCalls) {
         const args = this.parseToolArgs(toolCall.arguments);
-        const allDefinitions = [...this.config.loop.tools, ...this.mcpToolDefinitions];
+        const allDefinitions = [...this.config.loop.tools, ...this.mcpToolDefinitions, SPAWN_SUB_AGENT_TOOL];
         const matchedDefinition = allDefinitions.find((t) => t.name === toolCall.name);
         // Governor: 안전성 검증
         try {
@@ -3293,6 +3401,11 @@ export class AgentLoop extends EventEmitter {
                 return { result: pluginApprovalResult, deferredFixPrompt: null };
             }
         }
+        // spawn_sub_agent 도구 호출 — SubAgent로 위임
+        if (toolCall.name === "spawn_sub_agent") {
+            const subAgentResult = await this.executeSpawnSubAgent(toolCall, args);
+            return { result: subAgentResult, deferredFixPrompt: null };
+        }
         // MCP 도구 호출 확인
         if (this.mcpClient && this.isMCPTool(toolCall.name)) {
             // Emit tool_start before execution (required for trace, QA pipeline, replay)
@@ -3678,6 +3791,138 @@ export class AgentLoop extends EventEmitter {
         }
         return { results, deferredFixPrompts };
     }
+    /**
+     * Execute spawn_sub_agent tool — creates a SubAgent, runs it, returns result.
+     * The sub-agent inherits the parent's LLM config (provider, model, apiKey).
+     */
+    async executeSpawnSubAgent(toolCall, args) {
+        const startTime = Date.now();
+        const goal = String(args.goal ?? "");
+        const roleInput = typeof args.role === "string" ? args.role : "coder";
+        const role = mapToSubAgentRole(roleInput);
+        if (!goal) {
+            return {
+                tool_call_id: toolCall.id,
+                name: toolCall.name,
+                output: "Error: 'goal' parameter is required for spawn_sub_agent.",
+                success: false,
+                durationMs: Date.now() - startTime,
+            };
+        }
+        // Emit tool_start
+        this.emitEvent({
+            kind: "agent:tool_start",
+            tool: toolCall.name,
+            input: args,
+            source: "builtin",
+        });
+        const taskId = `sub-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        const projectPath = this.config.loop.projectPath || process.cwd();
+        try {
+            const subAgent = new SubAgent({
+                taskId,
+                goal,
+                targetFiles: [], // sub-agent discovers files via tools
+                readFiles: [],
+                maxIterations: Math.min(this.config.loop.maxIterations, 15),
+                projectPath,
+                byokConfig: this.config.byok,
+                tools: this.config.loop.tools.map((t) => t.name),
+                createToolExecutor: (_workDir, _enabledTools) => this.toolExecutor,
+                role,
+            });
+            // Forward sub-agent events as bg_update for TUI visibility
+            subAgent.on("subagent:phase", (tid, phase) => {
+                this.emitEvent({
+                    kind: "agent:bg_update",
+                    agentId: taskId,
+                    agentLabel: `sub-agent (${roleInput})`,
+                    eventType: "info",
+                    message: `Phase: ${phase}`,
+                    timestamp: Date.now(),
+                });
+            });
+            subAgent.on("event", (event) => {
+                // Re-emit sub-agent text/thinking for observability
+                if (event.kind === "agent:text_delta") {
+                    this.emitEvent({
+                        kind: "agent:bg_update",
+                        agentId: taskId,
+                        agentLabel: `sub-agent (${roleInput})`,
+                        eventType: "info",
+                        message: String(event.text ?? ""),
+                        timestamp: Date.now(),
+                    });
+                }
+                else if (event.kind === "agent:thinking") {
+                    this.emitEvent({
+                        kind: "agent:bg_update",
+                        agentId: taskId,
+                        agentLabel: `sub-agent (${roleInput})`,
+                        eventType: "info",
+                        message: String(event.content ?? ""),
+                        timestamp: Date.now(),
+                    });
+                }
+            });
+            // Build DAG context for the sub-agent
+            const dagContext = {
+                overallGoal: goal,
+                totalTasks: 1,
+                completedTasks: [],
+                runningTasks: [taskId],
+            };
+            // Run sub-agent
+            const result = await subAgent.run(dagContext);
+            // Build output summary
+            const changedFilesList = result.changedFiles.length > 0
+                ? result.changedFiles.map((f) => f.path).join(", ")
+                : "none";
+            const output = [
+                `## Sub-Agent Result (${roleInput})`,
+                `- Task ID: ${taskId}`,
+                `- Success: ${result.success}`,
+                `- Iterations: ${result.iterations}`,
+                `- Tokens: input=${result.tokensUsed.input}, output=${result.tokensUsed.output}`,
+                `- Changed files: ${changedFilesList}`,
+                ``,
+                `### Summary`,
+                result.summary,
+                result.error ? `\n### Error\n${result.error}` : "",
+            ].join("\n");
+            this.emitEvent({
+                kind: "agent:tool_result",
+                tool: toolCall.name,
+                output: output.length > 200 ? output.slice(0, 200) + "..." : output,
+                durationMs: Date.now() - startTime,
+            });
+            return {
+                tool_call_id: toolCall.id,
+                name: toolCall.name,
+                output,
+                success: result.success,
+                durationMs: Date.now() - startTime,
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            this.emitEvent({
+                kind: "agent:bg_update",
+                agentId: taskId,
+                agentLabel: `sub-agent (${roleInput})`,
+                eventType: "error",
+                message: `Sub-agent failed: ${errorMsg}`,
+                timestamp: Date.now(),
+            });
+            return {
+                tool_call_id: toolCall.id,
+                name: toolCall.name,
+                output: `Sub-agent error: ${errorMsg}`,
+                success: false,
+                durationMs: Date.now() - startTime,
+            };
+        }
+    }
     /**
      * Governor의 ApprovalRequiredError를 ApprovalManager로 처리.
      * 승인되면 null 반환 (실행 계속), 거부되면 ToolResult 반환 (실행 차단).