ikie-cli 0.1.39 → 0.1.41

package/dist/agent.js

@@ -77,7 +77,27 @@ export function shouldContinue(toolCallCount, _finishReason, step, maxSteps) {
  * assistant message so they stay in lockstep.
  */
 export function normalizeToolCalls(calls) {
-    return calls.filter(tc => typeof tc.name === 'string' && tc.name.trim().length > 0);
+    return calls
+        .filter(tc => typeof tc.name === 'string' && tc.name.trim().length > 0)
+        .map(tc => {
+        if (tc.argsStr !== undefined && !isValidJson(tc.argsStr)) {
+            return { ...tc, argsStr: '{}' };
+        }
+        return tc;
+    });
+}
+/** Check whether a string is valid JSON (object or array). */
+function isValidJson(s) {
+    s = s.trim();
+    if (!s)
+        return false;
+    try {
+        const parsed = JSON.parse(s);
+        return typeof parsed === 'object' && parsed !== null;
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * Safely restore previously-saved stdin listeners after a raw-mode interaction
@@ -120,14 +140,36 @@ async function withRetry(fn, opts) {
     const maxRetries = opts?.maxRetries ?? 2;
     let lastErr;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        if (opts?.signal?.aborted) {
+            throw new Error('Aborted');
+        }
         if (attempt > 0) {
             const delay = Math.min(1000 * Math.pow(2, attempt - 1), 8000) + Math.random() * 1000;
             if (opts?.label) {
                 process.stdout.write(`\n  ${c.muted(`Retry ${attempt}/${maxRetries} for ${opts.label} in ${(delay / 1000).toFixed(1)}s`)}`);
             }
-            await sleep(delay);
+            const sig = opts?.signal;
+            if (sig) {
+                await new Promise((resolve, reject) => {
+                    const timer = setTimeout(() => {
+                        sig.removeEventListener('abort', onAbort);
+                        resolve();
+                    }, delay);
+                    const onAbort = () => {
+                        clearTimeout(timer);
+                        reject(new Error('Aborted'));
+                    };
+                    sig.addEventListener('abort', onAbort);
+                });
+            }
+            else {
+                await sleep(delay);
+            }
         }
         try {
+            if (opts?.signal?.aborted) {
+                throw new Error('Aborted');
+            }
             return await fn();
         }
         catch (err) {
@@ -158,11 +200,11 @@ function targetsOwnPort(command) {
     // Only flag when paired with a process-killing / port-freeing tool.
     return /\b(lsof|fuser|kill|pkill|npx\s+kill-port|kill-port)\b/.test(command);
 }
-function printResponse(text, indentStr = '  ') {
+function printResponse(agent, text, indentStr = '  ') {
     const indent = (s) => s.split('\n').map(l => indentStr + l).join('\n');
     const { response } = extractThinkTags(text);
     if (response.trim()) {
-        process.stdout.write(indent(renderMarkdown(response)) + '\n');
+        agent.write(indent(renderMarkdown(response)) + '\n');
     }
 }
 function toolPhaseLabel(name) {
@@ -171,7 +213,6 @@ function toolPhaseLabel(name) {
         case 'edit_file': return 'Editing file';
         case 'read_file': return 'Reading';
         case 'bash': return 'Running command';
-        case 'spawn_agent': return 'Spawning agent';
         case 'list_dir': return 'Listing directory';
         case 'search_files': return 'Searching';
         case 'grep': return 'Searching';
@@ -203,22 +244,27 @@ export class Agent {
     systemPrompt;
     sessionAllowList = new Set();
     sessionDenyList = new Set();
-    depth;
-    indent;
+    indent = '  ';
     activeTurnStats = null;
     activeChangedFiles = new Set();
     lastTurnStats = { modelCalls: 0, toolCalls: 0, filesChanged: 0 };
     mode = 'agent';
-    constructor(client, config, systemPrompt, depth = 0) {
+    planSteps = [];
+    planStepIndex = 0;
+    constructor(client, config, systemPrompt) {
         this.client = client;
         this.config = config;
         this.systemPrompt = systemPrompt;
-        this.depth = depth;
-        this.indent = '  '.repeat(depth + 1);
+    }
+    write(text) {
+        process.stdout.write(text);
     }
     clearConversation() {
         this.conversation = [];
     }
+    updateApiKey(key) {
+        this.client.apiKey = key;
+    }
     getConversation() {
         return this.conversation;
     }
@@ -287,9 +333,30 @@ export class Agent {
     setMode(mode) {
         this.mode = mode;
     }
+    setPlanSteps(steps) {
+        this.planSteps = steps;
+        this.planStepIndex = 0;
+        if (steps.length > 0) {
+            this.write(`\n  ${c.primary.bold('Plan')} ${c.muted(`(${steps.length} steps)`)}\n`);
+            for (let i = 0; i < steps.length; i++) {
+                this.write(`  ${c.muted('☐')} ${c.dim(steps[i])}\n`);
+            }
+            this.write('\n');
+        }
+    }
+    advancePlanStep() {
+        if (this.planStepIndex < this.planSteps.length) {
+            const step = this.planSteps[this.planStepIndex];
+            this.write(`  ${c.success('☑')} ${c.white(step)}\n`);
+            this.planStepIndex++;
+        }
+    }
     async send(userMessage, opts = {}) {
         this.activeTurnStats = { modelCalls: 0, toolCalls: 0, filesChanged: 0 };
         this.activeChangedFiles = new Set();
+        // Reset plan steps before a new turn so old plans don't linger.
+        this.planSteps = [];
+        this.planStepIndex = 0;
         // A prior turn may have ended mid-tool-call (cancelled/errored). Heal the
         // history before adding the new turn so the request is always valid.
         this.conversation = repairDanglingToolCalls(this.conversation);
@@ -380,42 +447,10 @@ export class Agent {
                 this.conversation.push({ role: 'tool', tool_call_id: id, content });
             };
             const groups = this.groupToolCalls(toolCalls);
-            // ── Pass 1: all spawn_agents in parallel across groups ──────────────
-            const spawnResults = new Map(); // tool_call_id → result
-            {
-                const spawnTasks = [];
-                for (const group of groups) {
-                    for (const tc of group) {
-                        if (tc.name === 'spawn_agent') {
-                            let input;
-                            try {
-                                input = JSON.parse(tc.argsStr || '{}');
-                            }
-                            catch {
-                                input = {};
-                            }
-                            spawnTasks.push({ tc, input });
-                        }
-                    }
-                }
-                if (spawnTasks.length > 0) {
-                    if (this.activeTurnStats)
-                        this.activeTurnStats.toolCalls += spawnTasks.length;
-                    const results = await Promise.all(spawnTasks.map(st => this.runSubagent(st.input, opts)));
-                    spawnTasks.forEach((st, i) => spawnResults.set(st.tc.id, results[i]));
-                }
-            }
-            // ── Pass 2: remaining groups in order ──────────────────────────────
             for (const group of groups) {
                 if (opts.signal?.aborted)
                     break;
-                // Push spawn_agent results for any spawn calls in this group
-                for (const tc of group) {
-                    const r = spawnResults.get(tc.id);
-                    if (r !== undefined)
-                        pushResult(tc.id, r);
-                }
-                const remaining = group.filter(tc => !spawnResults.has(tc.id));
+                const remaining = group;
                 if (remaining.length === 0)
                     continue;
                 const inputs = remaining.map(tc => {
@@ -431,8 +466,8 @@ export class Agent {
                 if (this.mode === 'plan' && !PLAN_TOOLS.has(remaining[0].name)) {
                     if (this.activeTurnStats)
                         this.activeTurnStats.toolCalls += remaining.length;
-                    process.stdout.write(`\n${this.indent}${toolLine(remaining[0].name, formatToolArgs(remaining[0].name, inputs[0])).trimStart()}\n`);
-                    process.stdout.write(`${this.indent}${toolErrorLine('blocked · plan mode is read-only')}\n`);
+                    this.write(`\n${this.indent}${toolLine(remaining[0].name, formatToolArgs(remaining[0].name, inputs[0])).trimStart()}\n`);
+                    this.write(`${this.indent}${toolErrorLine('blocked · plan mode is read-only')}\n`);
                     for (const tc of remaining) {
                         pushResult(tc.id, 'Blocked: plan mode is read-only. Do not attempt changes — propose a plan instead. The user can switch to agent mode to apply it.');
                     }
@@ -441,7 +476,7 @@ export class Agent {
                 if (remaining.length === 1) {
                     if (this.activeTurnStats)
                         this.activeTurnStats.toolCalls++;
-                    process.stdout.write(`\n${this.indent}${toolLine(remaining[0].name, formatToolArgs(remaining[0].name, inputs[0])).trimStart()}\n`);
+                    this.write(`\n${this.indent}${toolLine(remaining[0].name, formatToolArgs(remaining[0].name, inputs[0])).trimStart()}\n`);
                     const result = await this.handleToolCall(remaining[0].name, remaining[0].id, inputs[0], opts);
                     pushResult(remaining[0].id, result);
                 }
@@ -449,7 +484,7 @@ export class Agent {
                     if (this.activeTurnStats)
                         this.activeTurnStats.toolCalls += remaining.length;
                     const summary = this.formatGroupSummary(remaining[0].name, inputs);
-                    process.stdout.write(`\n${this.indent}${toolLine(`${remaining[0].name} ×${remaining.length}`, summary).trimStart()}\n`);
+                    this.write(`\n${this.indent}${toolLine(`${remaining[0].name} ×${remaining.length}`, summary).trimStart()}\n`);
                     if (!opts.autoApprove && !this.config.autoApprove && !SAFE_TOOLS.has(remaining[0].name) && remaining[0].name !== 'switch_mode') {
                         const allowed = await this.checkPermission(remaining[0].name, inputs[0]);
                         if (!allowed) {
@@ -461,7 +496,7 @@ export class Agent {
                     }
                     const t0 = Date.now();
                     let errors = 0;
-                    const groupSpinner = new InlineSpinner(`${toolPhaseLabel(remaining[0].name)} (${remaining.length} operations)`, t0);
+                    const groupSpinner = new InlineSpinner(`${toolPhaseLabel(remaining[0].name)} (${remaining.length} operations)`, t0, opts.signal);
                     groupSpinner.start();
                     const results = new Map();
                     for (let i = 0; i < remaining.length; i++) {
@@ -478,7 +513,7 @@ export class Agent {
                             }
                             const result = tc.name === 'use_skill'
                                 ? await this.handleToolCall(tc.name, tc.id, inputs[i], opts)
-                                : await executeTool(tc.name, inputs[i]);
+                                : await executeTool(tc.name, inputs[i], opts.signal);
                             if (result.startsWith('Error'))
                                 errors++;
                             this.recordChangedFile(tc.name, inputs[i], result);
@@ -499,7 +534,7 @@ export class Agent {
                     const lineStr = errors === 0
                         ? toolSuccessLine(ms, `${remaining.length} operations`)
                         : toolErrorLine(`${errors} of ${remaining.length} operations`);
-                    process.stdout.write(`${this.indent}${lineStr}\n`);
+                    this.write(`${this.indent}${lineStr}\n`);
                 }
             }
             // Invariant: balance the assistant message. Any tool_call that didn't get
@@ -517,7 +552,8 @@ export class Agent {
                 await this.summarizeAndStop(opts, maxSteps);
                 break;
             }
-            process.stdout.write('\n');
+            this.write('\n');
+            this.advancePlanStep();
         }
     }
     /**
@@ -526,7 +562,7 @@ export class Agent {
      * tool call. Best-effort: failures here don't throw out of the turn.
      */
     async summarizeAndStop(opts, maxSteps) {
-        process.stdout.write(`\n${this.indent}${c.warning('◔')} ${c.muted(`Reached step budget (${maxSteps}) — wrapping up.`)}\n`);
+        this.write(`\n${this.indent}${c.warning('◔')} ${c.muted(`Reached step budget (${maxSteps}) — wrapping up.`)}\n`);
         this.conversation.push({
             role: 'user',
             content: `[system] You have reached the ${maxSteps}-step tool budget for this turn. `
@@ -546,11 +582,11 @@ export class Agent {
             const text = resp.choices[0]?.message?.content ?? '';
             this.conversation.push({ role: 'assistant', content: text || null });
             if (text)
-                printResponse(text, this.indent);
+                printResponse(this, text, this.indent);
         }
         catch (err) {
             if (!opts.signal?.aborted) {
-                process.stdout.write(`${this.indent}${toolErrorLine(extractUpstreamError(err))}\n`);
+                this.write(`${this.indent}${toolErrorLine(extractUpstreamError(err))}\n`);
             }
         }
     }
@@ -578,11 +614,9 @@ export class Agent {
     }
     buildParams() {
         // Always work on a copy — never push into the shared TOOL_DEFS array.
-        let tools = this.depth >= 1
-            ? TOOL_DEFS.filter(t => t.function.name !== 'spawn_agent')
-            : [...TOOL_DEFS];
+        let tools = [...TOOL_DEFS];
         // Append first-class MCP tools in agent mode only (we can't prove they're read-only).
-        if (this.mode === 'agent' && this.depth === 0) {
+        if (this.mode === 'agent') {
             tools = tools.concat(getMcpToolDefs());
         }
         // Always include switch_mode so the agent can request a mode change.
@@ -598,12 +632,11 @@ export class Agent {
         else if (switchModeTool && !tools.includes(switchModeTool)) {
             tools.push(switchModeTool);
         }
-        return {
+        const params = {
             model: this.config.model,
             max_tokens: this.config.maxTokens,
             temperature: this.config.temperature,
             top_p: this.config.topP,
-            top_k: this.config.topK,
             presence_penalty: this.config.presencePenalty,
             frequency_penalty: this.config.frequencyPenalty,
             messages: [
@@ -613,6 +646,11 @@ export class Agent {
             tools,
             tool_choice: 'auto',
         };
+        const isStandardModel = this.config.model.includes('deepseek') || this.config.model.includes('gpt') || this.config.model.includes('o1') || this.config.model.includes('o3') || this.config.model.includes('claude');
+        if (this.config.topK !== undefined && !isStandardModel) {
+            params.top_k = this.config.topK;
+        }
+        return params;
     }
     async throttleModelRequest() {
         const rpm = Math.max(1, Math.floor(this.config.requestsPerMinute || 10));
@@ -625,15 +663,15 @@ export class Agent {
         prune();
         if (requestTimestamps.length >= rpm) {
             const waitMs = Math.max(0, 60_000 - (Date.now() - requestTimestamps[0]) + 25);
-            process.stdout.write(`\n${this.indent}${c.muted(`Rate limit: waiting ${(waitMs / 1000).toFixed(1)}s (${rpm} rpm)`)}`);
+            this.write(`\n${this.indent}${c.muted(`Rate limit: waiting ${(waitMs / 1000).toFixed(1)}s (${rpm} rpm)`)}`);
             await sleep(waitMs);
-            process.stdout.write('\r\x1b[2K');
+            this.write('\r\x1b[2K');
             prune();
         }
         requestTimestamps.push(Date.now());
     }
     async callModelStreaming(opts, state) {
-        const spinner = new InlineSpinner('Working', opts.startedAt);
+        const spinner = new InlineSpinner('Working', opts.startedAt, opts.signal);
         spinner.start();
         const requestOpts = opts.signal ? { signal: opts.signal } : undefined;
         let stream;
@@ -644,7 +682,7 @@ export class Agent {
             }, requestOpts), { signal: opts.signal, label: 'stream' });
         }
         catch (err) {
-            spinner.stop();
+            spinner.stop('failed');
             throw new Error(extractUpstreamError(err));
         }
         let textContent = '';
@@ -657,12 +695,14 @@ export class Agent {
             for await (const chunk of stream) {
                 if (opts.signal?.aborted)
                     break;
-                const choice = chunk.choices[0];
+                const choice = chunk.choices?.[0];
                 if (!choice)
                     continue;
                 const { delta, finish_reason } = choice;
                 if (finish_reason)
                     finishReason = finish_reason;
+                if (!delta)
+                    continue;
                 const raw = delta;
                 if (typeof raw.reasoning_content === 'string' && raw.reasoning_content) {
                     thinkingContent += raw.reasoning_content;
@@ -717,10 +757,10 @@ export class Agent {
             }
         }
         finally {
-            spinner.stop();
+            spinner.stop('ok');
         }
         if (textContent) {
-            printResponse(textContent, this.indent);
+            printResponse(this, textContent, this.indent);
         }
         const toolCalls = normalizeToolCalls([...toolCallsMap.values()]);
         const assistantMsg = {
@@ -737,7 +777,7 @@ export class Agent {
         return { assistantMsg, toolCalls, finishReason };
     }
     async callModelNonStreaming(opts) {
-        const spinner = new InlineSpinner('Working', opts.startedAt);
+        const spinner = new InlineSpinner('Working', opts.startedAt, opts.signal);
         spinner.start();
         const requestOpts = opts.signal ? { signal: opts.signal } : undefined;
         let resp;
@@ -747,18 +787,21 @@ export class Agent {
             }, requestOpts), { signal: opts.signal, label: 'non-stream' });
         }
         catch (err) {
-            spinner.stop();
+            spinner.stop('failed');
             throw new Error(extractUpstreamError(err));
         }
         finally {
-            spinner.stop();
+            spinner.stop('ok');
+        }
+        const choice = resp.choices?.[0];
+        if (!choice) {
+            throw new Error('No completion choices returned from model API.');
         }
-        const choice = resp.choices[0];
         const msg = choice.message;
         const finishReason = choice.finish_reason ?? 'stop';
         const textContent = msg.content ?? '';
         if (textContent) {
-            printResponse(textContent, this.indent);
+            printResponse(this, textContent, this.indent);
         }
         const toolCalls = normalizeToolCalls((msg.tool_calls ?? []).map(tc => ({
             id: tc.id, name: tc.function.name, argsStr: tc.function.arguments,
@@ -786,9 +829,6 @@ export class Agent {
         if (name === 'use_skill') {
             return this.handleUseSkill(input);
         }
-        if (name === 'spawn_agent') {
-            return this.runSubagent(input, opts);
-        }
         if (name === 'ask_user') {
             return this.askUser(input);
         }
@@ -797,7 +837,7 @@ export class Agent {
             if (isRestrictedPath(path) && !opts.autoApprove && !this.config.autoApprove && !this.sessionAllowList.has('read_file')) {
                 if (this.sessionDenyList.has('read_file'))
                     return `Tool execution denied by user: read_file ${path}`;
-                process.stdout.write(`${this.indent}${c.warning('⚠')} ${c.muted('Restricted file')} ${c.white(path)} ${c.muted('— asking for permission')}\n`);
+                this.write(`${this.indent}${c.warning('⚠')} ${c.muted('Restricted file')} ${c.white(path)} ${c.muted('— asking for permission')}\n`);
                 const allowed = await this.checkPermission('read_file', input);
                 if (!allowed)
                     return `Tool execution denied by user: read_file ${path}`;
@@ -817,14 +857,14 @@ export class Agent {
                 return `Tool execution denied by user: ${name}`;
         }
         const t0 = Date.now();
-        const spinner = new InlineSpinner(toolPhaseLabel(name), t0);
+        const spinner = new InlineSpinner(toolPhaseLabel(name), t0, opts.signal);
         // For bash commands with streaming, show spinner briefly then let output flow
         const isStreamingBash = name === 'bash' && /\b(build|compile|test|deploy|install)\b/i.test(String(input.command ?? ''));
         if (!isStreamingBash) {
             spinner.start();
         }
         try {
-            const result = await executeTool(name, input);
+            const result = await executeTool(name, input, opts.signal);
             if (!isStreamingBash) {
                 spinner.stop();
             }
@@ -841,7 +881,7 @@ export class Agent {
                 block = toolOutputBlock(result, ms, this.indent);
             }
             if (block)
-                process.stdout.write(`${block}\n`);
+                this.write(`${block}\n`);
             return result;
         }
         catch (err) {
@@ -849,7 +889,7 @@ export class Agent {
                 spinner.stop();
             }
             const msg = err instanceof Error ? err.message : String(err);
-            process.stdout.write(`${this.indent}${toolErrorLine(msg)}\n`);
+            this.write(`${this.indent}${toolErrorLine(msg)}\n`);
             return msg;
         }
     }
@@ -866,9 +906,6 @@ export class Agent {
         return renderSkill(skill);
     }
     async handleSwitchMode(input) {
-        if (this.depth > 0) {
-            return 'Error: subagents cannot switch mode. Return your findings and let the main agent decide.';
-        }
         const mode = input.mode;
         const reason = (input.reason ?? '').trim();
         if (!mode || (mode !== 'plan' && mode !== 'agent')) {
@@ -885,13 +922,13 @@ export class Agent {
         return `Switched to ${mode} mode.`;
     }
     async requestModeSwitch(mode, reason) {
-        process.stdout.write(`\n  ${c.primary('◆')} ${c.white.bold('mode switch')} ${c.muted('·')} ${c.white(`to ${mode}`)}\n` +
+        this.write(`\n  ${c.primary('◆')} ${c.white.bold('mode switch')} ${c.muted('·')} ${c.white(`to ${mode}`)}\n` +
             `  ${c.muted('reason:')} ${c.dim(reason)}\n` +
             `  ${c.muted('⎿')} ${c.success.bold('y')} ${c.muted('allow')}   ${c.error.bold('n')} ${c.muted('deny')}\n` +
             `  ${c.muted('❯')} `);
         return new Promise((resolve) => {
             if (!process.stdin.isTTY) {
-                process.stdout.write(chalk.dim('(non-interactive, denying)\n'));
+                this.write(chalk.dim('(non-interactive, denying)\n'));
                 resolve(false);
                 return;
             }
@@ -911,11 +948,11 @@ export class Agent {
                 restoreStdinListeners(savedDataListeners, savedKeypressListeners);
                 const key = data.toString().toLowerCase();
                 if (key === 'y' || key === '\r' || key === '\n') {
-                    process.stdout.write(chalk.green('y\n'));
+                    this.write(chalk.green('y\n'));
                     resolve(true);
                 }
                 else {
-                    process.stdout.write(chalk.red('n\n'));
+                    this.write(chalk.red('n\n'));
                     resolve(false);
                 }
             };
@@ -928,7 +965,7 @@ export class Agent {
             return 'Error: ask_user requires a question.';
         return new Promise((resolve) => {
             if (!process.stdin.isTTY) {
-                process.stdout.write(chalk.dim('(non-interactive, skipping)\n'));
+                this.write(chalk.dim('(non-interactive, skipping)\n'));
                 resolve('(no answer — non-interactive mode)');
                 return;
             }
@@ -947,7 +984,7 @@ export class Agent {
                 terminal: false // Let us handle the prompt ourselves
             });
             // Display the question with custom formatting
-            process.stdout.write(`\n${this.indent}${c.info('[?]')} ${c.white.bold(question)}\n` +
+            this.write(`\n${this.indent}${c.info('[?]')} ${c.white.bold(question)}\n` +
                 `${this.indent}${c.primary('╰─❯')} `);
             // Wait for user input
             rl.once('line', (answer) => {
@@ -963,75 +1000,6 @@ export class Agent {
             process.stdin.resume();
         });
     }
-    // ── Subagent ──────────────────────────────────────────────────────────────
-    async runSubagent(input, opts) {
-        if (this.depth >= 2) {
-            return 'Error: subagents cannot spawn further subagents (max depth reached).';
-        }
-        const task = (input.task ?? '').trim();
-        if (!task)
-            return 'Error: spawn_agent requires a "task" describing what to do.';
-        const label = task.length > 64 ? task.slice(0, 64) + '…' : task;
-        process.stdout.write(`\n${this.indent}${c.primary('◆')} ${c.primary.bold('subagent')} ${c.muted('»')} ${c.white(label)}\n`);
-        const subPrompt = SUBAGENT_FRAMING + '\n\n' + this.systemPrompt;
-        const sub = new Agent(this.client, this.config, subPrompt, this.depth + 1);
-        const message = input.context
-            ? `Context from the main agent:\n${input.context}\n\nYour task: ${task}`
-            : `Your task: ${task}`;
-        try {
-            await sub.send(message, { autoApprove: true, signal: opts.signal });
-        }
-        catch (err) {
-            process.stdout.write(`${this.indent}${c.error('✗')} ${c.muted('subagent failed')}\n`);
-            return `Subagent error: ${err instanceof Error ? err.message : String(err)}`;
-        }
-        let result = sub.getLastAssistantText();
-        // The subagent's reply IS the only thing returned to the parent. If it ended
-        // without a textual summary (e.g. stopped right after a tool call), ask once
-        // more for a self-contained summary so we never hand back an empty result.
-        if (!result && !opts.signal?.aborted) {
-            result = await sub.requestFinalSummary(opts.signal);
-        }
-        process.stdout.write(`${this.indent}${c.success('✓')} ${c.muted('subagent done')}\n\n`);
-        return result || '(subagent completed but produced no summary)';
-    }
-    /**
-     * Best-effort: one tool-less model call asking for a concise, self-contained
-     * summary of the work so far. Used to guarantee a non-empty subagent result.
-     */
-    async requestFinalSummary(signal) {
-        this.conversation.push({
-            role: 'user',
-            content: 'Summarize what you did and any key results (paths changed, findings, answers) '
-                + 'in a few sentences. Do not call any tools.',
-        });
-        try {
-            if (this.activeTurnStats)
-                this.activeTurnStats.modelCalls++;
-            await this.throttleModelRequest();
-            const params = this.buildParams();
-            const resp = await withRetry(() => this.client.chat.completions.create({
-                ...params,
-                tools: undefined,
-                tool_choice: undefined,
-            }, (signal ? { signal } : undefined)), { signal, label: 'sub-summary' });
-            const text = resp.choices[0]?.message?.content ?? '';
-            this.conversation.push({ role: 'assistant', content: text || null });
-            return text;
-        }
-        catch {
-            return '';
-        }
-    }
-    getLastAssistantText() {
-        for (let i = this.conversation.length - 1; i >= 0; i--) {
-            const m = this.conversation[i];
-            if (m.role === 'assistant' && typeof m.content === 'string' && m.content.trim()) {
-                return m.content;
-            }
-        }
-        return '';
-    }
     // ── Permission prompt ─────────────────────────────────────────────────────
     async checkPermission(toolName, input, opts) {
         if (this.sessionDenyList.has(toolName))
@@ -1041,18 +1009,18 @@ export class Agent {
         if (!opts?.force && this.sessionAllowList.has(toolName))
             return true;
         if (opts?.warning) {
-            process.stdout.write(`${this.indent}${c.warning('⚠')} ${c.muted(opts.warning)}\n`);
+            this.write(`${this.indent}${c.warning('⚠')} ${c.muted(opts.warning)}\n`);
         }
         const t0 = Date.now();
         const preview = formatToolArgs(toolName, input);
         const { verb, tint } = toolMeta(toolName);
         const line = `\n  ${tint('●')} ${c.white.bold('permission')} ${c.muted(`(${((Date.now() - t0) / 1000).toFixed(1)}s)`)} ${c.muted('·')} ${c.white(verb)} ${c.dim(preview)}\n`;
-        process.stdout.write(line);
+        this.write(line);
         const optionsStr = `${c.success(' y allow ')}  ${c.error(' n deny ')}  ${c.info(' a always ')}  ${c.muted(' ! never ')}`;
-        process.stdout.write(`  ${optionsStr}\n  ${c.muted(CH.arrow)} `);
+        this.write(`  ${optionsStr}\n  ${c.muted(CH.arrow)} `);
         return new Promise((resolve) => {
             if (!process.stdin.isTTY) {
-                process.stdout.write(chalk.dim('(non-interactive, denying)\n'));
+                this.write(chalk.dim('(non-interactive, denying)\n'));
                 resolve(false);
                 return;
             }
@@ -1077,24 +1045,24 @@ export class Agent {
                 let label;
                 if (key === 'y') {
                     label = c.success('allow');
-                    process.stdout.write(`${label}\n`);
+                    this.write(`${label}\n`);
                     resolve(true);
                 }
                 else if (key === 'a') {
                     label = c.info('always');
                     this.sessionAllowList.add(toolName);
-                    process.stdout.write(`${label}\n`);
+                    this.write(`${label}\n`);
                     resolve(true);
                 }
                 else if (key === '!') {
                     label = c.muted('never');
                     this.sessionDenyList.add(toolName);
-                    process.stdout.write(`${label}\n`);
+                    this.write(`${label}\n`);
                     resolve(false);
                 }
                 else {
                     label = c.error('deny');
-                    process.stdout.write(`${label}\n`);
+                    this.write(`${label}\n`);
                     resolve(false);
                 }
             };
@@ -1102,18 +1070,13 @@ export class Agent {
         });
     }
 }
-export const SUBAGENT_FRAMING = `You are a focused sub-agent spawned by Ikie to autonomously complete ONE specific task.
-Work independently — do not ask the user questions. Use your tools to gather what you
-need, do the work, and verify it. When finished, your FINAL message must be a concise
-summary of what you did and any key results (paths changed, findings, answers). That
-summary is the only thing returned to the main agent, so make it self-contained.`;
 // Appended to the system prompt while in PLAN mode. The model is given only
 // read-only tools (see buildParams); this steers it to research and propose.
 export const PLAN_MODE_ADDENDUM = `
 
 ## PLAN MODE (read-only)
 You are currently in **plan mode**. You have ONLY read-only tools (read_file,
-list_dir, search_files, grep, fetch_url, web_search, use_skill, spawn_agent, ask_user). You CANNOT write files, edit
+list_dir, search_files, grep, fetch_url, web_search, use_skill, ask_user). You CANNOT write files, edit
 files, run shell commands, or change anything — those tools are unavailable and any
 attempt will be blocked.
 
@@ -1223,7 +1186,6 @@ continue assisting with the legitimate task.
   Keep momentum — don't stall on decisions you can reverse later.
 - Verify your work: after edits, re-read the changed regions and run the build, tests, or
   linter. Fix what you broke before you call a task done.
-- Delegate isolated or parallelizable investigation to \`spawn_agent\` to stay focused.
 - Be concise but clear: explain what you did and why in well-formatted points. Show
   code/results rather than narrating. Use \`ask_user\` only when genuinely blocked.
 - Never leave a task half-finished or claim a success you have not verified.
@@ -1270,9 +1232,8 @@ process you started, instead.
 form a hypothesis, and change your approach — never re-run the identical failing call
 and hope. If a permission prompt is denied, pick a different route, don't retry it.
 
-**7. Delegate and verify.** Hand isolated or parallelizable investigation to
-\`spawn_agent\` (give it a self-contained \`task\` + \`context\`). After making changes,
-verify: re-read the changed region and run the build/tests/linter before declaring done.
+**7. Verify after changing.** After making changes, re-read the changed region and run
+the build/tests/linter before declaring done.
 
 **8. Don't narrate routine calls.** Just make the call and let the result speak; explain
 only the non-obvious. Use \`ask_user\` only when truly blocked on a decision you can't make.
@@ -1283,6 +1244,7 @@ only the non-obvious. Use \`ask_user\` only when truly blocked on a decision you
 - \`edit_file\`: Replace exact strings (preferred for modifications)
 - \`bash\`: Run shell commands (build, test, git, etc.). Commands ending with & run detached in background.
   **IMPORTANT:** By default it's non-interactive — for commands that ask questions (create-next-app, npm init, etc.), skip prompts with \`--yes\`/\`-y\` or explicit flags. For prompts with no flag (e.g. an arrow-key menu), set \`interactive: true\` so the user answers in the real terminal. For long-running downloads (npx installs), request \`timeout_ms\` up to 300000.
+  **ANSWER PROMPTS YOURSELF:** To handle interactive prompts programmatically (e.g. filling in package name, confirming defaults), set \`allow_interaction: true\`. If the command prompts for input (stays alive >2.5s), the result includes \`[session s_xxx]\` plus the prompt text. Then call \`bash(session_id: "s_xxx", stdin: "your answer")\` to send input and get the next prompt. Repeat until the command finishes. If the command completes without prompting, it returns normally with no session.
 - \`list_dir\`: Explore directory structure
 - \`search_files\`: Find files by glob pattern
 - \`grep\`: Search file contents by regex
@@ -1309,11 +1271,6 @@ only the non-obvious. Use \`ask_user\` only when truly blocked on a decision you
 - **Trust fetched page content over snippet summaries** — snippets can be stale; the live page is authoritative.
 - **Never state a version, date, or fact as definitive if your search results conflict** — say what
   the most recent source says and link it.
-- \`spawn_agent\`: Delegate a self-contained subtask to a focused sub-agent. Use this
-  to parallelize or isolate work — e.g. "investigate how auth is implemented and report
-  back", or "write and run tests for module X". The sub-agent has the same tools (except
-  it cannot spawn further sub-agents) and returns a summary. Give it a clear, complete
-  \`task\` and any needed \`context\`, since it does not see this conversation.
 - \`switch_mode\`: Request permission to switch between plan and agent mode. Use when the current
   mode is not sufficient for what you need to do next. The user must approve the switch.
 - \`use_skill\`: Load a **skill** — a curated pack of expert instructions (plus optional bundled