@apolloyh/apollo-agent 0.1.0

package/dist/index.js

@@ -0,0 +1,1716 @@
+#!/usr/bin/env node
+import { stdin, stdout } from "node:process";
+import readline from "node:readline/promises";
+import { ASCII_LOGO, PRODUCT } from "./brand.js";
+import { parseArgs } from "./cli-args.js";
+import { loadAgentConfig, loadEnvFile, loadLlmConfig } from "./config.js";
+import { pickSpinnerVerb } from "./constants/spinner-verbs.js";
+import { QueryEngine } from "./runtime/query-engine.js";
+import { createCliApprovalProvider } from "./runtime/permissions.js";
+import { formatResumeTime, moveResumeSelection, resumeHistoryEntries } from "./session/resume-ui.js";
+import { formatOutcomeLine, formatWaitLine, STATUS_TICK_MS } from "./status-ui.js";
+import { ThoughtFoldManager } from "./thought-fold.js";
+import { workflowStatusBar } from "./coordinator/workflow.js";
+import { CliTraceRenderer, stripTerminalEscapes } from "./trace.js";
+let activeCliInput;
+let pinnedCliInput;
+let modalActive = false;
+let resolveModal;
+let modalDone;
+let liveStatus;
+let runningTaskCount = 0;
+let activeVerb = "Thinking";
+let assistantResponseStarted = false;
+/** Prevent double green/red outcome lines in one user turn */
+let outcomePrintedThisTurn = false;
+const slashCommands = [
+    { command: "/help", usage: "/help", description: "Show slash commands" },
+    { command: "/skill", usage: "/skill", description: "List installed skills" },
+    { command: "/skill install", usage: "/skill install <path> [name]", description: "Install a local SKILL.md" },
+    { command: "/agents", usage: "/agents", description: "Show recent Task subagent activity" },
+    { command: "/status", usage: "/status", description: "Show session, model, and cache usage" },
+    { command: "/compact", usage: "/compact", description: "Semantically compact older context" },
+    { command: "/save", usage: "/save", description: "Save the current session" },
+    { command: "/sessions", usage: "/sessions", description: "List saved sessions" },
+    { command: "/resume", usage: "/resume [session-id]", description: "Resume a saved session" },
+    { command: "/verbose", usage: "/verbose on|off", description: "Show tool process traces (default off)" },
+    { command: "/stream", usage: "/stream on|off", description: "Toggle streaming answers" },
+    { command: "/clear", usage: "/clear", description: "Clear conversation context" },
+    { command: "/exit", usage: "/exit", description: `Exit ${PRODUCT.name}` },
+];
+/** Filter slash commands by command-name prefix only (accurate search). */
+function filterSlashCommands(buffer) {
+    if (!buffer.startsWith("/"))
+        return [];
+    const q = buffer.slice(1).toLowerCase().trim();
+    if (!q)
+        return slashCommands;
+    // /s → /status /stream /skill…  NOT /help (desc has "slash")
+    return slashCommands.filter((cmd) => {
+        const name = cmd.command.slice(1).toLowerCase();
+        if (name.startsWith(q))
+            return true;
+        // multi-word: "/sk" matches "skill install"
+        return name.split(/\s+/).some((w) => w.startsWith(q));
+    });
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    loadEnvFile(args.envPath);
+    const task = args.task ?? (stdin.isTTY ? undefined : (await readStdin()).trim());
+    if (!task && !stdin.isTTY) {
+        stdout.write(`Usage: apollo [-c | -r [session-id]] [--yolo] "your task"\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const agentConfig = await loadAgentConfig(args.configPath);
+    const llmConfig = loadLlmConfig();
+    const interactiveMode = !task && stdin.isTTY;
+    const yolo = args.yolo;
+    const thoughtFold = new ThoughtFoldManager({
+        color: args.color,
+        out: writeAboveActiveInput,
+    });
+    const traceOptions = {
+        verbose: args.verbose,
+        stream: args.stream,
+        color: args.color,
+        status: true,
+        stdout,
+        stderr: process.stderr,
+        beforeOutput: () => {
+            // Clear standalone spinner so answer text is not mixed into it
+            clearStandaloneSpinnerLine();
+            if (!modalActive)
+                activeCliInput?.clearForExternalOutput();
+        },
+        afterOutput: (text) => {
+            if (!modalActive && text.endsWith("\n"))
+                activeCliInput?.renderAfterExternalOutput();
+        },
+        suspendLiveStatus: () => modalActive,
+        // Interactive: index owns spinner + ● Thought line; renderer only streams text
+        staticStatus: interactiveMode,
+    };
+    const renderer = new CliTraceRenderer(traceOptions);
+    const rendererSink = renderer.sink();
+    const taskActivity = new TaskActivityLog();
+    const inputHistory = [];
+    // traceSink closes over the runtime, but the runtime is created after this. Hold it in a
+    // mutable ref that createRuntime populates, so goal_status events don't hit a TDZ (task mode
+    // never reaches the interactive `runtime` binding). Also lets SIGINT close whichever is active.
+    let activeRuntime;
+    const traceSink = (event) => {
+        // Collect process into collapsible Thought (always, even when quiet)
+        if (event.type === "llm_request") {
+            thoughtFold.beginTurn();
+            thoughtFold.note(`turn ${event.turn} · ${event.toolCount} tools available`);
+        }
+        else if (event.type === "llm_retry") {
+            thoughtFold.note(`retry ${event.attempt} · ${event.mode} · ${event.reason}`);
+        }
+        else if (event.type === "tool_call") {
+            thoughtFold.noteTool(event.tool);
+        }
+        else if (event.type === "tool_result") {
+            thoughtFold.note(`${event.tool} ${event.isError ? "failed" : "ok"}`);
+        }
+        else if (event.type === "task_start") {
+            thoughtFold.note(`Task(${event.subagentType}): ${event.description}`);
+        }
+        else if (event.type === "task_finish") {
+            thoughtFold.note(`Task(${event.subagentType}) finished`);
+        }
+        else if (event.type === "assistant_delta") {
+            thoughtFold.finalizeAndPrint();
+        }
+        else if (event.type === "llm_response" && event.stopReason !== "tool_use") {
+            thoughtFold.finalizeAndPrint();
+        }
+        if (event.type === "workflow_status") {
+            const bar = workflowStatusBar({
+                goal: event.goal,
+                phases: event.phases.map((ph) => ({
+                    id: ph.name,
+                    name: ph.name,
+                    label: ph.label,
+                    status: ph.status,
+                    summary: ph.summary,
+                    retries: 0,
+                })),
+                startedAt: new Date().toISOString(),
+                maxRetries: 2,
+            }, traceOptions.color);
+            activeCliInput?.clearForExternalOutput();
+            stdout.write(bar);
+            if (!modalActive)
+                activeCliInput?.renderAfterExternalOutput();
+        }
+        if (event.type === "goal_status") {
+            const g = activeRuntime?.getGoal();
+            if (g) {
+                activeCliInput?.clearForExternalOutput();
+                stdout.write(activeRuntime.renderGoalBar(traceOptions.color));
+                if (!modalActive)
+                    activeCliInput?.renderAfterExternalOutput();
+            }
+        }
+        if (event.type === "plan_mode") {
+            const msg = event.active
+                ? "\n◆ Plan mode ON — write .apollo/plan.md then /approve\n"
+                : event.approved
+                    ? "\n● Plan approved — implement mode\n"
+                    : "\n○ Plan mode OFF\n";
+            activeCliInput?.clearForExternalOutput();
+            stdout.write(msg);
+            if (!modalActive)
+                activeCliInput?.renderAfterExternalOutput();
+        }
+        const renderBeforeStatus = event.type === "llm_tool_delta" || event.type === "tool_call";
+        if (renderBeforeStatus)
+            rendererSink(event);
+        updateLiveStatus(event, interactiveMode);
+        taskActivity.record(event);
+        if (!renderBeforeStatus)
+            rendererSink(event);
+    };
+    const askUser = async (question, options) => {
+        activeCliInput?.clearForExternalOutput();
+        beginModalInput();
+        activeCliInput?.cancelForModal();
+        try {
+            if (options?.length) {
+                const choices = [...options, "Type a custom answer…"];
+                const selected = await askChoice(`? ${question}`, choices, 0, traceOptions.color);
+                if (selected === undefined)
+                    return "(no answer)";
+                if (selected < options.length)
+                    return options[selected];
+                const custom = (await askPlainQuestion("> ")).trim();
+                return custom || "(no answer)";
+            }
+            stdout.write(`\n? ${question}\n`);
+            const answer = (await askPlainQuestion("> ")).trim();
+            return answer || "(no answer)";
+        }
+        finally {
+            endModalInput();
+        }
+    };
+    const createRuntime = (approvalProvider) => {
+        const engine = new QueryEngine({
+            agentConfig,
+            llmConfig,
+            emit: traceSink,
+            assumeYes: () => yolo,
+            approvalProvider,
+            stream: () => traceOptions.stream,
+            askUser,
+        });
+        activeRuntime = engine;
+        return engine;
+    };
+    if (task) {
+        const runtime = createRuntime();
+        try {
+            if (!(await resumeFromArgs(runtime, args, false, traceOptions.color))) {
+                process.exitCode = 1;
+                return;
+            }
+            activeVerb = pickSpinnerVerb(task);
+            const result = await runWithRenderer(renderer, () => runtime.submitMessage(task));
+            if (!traceOptions.stream)
+                stdout.write(`${stripTerminalEscapes(result.trim())}\n`);
+            return;
+        }
+        finally {
+            await runtime.close();
+        }
+    }
+    stdout.write(renderWelcomeBanner({
+        model: llmConfig.model,
+        cwd: agentConfig.workspaceRoot,
+        agents: agentConfig.agents.map((a) => a.name),
+        color: traceOptions.color,
+        quiet: !traceOptions.verbose,
+        yolo: yolo || agentConfig.permissions.mode === "unrestricted",
+    }));
+    const approvalProvider = createCliApprovalProvider(agentConfig, traceSink, () => yolo, {
+        beforePrompt: () => {
+            stopLiveStatus("none");
+            beginModalInput();
+            activeCliInput?.cancelForModal();
+        },
+        color: traceOptions.color,
+        output: stdout,
+        question: async (questionPrompt) => {
+            try {
+                return await askApprovalQuestion(questionPrompt, traceOptions.color);
+            }
+            finally {
+                endModalInput();
+            }
+        },
+    });
+    const runtime = createRuntime(approvalProvider);
+    // Ctrl-C during line editing is handled as a keypress; this catches SIGINT delivered
+    // mid-turn (while submitMessage runs) so MCP child processes get closed before exit.
+    process.on("SIGINT", () => {
+        if (activeRuntime?.cancelCurrentTurn())
+            return;
+        void activeRuntime?.close().catch(() => undefined).finally(() => process.exit(130));
+    });
+    try {
+        if (!(await resumeFromArgs(runtime, args, true, traceOptions.color)))
+            return;
+        while (true) {
+            if (modalActive && modalDone) {
+                await modalDone;
+                continue;
+            }
+            const text = (await readCliLine({ color: traceOptions.color, history: inputHistory })).trim();
+            if (!text)
+                continue;
+            if (text === "/exit" || text === "/quit") {
+                break;
+            }
+            if (text === "/" || text === "/help") {
+                stdout.write(renderSlashCommandMenu(traceOptions.color));
+                continue;
+            }
+            if (text === "/skills" || text === "/skill") {
+                const skills = await runtime.listSkills();
+                if (skills.length === 0)
+                    stdout.write("No skills installed.\n");
+                else
+                    stdout.write(`${skills.map((s) => `- ${s.name}: ${s.path}`).join("\n")}\n`);
+                continue;
+            }
+            if (text === "/agents" || text === "/workers" || text === "/tasks") {
+                stdout.write(taskActivity.render(traceOptions.color));
+                continue;
+            }
+            if (text === "/status") {
+                const usage = runtime.getUsageStats();
+                const tokenHitRate = usage.cacheHitRate === null ? "n/a" : `${(usage.cacheHitRate * 100).toFixed(1)}%`;
+                const requestHitRate = usage.requestHitRate === null ? "n/a" : `${(usage.requestHitRate * 100).toFixed(1)}%`;
+                const latest = usage.latestByCategory.main;
+                const latestHitRate = latest?.cacheHitRate === null || !latest
+                    ? "n/a"
+                    : `${(latest.cacheHitRate * 100).toFixed(1)}%`;
+                const categoryLines = ["main", "task", "compaction"]
+                    .filter((category) => usage.byCategory[category].requests > 0)
+                    .map((category) => {
+                    const stats = usage.byCategory[category];
+                    const rate = stats.cacheHitRate === null ? "n/a" : `${(stats.cacheHitRate * 100).toFixed(1)}%`;
+                    return `  hit/${category.padEnd(10)} ${rate} token / ${stats.requestsWithCacheRead}/${stats.requests} requests`;
+                });
+                stdout.write([
+                    "",
+                    `  ${PRODUCT.name} v${PRODUCT.version}`,
+                    `  model     ${llmConfig.model}`,
+                    `  base      ${llmConfig.baseUrl}`,
+                    `  cwd       ${shortenHome(agentConfig.workspaceRoot)}`,
+                    `  messages  ${runtime.conversationSize()}`,
+                    `  tokens    ${usage.input_tokens.toLocaleString()} input / ${usage.output_tokens.toLocaleString()} output`,
+                    `  cache     ${usage.cache_read_input_tokens.toLocaleString()} read / ${usage.cache_creation_input_tokens.toLocaleString()} write`,
+                    `  hit/latest ${latestHitRate}${latest ? ` (${latest.cache_read_input_tokens.toLocaleString()} read / ${latest.input_tokens.toLocaleString()} input / ${latest.cache_creation_input_tokens.toLocaleString()} write)` : ""}`,
+                    `  hit/session ${tokenHitRate} token / ${requestHitRate} requests (${usage.requestsWithCacheRead}/${usage.requests})`,
+                    `  cache mode ${runtime.getCacheMode()}`,
+                    ...categoryLines,
+                    `  cache key ${usage.cacheDiagnostics.prefixFingerprint ?? "n/a"} prefix / ${usage.cacheDiagnostics.configFingerprint ?? "n/a"} config`,
+                    `            ${usage.cacheDiagnostics.systemFingerprint ?? "n/a"} system / ${usage.cacheDiagnostics.toolsFingerprint ?? "n/a"} tools`,
+                    ...(usage.cacheDiagnostics.missesAfterHit > 0
+                        ? [`  cache miss ${usage.cacheDiagnostics.missesAfterHit} after hit; ${usage.cacheDiagnostics.lastMissReason}`]
+                        : []),
+                    `  mode      ${runtime.getMode()}`,
+                    `  goal      ${runtime.getGoal()?.goal?.slice(0, 40) ?? "(none)"}`,
+                    `  session   ${runtime.getSessionId() ?? "(none)"}`,
+                    `  verbose   ${traceOptions.verbose ? "on" : "off"}`,
+                    `  stream    ${traceOptions.stream ? "on" : "off"}`,
+                    `  yolo      ${yolo ? "on" : "off"}`,
+                    "",
+                ].join("\n"));
+                continue;
+            }
+            if (text === "/compact") {
+                outcomePrintedThisTurn = false;
+                const result = await runtime.compactConversation(true);
+                if (result === "not_needed")
+                    stdout.write("Nothing to compact yet.\n");
+                continue;
+            }
+            if (text === "/clear") {
+                runtime.clearConversation();
+                taskActivity.clear();
+                thoughtFold.clear();
+                stdout.write("conversation cleared\n");
+                continue;
+            }
+            if (text.startsWith("/skill install ")) {
+                try {
+                    const [sourcePath, name] = parseCommandWords(text.slice("/skill install ".length));
+                    if (!sourcePath)
+                        stdout.write("Usage: /skill install <path> [name]\n");
+                    else {
+                        const installed = await runtime.installSkill(sourcePath, name);
+                        stdout.write(`Installed ${installed.name}: ${installed.path}\n`);
+                    }
+                }
+                catch (error) {
+                    stdout.write(`Failed: ${error instanceof Error ? error.message : String(error)}\n`);
+                }
+                continue;
+            }
+            if (text === "/skill install") {
+                stdout.write("Usage: /skill install <path> [name]\n");
+                continue;
+            }
+            if (text === "/goal" || text === "/goal-status") {
+                if (!runtime.getGoal())
+                    stdout.write("No active goal. Usage: /goal <description>\n");
+                else
+                    stdout.write(runtime.renderGoalBar(traceOptions.color));
+                continue;
+            }
+            if (text === "/goal-stop" || text === "/goal stop") {
+                runtime.stopGoal("paused");
+                stdout.write("Goal mode stopped.\n");
+                continue;
+            }
+            if (text.startsWith("/goal ")) {
+                const goalText = text.slice("/goal ".length).trim();
+                if (!goalText) {
+                    stdout.write("Usage: /goal <description>\n");
+                    continue;
+                }
+                let maxIter = 12;
+                let goalBody = goalText;
+                const maxMatch = goalText.match(/^max=(\d+)\s+(.+)$/i);
+                if (maxMatch) {
+                    maxIter = Math.min(Math.max(Number(maxMatch[1]), 1), 30);
+                    goalBody = maxMatch[2].trim();
+                }
+                runtime.startGoal(goalBody, maxIter);
+                stdout.write(runtime.renderGoalBar(traceOptions.color));
+                stdout.write("Goal mode ON — working until done (or /goal-stop).\n");
+                runningTaskCount = 0;
+                outcomePrintedThisTurn = false;
+                activeVerb = pickSpinnerVerb(goalBody);
+                const firstPrompt = `Start Goal mode.\nGoal: ${goalBody}\nMake the first concrete step. Use tools as needed.\nEnd with GOAL_PROGRESS / GOAL_DONE / GOAL_BLOCKED / GOAL_FAILED.`;
+                startPinnedCliInput(traceOptions.color);
+                try {
+                    await runGoalLoop(runtime, renderer, thoughtFold, traceOptions, firstPrompt);
+                }
+                finally {
+                    stopPinnedCliInput();
+                }
+                continue;
+            }
+            if (text === "/plan") {
+                await runtime.enterPlanMode();
+                stdout.write("Plan mode ON. Research + write .apollo/plan.md, then /approve.\n");
+                continue;
+            }
+            if (text === "/approve") {
+                const plan = await runtime.approvePlan();
+                if (!plan)
+                    stdout.write("No plan file found. Enter /plan and write .apollo/plan.md first.\n");
+                else
+                    stdout.write("Plan approved. You can ask to implement it now.\n");
+                continue;
+            }
+            if (text === "/reject") {
+                await runtime.rejectPlan();
+                stdout.write("Plan rejected. Back to normal mode.\n");
+                continue;
+            }
+            if (text === "/wf" || text === "/workflow") {
+                stdout.write(runtime.renderWorkflowBar(traceOptions.color));
+                continue;
+            }
+            if (text.startsWith("/workflow ")) {
+                const goal = text.slice("/workflow ".length).trim();
+                if (!goal)
+                    stdout.write("Usage: /workflow <goal>\n");
+                else {
+                    runtime.startWorkflow(goal);
+                    stdout.write(runtime.renderWorkflowBar(traceOptions.color));
+                    stdout.write("Workflow started. Describe next action or say \"continue workflow\".\n");
+                }
+                continue;
+            }
+            if (text === "/save") {
+                const path = await runtime.saveCurrentSession();
+                stdout.write(path ? `Session saved: ${path}\n` : "Nothing to save.\n");
+                continue;
+            }
+            if (text === "/sessions") {
+                const list = await runtime.listSessions();
+                if (!list.length)
+                    stdout.write("No sessions.\n");
+                else
+                    stdout.write(list.map((s) => `- ${s.id}  ${s.updatedAt}  ${s.title}  [${s.mode}]`).join("\n") + "\n");
+                continue;
+            }
+            if (text === "/resume" || text.startsWith("/resume ")) {
+                const id = text === "/resume"
+                    ? await pickSession(runtime)
+                    : text.slice("/resume ".length).trim() || undefined;
+                if (!id)
+                    continue;
+                const snap = await runtime.resumeSession(id);
+                if (!snap)
+                    stdout.write("No session found.\n");
+                else {
+                    renderResumedHistory(snap, traceOptions.color);
+                    stdout.write(`Resumed ${snap.meta.id} (${snap.messages.length} messages, mode=${snap.meta.mode})\n`);
+                    if (runtime.getWorkflow())
+                        stdout.write(runtime.renderWorkflowBar(traceOptions.color));
+                    if (runtime.getGoal())
+                        stdout.write(runtime.renderGoalBar(traceOptions.color));
+                }
+                continue;
+            }
+            if (text.startsWith("/skillify ")) {
+                const rest = text.slice("/skillify ".length).trim();
+                const [namePart, ...descParts] = rest.split("|");
+                const name = (namePart ?? "").trim();
+                const desc = descParts.join("|").trim() || `Skillified from session for: ${name}`;
+                if (!name)
+                    stdout.write("Usage: /skillify <name> | <description>\n");
+                else {
+                    const r = await runtime.skillify(name, desc);
+                    stdout.write(`Skill created: ${r.path}\n`);
+                }
+                continue;
+            }
+            if (text === "/skillify") {
+                stdout.write("Usage: /skillify <name> | <description>\n");
+                continue;
+            }
+            if (text === "/memory" || text.startsWith("/memory ")) {
+                const q = text === "/memory" ? "" : text.slice("/memory ".length).trim();
+                const { searchMemories, listMemories } = await import("./memory/memdir.js");
+                const notes = q
+                    ? await searchMemories(agentConfig.workspaceRoot, q)
+                    : await listMemories(agentConfig.workspaceRoot);
+                if (!notes.length)
+                    stdout.write("No memories.\n");
+                else
+                    stdout.write(notes.map((n) => `- ${n.id}  ${n.title}\n  ${n.content.slice(0, 120).replace(/\n/g, " ")}`).join("\n") + "\n");
+                continue;
+            }
+            if (text === "/thought" || text === "/think" || text === "/t") {
+                thoughtFold.toggle();
+                continue;
+            }
+            if (text.startsWith("/verbose")) {
+                const value = text.split(/\s+/)[1];
+                traceOptions.verbose = value === "on" ? true : value === "off" ? false : !traceOptions.verbose;
+                stdout.write(`verbose=${traceOptions.verbose ? "on" : "off"}\n`);
+                continue;
+            }
+            if (text.startsWith("/stream")) {
+                const value = text.split(/\s+/)[1];
+                traceOptions.stream = value === "on" ? true : value === "off" ? false : traceOptions.stream;
+                stdout.write(`stream=${traceOptions.stream ? "on" : "off"}\n`);
+                continue;
+            }
+            if (text.startsWith("/")) {
+                stdout.write(`Unknown command: ${text}\n`);
+                stdout.write(renderSlashCommandMenu(traceOptions.color));
+                continue;
+            }
+            // ── user turn ──────────────────────────────────────────────
+            // Keep an empty input chrome pinned below streaming output while this turn runs.
+            runningTaskCount = 0;
+            assistantResponseStarted = false;
+            outcomePrintedThisTurn = false;
+            activeVerb = pickSpinnerVerb(text);
+            startPinnedCliInput(traceOptions.color);
+            try {
+                const result = await runWithRenderer(renderer, () => runtime.submitMessage(text));
+                stopLiveStatus("success");
+                if (!traceOptions.stream)
+                    writeAboveActiveInput(`${stripTerminalEscapes(result.trim())}\n`);
+            }
+            catch (error) {
+                stopLiveStatus(isAbortError(error) ? "none" : "error");
+                thoughtFold.finalizeAndPrint(isAbortError(error) ? "Interrupted." : "Request failed.", true);
+                writeAboveActiveInput(`${formatRuntimeError(error, traceOptions.verbose)}\n`);
+            }
+            finally {
+                runningTaskCount = 0;
+                stopLiveStatus("none");
+                thoughtFold.finalizeAndPrint();
+                if (runtime.getWorkflow()) {
+                    writeAboveActiveInput(runtime.renderWorkflowBar(traceOptions.color));
+                }
+                void runtime.saveCurrentSession().catch(() => null);
+                stopPinnedCliInput();
+            }
+        }
+        const sessionId = runtime.getSessionId();
+        if (sessionId)
+            stdout.write(`\nResume this session with:\n  apollo --resume ${sessionId}\n`);
+    }
+    finally {
+        await runtime.close();
+    }
+    stopLiveStatus();
+    stdin.pause();
+}
+async function resumeFromArgs(runtime, args, interactive, color) {
+    if (!args.continueSession && !args.resumeSession)
+        return true;
+    let id = typeof args.resumeSession === "string" ? args.resumeSession : undefined;
+    if (args.resumeSession === true) {
+        if (!interactive) {
+            stdout.write("--resume requires a session ID when a task is supplied.\n");
+            return false;
+        }
+        id = await pickSession(runtime);
+        if (!id)
+            return false;
+    }
+    const snap = await runtime.resumeSession(id);
+    if (!snap) {
+        stdout.write(id ? `Session not found: ${id}\n` : "No previous session found in this project.\n");
+        return false;
+    }
+    if (interactive)
+        renderResumedHistory(snap, color);
+    stdout.write(`Resumed ${snap.meta.id} · ${snap.meta.title} · ${snap.messages.length} messages\n`);
+    return true;
+}
+async function pickSession(runtime) {
+    const sessions = (await runtime.listSessions()).slice(0, 12);
+    if (!sessions.length) {
+        stdout.write("No saved sessions in this project.\n");
+        return undefined;
+    }
+    if (stdin.isTTY && stdout.isTTY)
+        return pickSessionWithArrows(sessions);
+    stdout.write("\nSaved sessions\n");
+    sessions.forEach((session, index) => stdout.write(`  ${index + 1}) ${session.title}  ${formatResumeTime(session.updatedAt)}  ${session.id}\n`));
+    const answer = (await askPlainQuestion("Resume [number or session ID, blank to cancel]: ")).trim();
+    if (!answer)
+        return undefined;
+    const selected = Number(answer);
+    if (Number.isInteger(selected) && selected >= 1 && selected <= sessions.length) {
+        return sessions[selected - 1].id;
+    }
+    return answer;
+}
+async function pickSessionWithArrows(sessions) {
+    let selected = 0;
+    let renderedLines = 0;
+    let previousRawMode = false;
+    const clear = () => {
+        if (!renderedLines)
+            return;
+        stdout.write(`\x1b[${renderedLines}A\r`);
+        for (let index = 0; index < renderedLines; index += 1) {
+            stdout.write("\x1b[2K");
+            if (index < renderedLines - 1)
+                stdout.write("\x1b[1B\r");
+        }
+        if (renderedLines > 1)
+            stdout.write(`\x1b[${renderedLines - 1}A\r`);
+        renderedLines = 0;
+    };
+    const render = () => {
+        clear();
+        const width = Math.max(20, (stdout.columns || 100) - 8);
+        const lines = ["Saved sessions"];
+        for (const [index, session] of sessions.entries()) {
+            const active = index === selected;
+            const marker = active ? "›" : " ";
+            const title = truncateDisplay(session.title || "untitled", Math.min(42, width));
+            const line = `${marker} ${title}  ${formatResumeTime(session.updatedAt)}  ${session.id}`;
+            lines.push(active ? `\x1b[1;38;2;96;165;250m${line}\x1b[0m` : line);
+        }
+        lines.push("", "↑/↓ select · Enter resume · Esc cancel");
+        stdout.write(`${lines.join("\n")}\n`);
+        renderedLines = lines.length;
+    };
+    return await new Promise((resolve) => {
+        const finish = (value) => {
+            stdin.off("data", onData);
+            stdin.setRawMode(previousRawMode);
+            clear();
+            resolve(value);
+        };
+        const onData = (chunk) => {
+            for (const key of tokenizeKeyInput(chunk)) {
+                if (key === "\x1b[A")
+                    selected = moveResumeSelection(selected, -1, sessions.length);
+                else if (key === "\x1b[B")
+                    selected = moveResumeSelection(selected, 1, sessions.length);
+                else if (key === "\r" || key === "\n")
+                    return finish(sessions[selected]?.id);
+                else if (key === "\x1b" || key === "\u0003" || key === "\u0004")
+                    return finish();
+                else
+                    continue;
+                render();
+            }
+        };
+        previousRawMode = stdin.isRaw;
+        stdin.setEncoding("utf8");
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("data", onData);
+        render();
+    });
+}
+function renderResumedHistory(snapshot, color) {
+    const entries = resumeHistoryEntries(snapshot);
+    if (!entries.length)
+        return;
+    const dim = color ? "\x1b[2m" : "";
+    const blue = color ? "\x1b[38;2;96;165;250m" : "";
+    const reset = color ? "\x1b[0m" : "";
+    stdout.write(`\n${dim}Conversation history · ${entries.length} entries${reset}\n\n`);
+    const historyRenderer = new CliTraceRenderer({
+        verbose: false,
+        stream: true,
+        color,
+        status: false,
+        staticStatus: true,
+        stdout,
+        stderr: stdout,
+    });
+    const sink = historyRenderer.sink();
+    for (const entry of entries) {
+        if (entry.kind === "user") {
+            stdout.write(`${blue}›${reset} ${stripTerminalEscapes(entry.text)}\n\n`);
+        }
+        else if (entry.kind === "assistant") {
+            historyRenderer.resetTurn();
+            sink({ type: "assistant_delta", text: entry.text });
+            historyRenderer.finishTurn();
+        }
+        else {
+            const toolLine = `${entry.name}${entry.detail ? ` ${entry.detail}` : ""}`;
+            stdout.write(`${dim}• ${stripTerminalEscapes(toolLine)}${reset}\n`);
+        }
+    }
+    stdout.write("\n");
+}
+/** Run goal mode: keep submitting continue prompts until done/blocked/max. */
+async function runGoalLoop(runtime, renderer, thoughtFold, traceOptions, firstPrompt) {
+    let prompt = firstPrompt;
+    try {
+        while (true) {
+            assistantResponseStarted = false;
+            outcomePrintedThisTurn = false;
+            activeVerb = pickSpinnerVerb(prompt);
+            const result = await runWithRenderer(renderer, () => runtime.submitMessage(prompt));
+            stopLiveStatus("success");
+            if (!traceOptions.stream)
+                writeAboveActiveInput(`${stripTerminalEscapes(result.trim())}\n`);
+            thoughtFold.finalizeAndPrint();
+            const g = runtime.getGoal();
+            if (g) {
+                writeAboveActiveInput(runtime.renderGoalBar(traceOptions.color));
+            }
+            void runtime.saveCurrentSession().catch(() => null);
+            if (!runtime.shouldContinueGoal()) {
+                const st = runtime.getGoal()?.status ?? "stopped";
+                writeAboveActiveInput(`\nGoal mode ended (${st}).\n`);
+                break;
+            }
+            writeAboveActiveInput("\n… auto-continuing goal …\n");
+            prompt = runtime.continueGoalPrompt();
+        }
+    }
+    catch (error) {
+        stopLiveStatus(isAbortError(error) ? "none" : "error");
+        thoughtFold.finalizeAndPrint(isAbortError(error) ? "Interrupted." : "Goal turn failed.", true);
+        writeAboveActiveInput(`${formatRuntimeError(error, traceOptions.verbose)}\n`);
+    }
+    finally {
+        runningTaskCount = 0;
+        stopLiveStatus("none");
+    }
+}
+function updateLiveStatus(event, enabled) {
+    if (!enabled)
+        return;
+    switch (event.type) {
+        case "llm_request":
+            assistantResponseStarted = false;
+            startLiveStatus(runningTaskCount > 0 ? formatRunningTasks() : activeVerb);
+            break;
+        case "llm_retry":
+            startLiveStatus(event.mode === "after-compaction"
+                ? "Retrying after compaction"
+                : event.mode === "continue"
+                    ? "Continuing response"
+                    : event.mode === "non-stream"
+                        ? "Retrying without streaming"
+                        : "Retrying request");
+            break;
+        case "context_compaction_start":
+            startLiveStatus("Compacting context");
+            break;
+        case "context_compacted":
+        case "context_compaction_failed":
+            stopLiveStatus("none");
+            break;
+        case "tool_call":
+            if (event.tool === "Task")
+                break;
+            startLiveStatus(formatToolCallStatus(event.tool, event.input));
+            break;
+        case "llm_tool_delta":
+            updatePreparingToolStatus(event.tool, event.bytes, event.detail);
+            break;
+        case "task_start":
+            runningTaskCount += 1;
+            startLiveStatus(formatRunningTasks());
+            break;
+        case "assistant_delta":
+            if (runningTaskCount === 0 && !assistantResponseStarted) {
+                // Markdown is emitted once a complete line is available. Keep visible
+                // feedback during a long first paragraph instead of appearing frozen.
+                stopLiveStatus("success");
+                assistantResponseStarted = true;
+                if (!event.text.includes("\n"))
+                    startLiveStatus("Rendering response");
+            }
+            else if (liveStatus?.text === "Rendering response" && event.text.includes("\n")) {
+                stopLiveStatus("none");
+            }
+            break;
+        case "llm_response":
+            if (runningTaskCount === 0 && event.stopReason !== "tool_use")
+                stopLiveStatus("success");
+            break;
+        case "tool_result":
+            if (runningTaskCount === 0)
+                stopLiveStatus("none");
+            break;
+        case "task_finish":
+            runningTaskCount = Math.max(0, runningTaskCount - 1);
+            if (runningTaskCount > 0)
+                startLiveStatus(formatRunningTasks());
+            else
+                startLiveStatus(activeVerb);
+            break;
+        default:
+            break;
+    }
+}
+function formatRunningTasks() {
+    return runningTaskCount === 1 ? "Running 1 Task" : `Running ${runningTaskCount} Tasks`;
+}
+function updatePreparingToolStatus(tool, bytes, detail) {
+    const label = formatToolStatusName(tool ?? "tool");
+    const base = detail ? `${label}(${compactLine(stripTerminalEscapes(detail), 72)})` : `Preparing ${label} input`;
+    const text = bytes > 0 ? `${base} · ${formatByteCount(bytes)}` : base;
+    if (liveStatus?.text.startsWith(base)) {
+        liveStatus.text = text;
+        paintLiveStatus();
+        return;
+    }
+    startLiveStatus(text);
+}
+function formatToolCallStatus(tool, input) {
+    const label = formatToolStatusName(tool);
+    const value = ["path", "file_path", "command", "query", "url", "description"]
+        .map((key) => input[key])
+        .find((candidate) => typeof candidate === "string" && Boolean(candidate.trim()));
+    const detail = value ? `(${compactLine(stripTerminalEscapes(value), 72)})` : "";
+    if (tool === "write_file" && typeof input.content === "string") {
+        const lines = input.content ? input.content.split(/\r?\n/).length : 0;
+        return `${label}${detail} · ${lines} ${lines === 1 ? "line" : "lines"}`;
+    }
+    return `${label}${detail}`;
+}
+function formatToolStatusName(tool) {
+    if (tool === "write_file")
+        return "Write";
+    if (tool === "shell_exec")
+        return "Bash";
+    if (tool === "Task")
+        return "Task";
+    return tool
+        .split("_")
+        .filter(Boolean)
+        .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+        .join(" ");
+}
+function formatByteCount(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    return `${(bytes / 1024).toFixed(1)} KB`;
+}
+function startLiveStatus(text) {
+    if (liveStatus?.text === text)
+        return;
+    stopLiveStatus("none");
+    liveStatus = {
+        text,
+        startedAt: Date.now(),
+        frame: 0,
+        timer: setInterval(() => {
+            if (!liveStatus || modalActive)
+                return;
+            liveStatus.frame += 1;
+            paintLiveStatus();
+        }, STATUS_TICK_MS),
+        standaloneDrawn: false,
+    };
+    liveStatus.timer.unref?.();
+    paintLiveStatus();
+}
+function paintLiveStatus() {
+    if (!liveStatus)
+        return;
+    if (activeCliInput) {
+        activeCliInput.renderAfterExternalOutput();
+        return;
+    }
+    // No input chrome (turn is awaited): draw spinner in-place on its own line
+    const line = renderLiveStatusLine(Boolean(process.stdout.isTTY));
+    if (!line)
+        return;
+    stdout.write(`\r\x1b[2K${line}`);
+    liveStatus.standaloneDrawn = true;
+}
+function clearStandaloneSpinnerLine() {
+    if (!liveStatus?.standaloneDrawn)
+        return;
+    stdout.write("\r\x1b[2K");
+    liveStatus.standaloneDrawn = false;
+}
+/**
+ * Stop the animated wait line.
+ * - none: just clear (switching tools / intermediate)
+ * - success: print green ● Thought for Xs  (once per turn)
+ * - error: print red ● Failed · Xs
+ */
+function stopLiveStatus(outcome = "none") {
+    if (!liveStatus)
+        return;
+    const snapshot = liveStatus;
+    clearInterval(snapshot.timer);
+    if (snapshot.standaloneDrawn) {
+        stdout.write("\r\x1b[2K");
+    }
+    liveStatus = undefined;
+    if (outcome === "none") {
+        if (!modalActive)
+            activeCliInput?.renderAfterExternalOutput();
+        return;
+    }
+    // One permanent outcome line per user turn — never double-print
+    if (outcomePrintedThisTurn) {
+        if (!modalActive)
+            activeCliInput?.renderAfterExternalOutput();
+        return;
+    }
+    outcomePrintedThisTurn = true;
+    const elapsed = `${((Date.now() - snapshot.startedAt) / 1000).toFixed(1)}s`;
+    const label = snapshot.text.replace(/\.\.\.$/, "");
+    const useColor = Boolean(process.stdout.isTTY);
+    const line = formatOutcomeLine({
+        outcome,
+        label,
+        elapsed,
+        useColor,
+    });
+    activeCliInput?.clearForExternalOutput();
+    stdout.write(`${line}\n`);
+    if (!modalActive)
+        activeCliInput?.renderAfterExternalOutput();
+}
+function writeAboveActiveInput(text) {
+    const input = activeCliInput;
+    input?.clearForExternalOutput();
+    stdout.write(text);
+    if (!modalActive && text.endsWith("\n") && activeCliInput === input) {
+        input?.renderAfterExternalOutput();
+    }
+}
+function startPinnedCliInput(color) {
+    if (!stdin.isTTY || !stdout.isTTY || modalActive)
+        return;
+    stopPinnedCliInput();
+    let renderedLines = 0;
+    let renderedCursorLine = 0;
+    const clear = () => {
+        if (renderedLines === 0)
+            return;
+        if (renderedCursorLine > 0)
+            stdout.write(`\x1b[${renderedCursorLine}A\r`);
+        else
+            stdout.write("\r");
+        for (let index = 0; index < renderedLines; index += 1) {
+            stdout.write("\x1b[2K");
+            if (index < renderedLines - 1)
+                stdout.write("\x1b[1B\r");
+        }
+        if (renderedLines > 1)
+            stdout.write(`\x1b[${renderedLines - 1}A\r`);
+        renderedLines = 0;
+        renderedCursorLine = 0;
+    };
+    const render = () => {
+        if (modalActive || activeCliInput !== pinnedCliInput)
+            return;
+        clear();
+        const statusLine = renderLiveStatusLine(color);
+        const lines = [
+            ...(statusLine ? [statusLine] : []),
+            renderInputBorder("top", color),
+            renderInputPrompt(color),
+            renderInputBorder("bottom", color),
+        ];
+        stdout.write(lines.join("\n"));
+        renderedLines = lines.length;
+        renderedCursorLine = statusLine ? 2 : 1;
+        const rowsBelowInput = lines.length - 1 - renderedCursorLine;
+        stdout.write(`\x1b[${rowsBelowInput}A\r\x1b[3G`);
+    };
+    const pinned = {
+        clearForExternalOutput: clear,
+        renderAfterExternalOutput: render,
+        cancelForModal: () => {
+            clear();
+            if (activeCliInput === pinned)
+                activeCliInput = undefined;
+        },
+    };
+    pinnedCliInput = pinned;
+    activeCliInput = pinned;
+    render();
+}
+function stopPinnedCliInput() {
+    const pinned = pinnedCliInput;
+    if (!pinned)
+        return;
+    pinned.clearForExternalOutput();
+    if (activeCliInput === pinned)
+        activeCliInput = undefined;
+    pinnedCliInput = undefined;
+}
+async function readCliLine(options) {
+    if (!stdin.isTTY || !stdout.isTTY) {
+        const p = PRODUCT.prompt;
+        stdout.write(options.color ? `\x1b[38;2;96;165;250m${p}>\x1b[0m ` : `${p}> `);
+        return readStdinLine();
+    }
+    let buffer = "";
+    let cursor = 0;
+    let historyIndex = options.history.length;
+    let historyDraft = "";
+    let paletteOpen = false;
+    let selected = 0;
+    let renderedLines = 0;
+    let done = false;
+    let result = "";
+    let onData;
+    let resolveLine;
+    let previousRawMode = false;
+    let renderedCursorLine = 0;
+    let pasteBuffer;
+    const pasteStart = "\x1b[200~";
+    const pasteEnd = "\x1b[201~";
+    const complete = (value) => {
+        if (done)
+            return;
+        result = value;
+        done = true;
+        if (onData)
+            stdin.off("data", onData);
+        if (stdin.isTTY)
+            stdout.write("\x1b[?2004l");
+        if (stdin.isTTY)
+            stdin.setRawMode(previousRawMode);
+        if (activeCliInput?.cancelForModal === cancelForModal)
+            activeCliInput = undefined;
+        resolveLine?.(result);
+    };
+    const linesForState = () => {
+        const lines = [];
+        const liveStatusLine = renderLiveStatusLine(options.color);
+        if (liveStatusLine)
+            lines.push(liveStatusLine);
+        lines.push(renderInputBorder("top", options.color));
+        const view = inputView(buffer, cursor, Math.max(20, (stdout.columns ?? 100) - 4));
+        lines.push(`${renderInputPrompt(options.color)}${view.text}`);
+        if (paletteOpen) {
+            const filtered = filterSlashCommands(buffer);
+            lines.push(...renderSlashPaletteLines(selected, options.color, filtered, buffer));
+        }
+        lines.push(renderInputBorder("bottom", options.color));
+        return lines;
+    };
+    const clearRendered = () => {
+        if (renderedLines === 0)
+            return;
+        if (renderedCursorLine > 0)
+            stdout.write(`\x1b[${renderedCursorLine}A\r`);
+        else
+            stdout.write("\r");
+        for (let index = 0; index < renderedLines; index += 1) {
+            stdout.write("\x1b[2K");
+            if (index < renderedLines - 1)
+                stdout.write("\x1b[1B\r");
+        }
+        if (renderedLines > 1)
+            stdout.write(`\x1b[${renderedLines - 1}A\r`);
+        renderedLines = 0;
+        renderedCursorLine = 0;
+    };
+    const render = () => {
+        if (done)
+            return;
+        clearRendered();
+        const lines = linesForState();
+        stdout.write(lines.join("\n"));
+        renderedLines = lines.length;
+        renderedCursorLine = renderLiveStatusLine(options.color) ? 2 : 1;
+        const rowsBelowInput = lines.length - 1 - renderedCursorLine;
+        const view = inputView(buffer, cursor, Math.max(20, (stdout.columns ?? 100) - 4));
+        stdout.write(`\x1b[${rowsBelowInput}A\r\x1b[${3 + view.cursorWidth}G`);
+    };
+    const finish = (value) => {
+        clearRendered();
+        if (value) {
+            if (options.history.at(-1) !== value)
+                options.history.push(value);
+            if (options.history.length > 100)
+                options.history.splice(0, options.history.length - 100);
+            stdout.write(`${renderInputBorder("top", options.color)}\n${renderInputPrompt(options.color)}${submittedInputLabel(value)}\n${renderInputBorder("bottom", options.color)}\n`);
+        }
+        complete(value);
+    };
+    const cancelForModal = () => {
+        clearRendered();
+        complete("");
+    };
+    const closePalette = () => {
+        paletteOpen = false;
+        selected = 0;
+    };
+    const clampSelected = () => {
+        const list = filterSlashCommands(buffer);
+        if (list.length === 0) {
+            selected = 0;
+            return;
+        }
+        selected = ((selected % list.length) + list.length) % list.length;
+    };
+    const handleKey = (chunk) => {
+        if (done)
+            return;
+        if (paletteOpen) {
+            if (chunk === "\x1b[B" || chunk === "\t") {
+                const list = filterSlashCommands(buffer);
+                if (list.length)
+                    selected = (selected + 1) % list.length;
+                render();
+                return;
+            }
+            if (chunk === "\x1b[A") {
+                const list = filterSlashCommands(buffer);
+                if (list.length)
+                    selected = (selected - 1 + list.length) % list.length;
+                render();
+                return;
+            }
+            if (chunk === "\r" || chunk === "\n") {
+                const list = filterSlashCommands(buffer);
+                finish(list[selected]?.command ?? buffer);
+                return;
+            }
+            if (chunk === "\x1b") {
+                buffer = "";
+                cursor = 0;
+                closePalette();
+                render();
+                return;
+            }
+        }
+        if (chunk === "\u0003") {
+            if (buffer) {
+                buffer = "";
+                cursor = 0;
+                closePalette();
+                render();
+            }
+            else {
+                finish("/exit");
+            }
+            return;
+        }
+        if (chunk === "\u0004") {
+            if (!buffer)
+                finish("/exit");
+            return;
+        }
+        if (chunk === "\r" || chunk === "\n") {
+            finish(buffer);
+            return;
+        }
+        if (chunk === "\x7f") {
+            if (cursor > 0) {
+                const characters = Array.from(buffer);
+                characters.splice(cursor - 1, 1);
+                buffer = characters.join("");
+                cursor -= 1;
+            }
+            if (buffer.startsWith("/")) {
+                paletteOpen = true;
+                clampSelected();
+            }
+            else {
+                closePalette();
+            }
+            render();
+            return;
+        }
+        if (chunk === "\x1b[D" || chunk === "\x1b[C") {
+            const length = Array.from(buffer).length;
+            cursor = chunk === "\x1b[D" ? Math.max(0, cursor - 1) : Math.min(length, cursor + 1);
+            render();
+            return;
+        }
+        if (chunk === "\x1b[H" || chunk === "\u0001") {
+            cursor = 0;
+            render();
+            return;
+        }
+        if (chunk === "\x1b[F" || chunk === "\u0005") {
+            cursor = Array.from(buffer).length;
+            render();
+            return;
+        }
+        if (chunk === "\x1b[3~") {
+            const characters = Array.from(buffer);
+            if (cursor < characters.length)
+                characters.splice(cursor, 1);
+            buffer = characters.join("");
+            render();
+            return;
+        }
+        if (chunk === "\u0015") {
+            buffer = "";
+            cursor = 0;
+            closePalette();
+            render();
+            return;
+        }
+        if (chunk === "\u0017") {
+            const characters = Array.from(buffer);
+            let start = cursor;
+            while (start > 0 && /\s/.test(characters[start - 1] ?? ""))
+                start -= 1;
+            while (start > 0 && !/\s/.test(characters[start - 1] ?? ""))
+                start -= 1;
+            characters.splice(start, cursor - start);
+            buffer = characters.join("");
+            cursor = start;
+            render();
+            return;
+        }
+        if (chunk === "\x1b[A" || chunk === "\x1b[B") {
+            if (!options.history.length)
+                return;
+            if (chunk === "\x1b[A" && historyIndex > 0) {
+                if (historyIndex === options.history.length)
+                    historyDraft = buffer;
+                historyIndex -= 1;
+                buffer = options.history[historyIndex] ?? "";
+            }
+            else if (chunk === "\x1b[B" && historyIndex < options.history.length) {
+                historyIndex += 1;
+                buffer = historyIndex === options.history.length ? historyDraft : options.history[historyIndex] ?? "";
+            }
+            cursor = Array.from(buffer).length;
+            closePalette();
+            render();
+            return;
+        }
+        if (chunk === "\t" || chunk.startsWith("\x1b"))
+            return;
+        for (const char of chunk) {
+            if (char < " ")
+                continue;
+            const characters = Array.from(buffer);
+            characters.splice(cursor, 0, char);
+            buffer = characters.join("");
+            cursor += 1;
+        }
+        if (buffer.startsWith("/")) {
+            paletteOpen = true;
+            clampSelected();
+        }
+        else {
+            closePalette();
+        }
+        render();
+    };
+    const insertText = (text) => {
+        const safeText = stripTerminalEscapes(text).replace(/\r\n?/g, "\n");
+        const characters = Array.from(buffer);
+        const inserted = Array.from(safeText);
+        characters.splice(cursor, 0, ...inserted);
+        buffer = characters.join("");
+        cursor += inserted.length;
+    };
+    const handleData = (chunk) => {
+        let rest = chunk;
+        while (rest) {
+            if (pasteBuffer !== undefined) {
+                const end = rest.indexOf(pasteEnd);
+                if (end < 0) {
+                    pasteBuffer += rest;
+                    return;
+                }
+                pasteBuffer += rest.slice(0, end);
+                insertText(pasteBuffer);
+                pasteBuffer = undefined;
+                rest = rest.slice(end + pasteEnd.length);
+                render();
+                continue;
+            }
+            const start = rest.indexOf(pasteStart);
+            const typed = start < 0 ? rest : rest.slice(0, start);
+            for (const key of tokenizeKeyInput(typed)) {
+                handleKey(key);
+                if (done)
+                    return;
+            }
+            if (start < 0)
+                return;
+            pasteBuffer = "";
+            rest = rest.slice(start + pasteStart.length);
+        }
+    };
+    return await new Promise((resolve) => {
+        resolveLine = resolve;
+        previousRawMode = stdin.isRaw;
+        stdin.setEncoding("utf8");
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdout.write("\x1b[?2004h");
+        activeCliInput = {
+            clearForExternalOutput: clearRendered,
+            renderAfterExternalOutput: render,
+            cancelForModal,
+        };
+        onData = handleData;
+        stdin.on("data", onData);
+        render();
+    });
+}
+function beginModalInput() {
+    if (modalActive)
+        return;
+    modalActive = true;
+    activeCliInput?.cancelForModal();
+    modalDone = new Promise((resolve) => {
+        resolveModal = resolve;
+    });
+}
+function endModalInput() {
+    if (!modalActive)
+        return;
+    modalActive = false;
+    resolveModal?.();
+    resolveModal = undefined;
+    modalDone = undefined;
+    if (pinnedCliInput && !activeCliInput) {
+        activeCliInput = pinnedCliInput;
+        pinnedCliInput.renderAfterExternalOutput();
+    }
+}
+async function askPlainQuestion(prompt) {
+    const wasRaw = stdin.isTTY ? stdin.isRaw : false;
+    if (stdin.isTTY)
+        stdin.setRawMode(false);
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+    try {
+        return await rl.question(prompt);
+    }
+    finally {
+        rl.close();
+        if (stdin.isTTY)
+            stdin.setRawMode(wasRaw);
+    }
+}
+async function askApprovalQuestion(prompt, color) {
+    if (!stdin.isTTY || !stdout.isTTY)
+        return askPlainQuestion(prompt);
+    const selected = await askChoice(prompt, ["Yes", "No"], 1, color);
+    return selected === 0 ? "y" : "n";
+}
+async function askChoice(prompt, choices, initial, color) {
+    if (!choices.length)
+        return undefined;
+    let selected = Math.max(0, Math.min(initial, choices.length - 1));
+    let renderedLines = 0;
+    const previousRawMode = stdin.isRaw;
+    const blue = color ? "\x1b[1;38;2;96;165;250m" : "";
+    const dim = color ? "\x1b[90m" : "";
+    const reset = color ? "\x1b[0m" : "";
+    const clear = () => {
+        if (!renderedLines)
+            return;
+        stdout.write(`\x1b[${renderedLines}A\r`);
+        for (let index = 0; index < renderedLines; index += 1) {
+            stdout.write("\x1b[2K");
+            if (index < renderedLines - 1)
+                stdout.write("\x1b[1B\r");
+        }
+        if (renderedLines > 1)
+            stdout.write(`\x1b[${renderedLines - 1}A\r`);
+        renderedLines = 0;
+    };
+    const render = () => {
+        clear();
+        const lines = [
+            prompt,
+            ...choices.map((label, index) => index === selected ? `${blue}› ${label}${reset}` : `  ${label}`),
+            `${dim}↑/↓ select · Enter confirm · Esc cancel${reset}`,
+        ];
+        stdout.write(`${lines.join("\n")}\n`);
+        renderedLines = lines.length;
+    };
+    return await new Promise((resolve) => {
+        const finish = (value) => {
+            stdin.off("data", onData);
+            stdin.setRawMode(previousRawMode);
+            clear();
+            resolve(value);
+        };
+        const onData = (chunk) => {
+            for (const key of tokenizeKeyInput(chunk)) {
+                if (key === "\x1b[A" || key === "\x1b[B" || key === "\t") {
+                    selected = moveResumeSelection(selected, key === "\x1b[A" ? -1 : 1, choices.length);
+                    render();
+                }
+                else if (/^[1-9]$/.test(key) && Number(key) <= choices.length)
+                    return finish(Number(key) - 1);
+                else if (choices.length === 2 && key.toLowerCase() === "y")
+                    return finish(0);
+                else if (choices.length === 2 && key.toLowerCase() === "n")
+                    return finish(1);
+                else if (key === "\x1b" || key === "\u0003")
+                    return finish();
+                else if (key === "\r" || key === "\n")
+                    return finish(selected);
+            }
+        };
+        stdin.setEncoding("utf8");
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("data", onData);
+        render();
+    });
+}
+function tokenizeKeyInput(input) {
+    const tokens = [];
+    for (let index = 0; index < input.length;) {
+        const fourByteSequence = input.slice(index, index + 4);
+        if (fourByteSequence === "\x1b[3~") {
+            tokens.push(fourByteSequence);
+            index += 4;
+            continue;
+        }
+        const sequence = input.slice(index, index + 3);
+        if (["\x1b[A", "\x1b[B", "\x1b[C", "\x1b[D", "\x1b[H", "\x1b[F"].includes(sequence)) {
+            tokens.push(sequence);
+            index += 3;
+            continue;
+        }
+        const char = Array.from(input.slice(index))[0] ?? "";
+        tokens.push(char);
+        index += char.length;
+    }
+    return tokens;
+}
+async function readStdinLine() {
+    let line = "";
+    for await (const chunk of stdin) {
+        const text = String(chunk);
+        const newline = text.search(/\r|\n/);
+        if (newline >= 0)
+            return `${line}${text.slice(0, newline)}`;
+        line += text;
+    }
+    return line;
+}
+function renderSlashCommandMenu(useColor) {
+    const width = Math.max(...slashCommands.map((c) => displayLength(c.usage)));
+    const title = useColor ? "\x1b[38;2;96;165;250mSlash commands\x1b[0m" : "Slash commands";
+    const rows = slashCommands
+        .map((command) => {
+        const usage = useColor ? `\x1b[38;2;96;165;250m${command.usage}\x1b[0m` : command.usage;
+        return `  ${padDisplay(command.usage, width, usage)}  ${command.description}`;
+    })
+        .join("\n");
+    return `\n${title}\n${rows}\n`;
+}
+function renderSlashPaletteLines(selectedIndex, useColor, filtered, buffer) {
+    const query = buffer.startsWith("/") ? buffer.slice(1) : buffer;
+    const title = useColor
+        ? `\x1b[38;2;96;165;250mCommands${query ? ` · “${query}”` : ""}\x1b[0m`
+        : `Commands${query ? ` · “${query}”` : ""}`;
+    if (filtered.length === 0) {
+        const empty = useColor ? "\x1b[90m  (no matching commands)\x1b[0m" : "  (no matching commands)";
+        const hint = useColor ? "\x1b[90mType to filter · Esc clear\x1b[0m" : "Type to filter · Esc clear";
+        return [title, empty, hint];
+    }
+    const width = Math.max(...filtered.map((c) => displayLength(c.usage)));
+    const maxVisible = 8;
+    const maxStart = Math.max(0, filtered.length - maxVisible);
+    const start = Math.min(Math.max(0, selectedIndex - Math.floor(maxVisible / 2)), maxStart);
+    const visible = filtered.slice(start, start + maxVisible);
+    const rows = visible.map((command, offset) => {
+        const index = start + offset;
+        const pointer = index === selectedIndex ? "›" : " ";
+        const text = `${pointer} ${padDisplay(command.usage, width)}  ${command.description}`;
+        if (!useColor)
+            return text;
+        if (index === selectedIndex)
+            return `\x1b[7m${text}\x1b[0m`;
+        return `\x1b[90m${text}\x1b[0m`;
+    });
+    while (rows.length < maxVisible)
+        rows.push("");
+    const range = filtered.length > maxVisible
+        ? `${start + 1}-${Math.min(start + maxVisible, filtered.length)}/${filtered.length}`
+        : `${filtered.length}/${filtered.length}`;
+    const hint = useColor
+        ? "\x1b[90m↑/↓ select · Enter run · type to search · Esc close\x1b[0m"
+        : "↑/↓ select · Enter run · type to search · Esc close";
+    return [title, ...rows, `${hint} · ${useColor ? `\x1b[90m${range}\x1b[0m` : range}`];
+}
+class TaskActivityLog {
+    activities = [];
+    record(event) {
+        if (event.type === "task_start") {
+            this.activities.push({
+                id: event.id,
+                subagentType: event.subagentType,
+                description: event.description,
+                status: "running",
+                startedAt: Date.now(),
+                steps: [],
+            });
+            return;
+        }
+        if (event.type === "task_progress") {
+            const activity = this.activities.find((a) => a.id === event.id);
+            if (!activity)
+                return;
+            const last = activity.steps[activity.steps.length - 1];
+            if (last?.text === event.message)
+                return;
+            activity.steps.push({ at: Date.now(), text: event.message });
+            return;
+        }
+        if (event.type === "task_finish") {
+            const activity = this.activities.find((a) => a.id === event.id);
+            if (!activity)
+                return;
+            activity.status = "finished";
+            activity.finishedAt = Date.now();
+            activity.result = event.result;
+        }
+    }
+    clear() {
+        this.activities.length = 0;
+    }
+    render(useColor) {
+        if (this.activities.length === 0)
+            return "\nNo Task activity yet.\n";
+        const title = useColor ? "\x1b[38;2;96;165;250mTasks\x1b[0m" : "Tasks";
+        const rows = this.activities
+            .slice(-12)
+            .map((a) => this.renderActivity(a, useColor))
+            .join("\n\n");
+        return `\n${title}\n${rows}\n`;
+    }
+    renderActivity(activity, useColor) {
+        const duration = `${(((activity.finishedAt ?? Date.now()) - activity.startedAt) / 1000).toFixed(1)}s`;
+        const status = activity.status === "finished" ? "done" : "running";
+        const bullet = activity.status === "finished" ? paint("●", "green", useColor) : paint("○", "blue", useColor);
+        const header = `${bullet} Task(${activity.subagentType}): ${activity.description}  ${paint(`${status} · ${duration}`, "gray", useColor)}`;
+        const stepLines = activity.steps.slice(-8).map((step) => {
+            const elapsed = `${((step.at - activity.startedAt) / 1000).toFixed(1)}s`;
+            return `  ${paint("│", "gray", useColor)} ${paint(elapsed, "gray", useColor)}  ${compactLine(step.text, 100)}`;
+        });
+        if (activity.result)
+            stepLines.push(`  ${paint("└", "gray", useColor)} ${compactLine(activity.result, 140)}`);
+        else if (stepLines.length) {
+            const last = stepLines[stepLines.length - 1];
+            stepLines[stepLines.length - 1] = last.replace("│", "└");
+        }
+        return [header, ...stepLines].join("\n");
+    }
+}
+function paint(text, colorName, useColor) {
+    if (!useColor)
+        return text;
+    const code = colorName === "green" ? "\x1b[32m" : colorName === "blue" ? "\x1b[38;2;96;165;250m" : "\x1b[90m";
+    return `${code}${text}\x1b[0m`;
+}
+function compactLine(text, max) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (displayLength(normalized) <= max)
+        return normalized;
+    return truncateDisplay(normalized, max);
+}
+function renderInputPrompt(useColor) {
+    return useColor ? "\x1b[38;2;96;165;250m›\x1b[0m " : "› ";
+}
+function renderLiveStatusLine(useColor) {
+    if (!liveStatus)
+        return undefined;
+    const elapsed = `${((Date.now() - liveStatus.startedAt) / 1000).toFixed(1)}s`;
+    const label = liveStatus.text.includes(" ") || liveStatus.text.endsWith("...")
+        ? liveStatus.text
+        : `${liveStatus.text}...`;
+    return formatWaitLine({ frame: liveStatus.frame, label, elapsed, useColor });
+}
+function renderInputBorder(position, useColor) {
+    const terminalWidth = Math.max(48, Math.min(stdout.columns ?? 100, 100));
+    const left = position === "top" ? "╭" : "╰";
+    const right = position === "top" ? "╮" : "╯";
+    const line = `${left}${"─".repeat(Math.max(0, terminalWidth - 2))}${right}`;
+    return useColor ? `\x1b[38;2;84;94;112m${line}\x1b[0m` : line;
+}
+function renderWelcomeBanner(options) {
+    const blue = options.color ? "\x1b[38;2;96;165;250m" : "";
+    const green = options.color ? "\x1b[32m" : "";
+    const dim = options.color ? "\x1b[90m" : "";
+    const reset = options.color ? "\x1b[0m" : "";
+    const agents = options.agents.length ? options.agents.join(" · ") : "—";
+    const cwd = shortenHome(options.cwd);
+    const logo = ASCII_LOGO.map((line) => `${blue}${line}${reset}`).join("\n");
+    return [
+        "",
+        logo,
+        "",
+        `${dim}v${PRODUCT.version}${reset}  ·  ${dim}${PRODUCT.tagline}${reset}`,
+        "",
+        `${dim}model${reset}   ${options.model}`,
+        `${dim}cwd${reset}     ${cwd}`,
+        `${dim}agents${reset}  ${agents}`,
+        `${dim}trace${reset}   ${options.quiet ? "quiet" : "verbose"}`,
+        `${dim}approval${reset} ${options.yolo ? `${green}yolo${reset}` : "ask"}`,
+        "",
+        `${dim}Type / to search · /thought expands Thought · /help${reset}`,
+        "",
+        "",
+    ].join("\n");
+}
+function padDisplay(rawText, width, renderedText = rawText) {
+    return `${renderedText}${" ".repeat(Math.max(0, width - displayLength(rawText)))}`;
+}
+function truncateDisplay(text, width) {
+    if (displayLength(text) <= width)
+        return text;
+    let result = "";
+    let length = 0;
+    for (const char of text) {
+        const charWidth = displayLength(char);
+        if (length + charWidth > width - 1)
+            break;
+        result += char;
+        length += charWidth;
+    }
+    return `${result}…`;
+}
+function inputView(value, cursor, width) {
+    const characters = Array.from(value);
+    const normalize = (text) => text.replace(/\n/g, " ↵ ").replace(/\t/g, "  ");
+    const before = normalize(characters.slice(0, cursor).join(""));
+    const after = normalize(characters.slice(cursor).join(""));
+    if (displayLength(before) >= width) {
+        const visible = takeDisplayEnd(before, width - 1);
+        return { text: `…${visible}`, cursorWidth: 1 + displayLength(visible) };
+    }
+    const remaining = Math.max(0, width - displayLength(before));
+    const visibleAfter = remaining > 0 ? truncateDisplay(after, remaining) : "";
+    return { text: `${before}${visibleAfter}`, cursorWidth: displayLength(before) };
+}
+function takeDisplayEnd(text, width) {
+    const result = [];
+    let length = 0;
+    for (const char of Array.from(text).reverse()) {
+        const charWidth = displayLength(char);
+        if (length + charWidth > width)
+            break;
+        result.push(char);
+        length += charWidth;
+    }
+    return result.reverse().join("");
+}
+function submittedInputLabel(value) {
+    if (!value.includes("\n"))
+        return value;
+    const lines = value.split("\n").length;
+    return `[Pasted ${lines} lines · ${Array.from(value).length} chars]`;
+}
+function displayLength(text) {
+    let length = 0;
+    for (const char of text)
+        length += isWideChar(char) ? 2 : 1;
+    return length;
+}
+function isWideChar(char) {
+    return /[\u1100-\u115F\u2E80-\uA4CF\uAC00-\uD7A3\uF900-\uFAFF\uFE10-\uFE19\uFE30-\uFE6F\uFF00-\uFF60\uFFE0-\uFFE6]/u.test(char);
+}
+function shortenHome(cwd) {
+    const home = process.env.HOME;
+    return home && cwd.startsWith(home) ? cwd.replace(home, "~") : cwd;
+}
+function parseCommandWords(inputText) {
+    const words = [];
+    const pattern = /"([^"]*)"|'([^']*)'|(\S+)/g;
+    for (const match of inputText.matchAll(pattern)) {
+        words.push(match[1] ?? match[2] ?? match[3] ?? "");
+    }
+    return words;
+}
+function formatRuntimeError(error, verbose) {
+    if (isAbortError(error))
+        return "Interrupted by user.";
+    const message = error instanceof Error ? error.message : String(error);
+    if (verbose && error instanceof Error)
+        return error.stack ?? message;
+    const bounded = message.length > 1200 ? `${message.slice(0, 1200)}...` : message;
+    return `Request failed after automatic recovery: ${bounded}`;
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}
+async function runWithRenderer(renderer, fn) {
+    renderer.resetTurn();
+    try {
+        return await fn();
+    }
+    finally {
+        renderer.finishTurn();
+    }
+}
+async function readStdin() {
+    let data = "";
+    stdin.setEncoding("utf8");
+    for await (const chunk of stdin)
+        data += chunk;
+    return data;
+}
+main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});