hoomanjs 1.29.2 → 1.30.0

package/dist/chat/app.js

@@ -1,12 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useRef, useState, } from "react";
 import fastq from "fastq";
-import { Box, useApp, useInput, useWindowSize } from "ink";
-import { BeforeToolCallEvent, Message, TextBlock, } from "@strands-agents/sdk";
+import { Box, Static, useApp, useInput } from "ink";
+import { Message, TextBlock, } from "@strands-agents/sdk";
 import { accumulateUsage, createEmptyUsage, } from "../core/utils/strands-usage-accumulate.js";
-import { bootstrap } from "../core/index.js";
+import { modelProviders } from "../core/models/index.js";
+import { MODE_DEFINITIONS, formatModeNames, getModeDefinition, isKnownSessionMode, } from "../core/modes/index.js";
 import { takeFileToolDisplay } from "../core/state/file-tool-display.js";
-import { ChatApprovalController, createChatApprovalHandler, } from "./approvals.js";
 import { ApprovalPrompt } from "./components/ApprovalPrompt.js";
 import { Composer } from "./components/Composer.js";
 import { SelectPicker } from "./components/SelectPicker.js";
@@ -14,15 +14,16 @@ import { QueuedPrompts } from "./components/QueuedPrompts.js";
 import { SlashCommands } from "./components/SlashCommands.js";
 import { StatusBar } from "./components/StatusBar.js";
 import { TodoPanel } from "./components/TodoPanel.js";
-import { TranscriptViewport } from "./components/TranscriptViewport.js";
+import { Transcript, TranscriptLine } from "./components/Transcript.js";
 import { getTodoViewState } from "../core/state/todos.js";
 import { isExitRequested } from "../core/state/exit-request.js";
-import { copyAgentAppState } from "../core/state/agent-app-state.js";
 import { getModeState, setSessionMode, } from "../core/state/session-mode.js";
 import { isYoloEnabled, setYoloEnabled } from "../core/state/yolo.js";
 import { applySessionMode } from "../core/agent/sync-tool-registry-mode.js";
 import { attachmentPathsToPromptBlocks } from "../core/utils/attachments.js";
 import { isMouseInput } from "./mouse.js";
+import { readBundledPrompt } from "../core/prompts/bundled.js";
+import { runWithAgentMemoryScope } from "../core/memory/index.js";
 function emptyTurnUsage() {
     return { ...createEmptyUsage(), latencyMs: 0 };
 }
@@ -38,6 +39,8 @@ function normalizePromptSubmission(value) {
     };
 }
 const INPUT_HINT = "shift/meta+enter or \\+enter: newline | esc/ctrl+c: cancel or exit";
+const INPUT_HINT_WITH_STEERING = "enter on empty input: steer active turn with queued prompts | shift/meta+enter or \\+enter: newline | esc/ctrl+c: cancel or exit";
+const INIT_AGENTS_PROMPT = readBundledPrompt("static", "init.md");
 function nowId() {
     return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -129,16 +132,23 @@ function parseYoloToggleArg(raw) {
 }
 function parseSessionModeArg(raw) {
     const t = raw.trim().toLowerCase();
-    if (t === "default" || t === "plan" || t === "ask") {
+    if (isKnownSessionMode(t)) {
         return t;
     }
     return undefined;
 }
+function sessionModeLabel(mode) {
+    return getModeDefinition(mode)?.name ?? mode;
+}
 function listModelsText(config) {
     const current = currentModelName(config);
     const options = config.llms.map((entry) => {
         const marker = entry.name === current ? "*" : "-";
-        return `${marker} ${entry.name} (${entry.options.provider}/${entry.options.model})`;
+        const resolved = config.resolveLlm(entry.name);
+        if (!resolved) {
+            return `${marker} ${entry.name} (${entry.options.provider}/${entry.options.model})`;
+        }
+        return `${marker} ${entry.name} (${entry.options.provider} -> ${resolved.options.provider}/${resolved.options.model})`;
     });
     return [
         `Current model: ${current}`,
@@ -148,9 +158,13 @@ function listModelsText(config) {
     ].join("\n");
 }
 const SLASH_COMMANDS = [
+    {
+        name: "init",
+        description: "Generate or refresh AGENTS.md for this project.",
+    },
     {
         name: "mode",
-        description: "Session mode: default, plan, or ask.",
+        description: `Session mode: ${formatModeNames()}.`,
     },
     {
         name: "model",
@@ -175,11 +189,8 @@ function matchingSlashCommands(input) {
     }
     return SLASH_COMMANDS.filter((item) => item.name.startsWith(query));
 }
-export function ChatApp({ agent, config, sessionId, manager, registry, prompt, onExit, }) {
+export function ChatApp({ agent, config, sessionId, manager, registry, approvals, steering, prompt, onExit, }) {
     const { exit } = useApp();
-    const { rows } = useWindowSize();
-    const [currentAgent, setCurrentAgent] = useState(agent);
-    const [currentManager, setCurrentManager] = useState(manager);
     const [input, setInput] = useState("");
     const [running, setRunning] = useState(false);
     const [status, setStatus] = useState("ready");
@@ -198,16 +209,23 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
     }, []);
     const [slashHighlightIndex, setSlashHighlightIndex] = useState(0);
     const [queuedPrompts, setQueuedPrompts] = useState([]);
-    const [liveReasoning, setLiveReasoning] = useState("");
-    const [followRequest, setFollowRequest] = useState(0);
     const [todoState, setTodoState] = useState(() => getTodoViewState(agent));
-    const controllerRef = useRef(new ChatApprovalController());
     const mountedRef = useRef(true);
     const runningRef = useRef(false);
     const assistantLineIdRef = useRef(null);
+    const assistantCommittedTextRef = useRef("");
+    const streamedAssistantBlockRef = useRef(null);
+    const thoughtLineIdRef = useRef(null);
+    const thoughtTextRef = useRef("");
+    const thoughtStartedAtRef = useRef(null);
     const toolLineIdsRef = useRef(new Map());
     const pendingToolLineIdsRef = useRef([]);
     const initialRanRef = useRef(false);
+    const queuedPromptsRef = useRef([]);
+    const skippedQueueIdsRef = useRef(new Set());
+    useEffect(() => {
+        queuedPromptsRef.current = queuedPrompts;
+    }, [queuedPrompts]);
     useEffect(() => {
         let cancelled = false;
         void registry
@@ -240,23 +258,20 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
         };
     }, [running, turnStartedAt]);
     useEffect(() => {
-        const controller = controllerRef.current;
-        const cleanupListener = controller.subscribe(() => {
-            setPendingApproval(controller.pending);
+        const cleanupListener = approvals.subscribe(() => {
+            setPendingApproval(approvals.pending);
         });
-        const cleanupHook = currentAgent.addHook(BeforeToolCallEvent, createChatApprovalHandler(controller));
         return () => {
             cleanupListener();
-            cleanupHook();
         };
-    }, [currentAgent]);
+    }, [approvals]);
     useEffect(() => {
         let active = true;
         const refresh = () => {
             if (!active) {
                 return;
             }
-            setTodoState(getTodoViewState(currentAgent));
+            setTodoState(getTodoViewState(agent));
         };
         refresh();
         const timer = setInterval(refresh, running ? 200 : 800);
@@ -264,8 +279,8 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
             active = false;
             clearInterval(timer);
         };
-    }, [currentAgent, running]);
-    const totalTools = currentAgent.tools?.length ?? 0;
+    }, [agent, running]);
+    const totalTools = agent.tools?.length ?? 0;
     const slashCommands = useMemo(() => matchingSlashCommands(input), [input]);
     useEffect(() => {
         setSlashHighlightIndex((i) => {
@@ -317,26 +332,98 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
             return next;
         });
     }, []);
+    const replaceAssistantText = useCallback((text) => {
+        const id = assistantLineIdRef.current;
+        if (!id) {
+            return;
+        }
+        setLines((prev) => prev.map((line) => (line.id === id ? { ...line, content: text } : line)));
+    }, []);
     const appendAssistantText = useCallback((text) => {
+        streamedAssistantBlockRef.current = `${streamedAssistantBlockRef.current ?? ""}${text}`;
+        replaceAssistantText(`${assistantCommittedTextRef.current}${streamedAssistantBlockRef.current}`);
+    }, [replaceAssistantText]);
+    const commitAssistantBlock = useCallback((text) => {
+        assistantCommittedTextRef.current = `${assistantCommittedTextRef.current}${text}`;
+        streamedAssistantBlockRef.current = null;
+        replaceAssistantText(assistantCommittedTextRef.current);
+    }, [replaceAssistantText]);
+    const finalizeAssistantLine = useCallback(() => {
         const id = assistantLineIdRef.current;
         if (!id) {
             return;
         }
-        setLines((prev) => prev.map((line) => line.id === id ? { ...line, content: `${line.content}${text}` } : line));
+        updateLine(id, { done: true });
+        assistantLineIdRef.current = null;
+        assistantCommittedTextRef.current = "";
+        streamedAssistantBlockRef.current = null;
+    }, [updateLine]);
+    const ensureAssistantLine = useCallback(() => {
+        const existing = assistantLineIdRef.current;
+        if (existing) {
+            return existing;
+        }
+        const id = nowId();
+        assistantLineIdRef.current = id;
+        assistantCommittedTextRef.current = "";
+        streamedAssistantBlockRef.current = null;
+        appendLine({
+            id,
+            role: "assistant",
+            content: "",
+            done: false,
+        });
+        return id;
+    }, [appendLine]);
+    const estimateReasoningTokens = useCallback((text) => {
+        const trimmed = text.trim();
+        if (!trimmed) {
+            return 0;
+        }
+        return Math.max(1, Math.round(trimmed.length / 4));
     }, []);
-    const rebuildAgent = useCallback(async () => {
-        const messageSnapshot = currentAgent.messages.map((message) => message.toJSON());
-        const { agent: nextAgent, mcp: { manager: nextManager }, } = await bootstrap("default", { sessionId, yolo: isYoloEnabled(currentAgent) }, false, config);
-        nextAgent.messages.length = 0;
-        for (const message of messageSnapshot) {
-            nextAgent.messages.push(Message.fromJSON(message));
-        }
-        copyAgentAppState(currentAgent, nextAgent);
-        applySessionMode(nextAgent);
-        setCurrentAgent(nextAgent);
-        setCurrentManager(nextManager);
-        await currentManager.disconnect();
-    }, [config, currentAgent, currentManager, sessionId]);
+    const finalizeThoughtLine = useCallback(() => {
+        const id = thoughtLineIdRef.current;
+        if (!id) {
+            return;
+        }
+        const finishedAt = Date.now();
+        updateLine(id, {
+            done: true,
+            finishedAt,
+            estimatedTokens: estimateReasoningTokens(thoughtTextRef.current),
+        });
+        thoughtLineIdRef.current = null;
+        thoughtTextRef.current = "";
+        thoughtStartedAtRef.current = null;
+    }, [estimateReasoningTokens, updateLine]);
+    const ensureThoughtLine = useCallback(() => {
+        const existing = thoughtLineIdRef.current;
+        if (existing) {
+            return existing;
+        }
+        finalizeAssistantLine();
+        const startedAt = Date.now();
+        const id = nowId();
+        thoughtLineIdRef.current = id;
+        thoughtTextRef.current = "";
+        thoughtStartedAtRef.current = startedAt;
+        appendLine({
+            id,
+            role: "thought",
+            content: "",
+            done: false,
+            startedAt,
+        });
+        return id;
+    }, [appendLine, finalizeAssistantLine]);
+    const appendThoughtText = useCallback((text) => {
+        const id = ensureThoughtLine();
+        thoughtTextRef.current = `${thoughtTextRef.current}${text}`;
+        setLines((prev) => prev.map((line) => line.id === id
+            ? { ...line, content: `${line.content}${text}` }
+            : line));
+    }, [ensureThoughtLine]);
     const handleModelCommand = useCallback(async (args) => {
         if (runningRef.current) {
             appendLine({
@@ -374,7 +461,8 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
             })),
         });
         try {
-            await rebuildAgent();
+            const provider = await modelProviders[config.llm.provider]();
+            agent.model = provider.create(config.llm.model, config.llm.params);
         }
         catch (error) {
             config.update({
@@ -391,7 +479,7 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
                 done: true,
             });
         }
-    }, [appendLine, config, rebuildAgent]);
+    }, [agent, appendLine, config]);
     const handleYoloCommand = useCallback(async (args) => {
         if (runningRef.current) {
             appendLine({
@@ -419,13 +507,13 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
             });
             return;
         }
-        const prev = isYoloEnabled(currentAgent);
+        const prev = isYoloEnabled(agent);
         if (prev === enabled) {
             return;
         }
-        setYoloEnabled(currentAgent, enabled);
+        setYoloEnabled(agent, enabled);
         bumpSessionChrome();
-    }, [appendLine, bumpSessionChrome, currentAgent]);
+    }, [agent, appendLine, bumpSessionChrome]);
     const handleModeCommand = useCallback(async (args) => {
         if (runningRef.current) {
             appendLine({
@@ -448,19 +536,19 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
                 id: nowId(),
                 role: "system",
                 title: "mode",
-                content: `Unknown mode "${trimmed}". Use default, plan, or ask, or open the picker with /mode.`,
+                content: `Unknown mode "${trimmed}". Use agent, ask, or plan, or open the picker with /mode.`,
                 done: true,
             });
             return;
         }
-        const prev = getModeState(currentAgent).mode;
+        const prev = getModeState(agent).mode;
         if (prev === mode) {
             return;
         }
-        setSessionMode(currentAgent, mode);
-        applySessionMode(currentAgent);
+        setSessionMode(agent, mode);
+        applySessionMode(agent);
         bumpSessionChrome();
-    }, [appendLine, bumpSessionChrome, currentAgent]);
+    }, [agent, appendLine, bumpSessionChrome]);
     const runTurn = useCallback(async (prompt) => {
         const trimmed = prompt.text.trim();
         if (!trimmed && prompt.attachments.length === 0) {
@@ -471,7 +559,6 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
         setRunning(true);
         setStatus("thinking");
         setTurnStartedAt(Date.now());
-        setLiveReasoning("");
         setTurnCount((value) => value + 1);
         appendLine({
             id: nowId(),
@@ -483,14 +570,6 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
                 : trimmed,
             done: true,
         });
-        const assistantId = nowId();
-        assistantLineIdRef.current = assistantId;
-        appendLine({
-            id: assistantId,
-            role: "assistant",
-            content: "",
-            done: false,
-        });
         try {
             const streamInput = attachmentBlocks.length > 0
                 ? [
@@ -503,136 +582,142 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
                     }),
                 ]
                 : trimmed;
-            for await (const event of currentAgent.stream(streamInput)) {
-                const e = event;
-                switch (e.type) {
-                    case "contentBlockEvent": {
-                        const block = e.contentBlock;
-                        if (block.type === "textBlock") {
-                            appendAssistantText(block.text ?? "");
-                        }
-                        else if (block.type === "toolUseBlock") {
-                            const toolId = nowId();
-                            const toolUseId = getToolUseId(block);
-                            if (toolUseId) {
-                                toolLineIdsRef.current.set(toolUseId, toolId);
-                            }
-                            else {
-                                pendingToolLineIdsRef.current.push(toolId);
+            await runWithAgentMemoryScope(agent, async () => {
+                for await (const event of agent.stream(streamInput)) {
+                    const e = event;
+                    switch (e.type) {
+                        case "contentBlockEvent": {
+                            const block = e.contentBlock;
+                            if (block.type === "textBlock") {
+                                finalizeThoughtLine();
+                                ensureAssistantLine();
+                                commitAssistantBlock(block.text ?? "");
                             }
-                            appendLine({
-                                id: toolId,
-                                role: "tool",
-                                title: "tool",
-                                toolName: block.name ?? "unknown",
-                                content: stringifyUnknown(block.input ?? {}),
-                                phase: "running",
-                                done: false,
-                            });
-                            if (assistantLineIdRef.current) {
-                                moveLineToEnd(assistantLineIdRef.current);
+                            else if (block.type === "toolUseBlock") {
+                                finalizeThoughtLine();
+                                finalizeAssistantLine();
+                                const toolId = nowId();
+                                const toolUseId = getToolUseId(block);
+                                if (toolUseId) {
+                                    toolLineIdsRef.current.set(toolUseId, toolId);
+                                }
+                                else {
+                                    pendingToolLineIdsRef.current.push(toolId);
+                                }
+                                appendLine({
+                                    id: toolId,
+                                    role: "tool",
+                                    title: "tool",
+                                    toolName: block.name ?? "unknown",
+                                    content: stringifyUnknown(block.input ?? {}),
+                                    phase: "running",
+                                    done: false,
+                                });
                             }
+                            break;
                         }
-                        break;
-                    }
-                    case "toolResultEvent": {
-                        const resultContent = toToolResultText(e.result);
-                        const toolUseId = getToolUseId(e.result);
-                        const fileToolDisplay = takeFileToolDisplay(currentAgent.appState, toolUseId);
-                        let toolLineId = toolUseId
-                            ? toolLineIdsRef.current.get(toolUseId)
-                            : undefined;
-                        if (toolLineId && toolUseId) {
-                            toolLineIdsRef.current.delete(toolUseId);
-                        }
-                        toolLineId ??= pendingToolLineIdsRef.current.shift();
-                        if (!toolLineId) {
-                            const firstTrackedTool = toolLineIdsRef.current
-                                .entries()
-                                .next();
-                            if (!firstTrackedTool.done) {
-                                const [trackedToolUseId, trackedToolLineId] = firstTrackedTool.value;
-                                toolLineIdsRef.current.delete(trackedToolUseId);
-                                toolLineId = trackedToolLineId;
+                        case "toolResultEvent": {
+                            const resultContent = toToolResultText(e.result);
+                            const toolUseId = getToolUseId(e.result);
+                            const fileToolDisplay = takeFileToolDisplay(agent.appState, toolUseId);
+                            let toolLineId = toolUseId
+                                ? toolLineIdsRef.current.get(toolUseId)
+                                : undefined;
+                            if (toolLineId && toolUseId) {
+                                toolLineIdsRef.current.delete(toolUseId);
                             }
-                        }
-                        if (toolLineId) {
-                            updateLine(toolLineId, {
-                                phase: "done",
-                                done: true,
-                                resultContent,
-                                fileToolDisplay,
-                            });
-                        }
-                        else {
-                            appendLine({
-                                id: nowId(),
-                                role: "tool",
-                                title: "tool",
-                                toolName: "unknown",
-                                content: "",
-                                resultContent,
-                                fileToolDisplay,
-                                phase: "done",
-                                done: true,
-                            });
-                        }
-                        break;
-                    }
-                    case "toolStreamUpdateEvent":
-                        setStatus("running tool");
-                        break;
-                    case "modelStreamUpdateEvent": {
-                        const modelEvent = e.event;
-                        if (modelEvent?.type === "modelContentBlockDeltaEvent") {
-                            const delta = modelEvent.delta;
-                            if (delta?.type === "reasoningContentDelta" && delta.text) {
-                                setStatus("thinking");
-                                setLiveReasoning((prev) => `${prev}${delta.text}`);
+                            toolLineId ??= pendingToolLineIdsRef.current.shift();
+                            if (!toolLineId) {
+                                const firstTrackedTool = toolLineIdsRef.current
+                                    .entries()
+                                    .next();
+                                if (!firstTrackedTool.done) {
+                                    const [trackedToolUseId, trackedToolLineId] = firstTrackedTool.value;
+                                    toolLineIdsRef.current.delete(trackedToolUseId);
+                                    toolLineId = trackedToolLineId;
+                                }
+                            }
+                            if (toolLineId) {
+                                updateLine(toolLineId, {
+                                    phase: "done",
+                                    done: true,
+                                    resultContent,
+                                    fileToolDisplay,
+                                });
                             }
-                            else if (delta?.type === "textDelta") {
-                                setStatus("streaming");
+                            else {
+                                appendLine({
+                                    id: nowId(),
+                                    role: "tool",
+                                    title: "tool",
+                                    toolName: "unknown",
+                                    content: "",
+                                    resultContent,
+                                    fileToolDisplay,
+                                    phase: "done",
+                                    done: true,
+                                });
                             }
+                            break;
                         }
-                        if (modelEvent?.type === "modelMetadataEvent") {
-                            const u = (modelEvent.usage ?? {});
-                            const delta = {
-                                inputTokens: u.inputTokens ?? 0,
-                                outputTokens: u.outputTokens ?? 0,
-                                totalTokens: u.totalTokens ?? 0,
-                                ...(u.cacheReadInputTokens !== undefined && {
-                                    cacheReadInputTokens: u.cacheReadInputTokens,
-                                }),
-                                ...(u.cacheWriteInputTokens !== undefined && {
-                                    cacheWriteInputTokens: u.cacheWriteInputTokens,
-                                }),
-                            };
-                            const metricsData = (modelEvent.metrics ?? {});
-                            const lat = metricsData.latencyMs ?? 0;
-                            // Sum every `modelMetadataEvent` for this chat session (Strands meter semantics). Never reset on
-                            // new prompts so the footer stays monotonic; note input totals sum per-request prompt sizes.
-                            setUsage((prev) => {
-                                const tokens = {
-                                    inputTokens: prev.inputTokens,
-                                    outputTokens: prev.outputTokens,
-                                    totalTokens: prev.totalTokens,
-                                    ...(prev.cacheReadInputTokens !== undefined && {
-                                        cacheReadInputTokens: prev.cacheReadInputTokens,
+                        case "toolStreamUpdateEvent":
+                            setStatus("running tool");
+                            break;
+                        case "modelStreamUpdateEvent": {
+                            const modelEvent = e.event;
+                            if (modelEvent?.type === "modelContentBlockDeltaEvent") {
+                                const delta = modelEvent.delta;
+                                if (delta?.type === "reasoningContentDelta" && delta.text) {
+                                    setStatus("thinking");
+                                    appendThoughtText(delta.text);
+                                }
+                                else if (delta?.type === "textDelta" && delta.text) {
+                                    finalizeThoughtLine();
+                                    setStatus("streaming");
+                                    ensureAssistantLine();
+                                    appendAssistantText(delta.text);
+                                }
+                            }
+                            if (modelEvent?.type === "modelMetadataEvent") {
+                                const u = (modelEvent.usage ?? {});
+                                const delta = {
+                                    inputTokens: u.inputTokens ?? 0,
+                                    outputTokens: u.outputTokens ?? 0,
+                                    totalTokens: u.totalTokens ?? 0,
+                                    ...(u.cacheReadInputTokens !== undefined && {
+                                        cacheReadInputTokens: u.cacheReadInputTokens,
                                     }),
-                                    ...(prev.cacheWriteInputTokens !== undefined && {
-                                        cacheWriteInputTokens: prev.cacheWriteInputTokens,
+                                    ...(u.cacheWriteInputTokens !== undefined && {
+                                        cacheWriteInputTokens: u.cacheWriteInputTokens,
                                     }),
                                 };
-                                accumulateUsage(tokens, delta);
-                                return { ...tokens, latencyMs: prev.latencyMs + lat };
-                            });
+                                const metricsData = (modelEvent.metrics ?? {});
+                                const lat = metricsData.latencyMs ?? 0;
+                                // Sum every `modelMetadataEvent` for this chat session (Strands meter semantics). Never reset on
+                                // new prompts so the footer stays monotonic; note input totals sum per-request prompt sizes.
+                                setUsage((prev) => {
+                                    const tokens = {
+                                        inputTokens: prev.inputTokens,
+                                        outputTokens: prev.outputTokens,
+                                        totalTokens: prev.totalTokens,
+                                        ...(prev.cacheReadInputTokens !== undefined && {
+                                            cacheReadInputTokens: prev.cacheReadInputTokens,
+                                        }),
+                                        ...(prev.cacheWriteInputTokens !== undefined && {
+                                            cacheWriteInputTokens: prev.cacheWriteInputTokens,
+                                        }),
+                                    };
+                                    accumulateUsage(tokens, delta);
+                                    return { ...tokens, latencyMs: prev.latencyMs + lat };
+                                });
+                            }
+                            break;
                         }
-                        break;
+                        default:
+                            break;
                     }
-                    default:
-                        break;
                 }
-            }
+            });
         }
         catch (error) {
             appendLine({
@@ -644,8 +729,8 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
             });
         }
         finally {
-            updateLine(assistantId, { done: true });
-            assistantLineIdRef.current = null;
+            finalizeThoughtLine();
+            finalizeAssistantLine();
             for (const toolLineId of toolLineIdsRef.current.values()) {
                 updateLine(toolLineId, { phase: "done", done: true });
             }
@@ -657,19 +742,21 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
             runningRef.current = false;
             setRunning(false);
             setTurnStartedAt(null);
-            setLiveReasoning("");
             setStatus("ready");
-            if (isExitRequested(currentAgent)) {
+            if (isExitRequested(agent)) {
                 onExit();
                 exit();
             }
         }
     }, [
         appendAssistantText,
+        appendThoughtText,
         appendLine,
-        currentAgent,
+        agent,
         exit,
-        moveLineToEnd,
+        ensureAssistantLine,
+        finalizeAssistantLine,
+        finalizeThoughtLine,
         onExit,
         updateLine,
     ]);
@@ -680,6 +767,9 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
     const queueRef = useRef(null);
     if (!queueRef.current) {
         queueRef.current = fastq.promise(async (item) => {
+            if (skippedQueueIdsRef.current.delete(item.id)) {
+                return;
+            }
             if (mountedRef.current) {
                 setQueuedPrompts((prev) => prev.filter((entry) => entry.id !== item.id));
             }
@@ -728,8 +818,37 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
         if (pendingApproval) {
             return;
         }
+        const trimmed = value.text.trim();
+        if (runningRef.current &&
+            !trimmed &&
+            value.attachments.length === 0 &&
+            queuedPromptsRef.current.length > 0) {
+            const queued = queuedPromptsRef.current;
+            queuedPromptsRef.current = [];
+            for (const item of queued) {
+                skippedQueueIdsRef.current.add(item.id);
+            }
+            setQueuedPrompts([]);
+            if (steering.queue(queued.map((item) => item.prompt))) {
+                appendLine({
+                    id: nowId(),
+                    role: "system",
+                    title: "steering",
+                    content: `Steered the active turn with ${queued.length} queued prompt${queued.length === 1 ? "" : "s"}.`,
+                    done: true,
+                });
+            }
+            setInput("");
+            return;
+        }
         const command = parseChatCommand(value.text);
         if (command && value.attachments.length === 0) {
+            if (command.name === "init") {
+                if (pushPrompt(INIT_AGENTS_PROMPT)) {
+                    setInput("");
+                }
+                return;
+            }
             if (command.name === "model") {
                 void handleModelCommand(command.args);
                 setInput("");
@@ -747,15 +866,16 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
             }
         }
         if (pushPrompt(value)) {
-            setFollowRequest((value) => value + 1);
             setInput("");
         }
     }, [
+        appendLine,
         handleModelCommand,
         handleModeCommand,
         handleYoloCommand,
         pendingApproval,
         pushPrompt,
+        steering,
     ]);
     useInput((inputKey, key) => {
         if (isMouseInput(inputKey)) {
@@ -763,7 +883,7 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
         }
         if (key.ctrl && inputKey.toLowerCase() === "c") {
             if (runningRef.current) {
-                currentAgent.cancel();
+                agent.cancel();
                 setStatus("cancel requested");
                 return;
             }
@@ -781,7 +901,7 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
                 return;
             }
             if (runningRef.current) {
-                currentAgent.cancel();
+                agent.cancel();
                 setStatus("cancel requested");
                 return;
             }
@@ -802,7 +922,17 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
     const statusLabel = running && activeTodo
         ? activeTodo.activeForm.trim() || activeTodo.content
         : status;
-    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: rows, paddingX: 1, children: [_jsx(TranscriptViewport, { lines: lines, liveReasoning: liveReasoning, followRequest: followRequest }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [running && todoState.visible && todoState.todos.length > 0 ? (_jsx(TodoPanel, { todos: todoState.todos })) : null, _jsx(QueuedPrompts, { prompts: queuedPrompts }), pendingApproval ? (_jsx(ApprovalPrompt, { onDecision: (decision) => controllerRef.current.decide(decision) })) : null, !pendingApproval && picker === "model" ? (_jsx(SelectPicker, { title: "Choose model", items: config.llms.map((entry) => ({
+    const inputHint = running && queuedPrompts.length > 0 ? INPUT_HINT_WITH_STEERING : INPUT_HINT;
+    const firstLiveLineIndex = useMemo(() => {
+        let index = 0;
+        while (index < lines.length && lines[index]?.done) {
+            index += 1;
+        }
+        return index;
+    }, [lines]);
+    const staticLines = useMemo(() => lines.slice(0, firstLiveLineIndex), [firstLiveLineIndex, lines]);
+    const liveLines = useMemo(() => lines.slice(firstLiveLineIndex), [firstLiveLineIndex, lines]);
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", paddingX: 1, children: [staticLines.length > 0 ? (_jsx(Static, { items: staticLines, children: (line) => _jsx(TranscriptLine, { line: line }, line.id) })) : null, _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [lines.length === 0 || liveLines.length > 0 ? (_jsx(Transcript, { lines: liveLines, showEmptyBanner: lines.length === 0, marginTop: staticLines.length > 0 ? 0 : 1 })) : null, running && todoState.visible && todoState.todos.length > 0 ? (_jsx(TodoPanel, { todos: todoState.todos })) : null, _jsx(QueuedPrompts, { prompts: queuedPrompts }), pendingApproval ? (_jsx(ApprovalPrompt, { onDecision: (decision) => approvals.decide(decision) })) : null, !pendingApproval && picker === "model" ? (_jsx(SelectPicker, { title: "Choose model", items: config.llms.map((entry) => ({
                             label: `${entry.name} • ${entry.options.provider}/${entry.options.model}${entry.default ? " • current" : ""}`,
                             value: entry.name,
                         })), onSelect: (name) => {
@@ -810,34 +940,24 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
                             void handleModelCommand(name);
                         } })) : null, !pendingApproval && picker === "yolo" ? (_jsx(SelectPicker, { title: "Auto-approve tools (yolo)", items: [
                             {
-                                label: `Off • confirm each tool${!isYoloEnabled(currentAgent) ? " • current" : ""}`,
+                                label: `Off • confirm each tool${!isYoloEnabled(agent) ? " • current" : ""}`,
                                 value: "off",
                             },
                             {
-                                label: `On • run tools without prompts${isYoloEnabled(currentAgent) ? " • current" : ""}`,
+                                label: `On • run tools without prompts${isYoloEnabled(agent) ? " • current" : ""}`,
                                 value: "on",
                             },
                         ], onSelect: (v) => {
                             setPicker(null);
                             void handleYoloCommand(v);
                         } })) : null, !pendingApproval && picker === "mode" ? (_jsx(SelectPicker, { title: "Session mode", items: [
-                            {
-                                label: `Default • full tool surface${getModeState(currentAgent).mode === "default"
-                                    ? " • current"
-                                    : ""}`,
-                                value: "default",
-                            },
-                            {
-                                label: `Plan • read only tools + plan file${getModeState(currentAgent).mode === "plan" ? " • current" : ""}`,
-                                value: "plan",
-                            },
-                            {
-                                label: `Ask • read only tools, no plan workflow${getModeState(currentAgent).mode === "ask" ? " • current" : ""}`,
-                                value: "ask",
-                            },
+                            ...MODE_DEFINITIONS.map((entry) => ({
+                                label: `${entry.name} • ${entry.description}${getModeState(agent).mode === entry.id ? " • current" : ""}`,
+                                value: entry.id,
+                            })),
                         ], onSelect: (v) => {
                             setPicker(null);
                             void handleModeCommand(v);
-                        } })) : null, !pendingApproval && !picker ? (_jsx(SlashCommands, { items: slashCommands, highlightIndex: slashHighlightIndex })) : null, !pendingApproval && !picker ? (_jsx(Composer, { input: input, running: running, disabled: Boolean(pendingApproval), hint: INPUT_HINT, onChange: setInput, onSubmit: onSubmit, slashMenu: slashMenu })) : null, _jsx(StatusBar, { running: running, status: status, statusLabel: statusLabel, sessionId: sessionId, currentModel: currentModelLabel(config), yoloOn: isYoloEnabled(currentAgent), sessionMode: getModeState(currentAgent).mode, elapsedLabel: elapsedLabel, turnCount: turnCount, totalTools: totalTools, skillsFound: skillsFound, manager: currentManager, usage: usage })] })] }));
+                        } })) : null, !pendingApproval && !picker ? (_jsx(SlashCommands, { items: slashCommands, highlightIndex: slashHighlightIndex })) : null, !pendingApproval && !picker ? (_jsx(Composer, { input: input, running: running, disabled: Boolean(pendingApproval), hint: inputHint, onChange: setInput, onSubmit: onSubmit, slashMenu: slashMenu })) : null, _jsx(StatusBar, { running: running, status: status, statusLabel: statusLabel, sessionId: sessionId, currentModel: currentModelLabel(config), yoloOn: isYoloEnabled(agent), sessionMode: sessionModeLabel(getModeState(agent).mode), elapsedLabel: elapsedLabel, turnCount: turnCount, totalTools: totalTools, skillsFound: skillsFound, manager: manager, usage: usage })] })] }));
 }
 //# sourceMappingURL=app.js.map