hoomanjs 1.29.2 → 1.31.0

package/dist/chat/app.js

@@ -2,27 +2,22 @@ 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 { Message, TextBlock, ToolResultBlock, ToolUseBlock, } 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 { formatModeNames, 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";
-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 { BottomChrome } from "./components/BottomChrome.js";
+import { Transcript } 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 };
 }
@@ -37,7 +32,9 @@ function normalizePromptSubmission(value) {
         ],
     };
 }
-const INPUT_HINT = "shift/meta+enter or \\+enter: newline | esc/ctrl+c: cancel or exit";
+const INPUT_HINT = "pgup/pgdn: scroll | 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 | pgup/pgdn: scroll | 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)}`;
 }
@@ -49,6 +46,17 @@ function stringifyUnknown(value) {
         return String(value);
     }
 }
+function blockToFallbackText(block) {
+    if (block.type === "textBlock") {
+        return block.text;
+    }
+    try {
+        return JSON.stringify(block.toJSON?.() ?? block, null, 2);
+    }
+    catch {
+        return String(block);
+    }
+}
 function toToolResultText(result) {
     const data = result;
     const pieces = (data.content ?? []).map((item) => {
@@ -76,6 +84,83 @@ function getToolUseId(value) {
     }
     return null;
 }
+function estimateReasoningTokens(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return 0;
+    }
+    return Math.max(1, Math.round(trimmed.length / 4));
+}
+function buildInitialTranscript(messages) {
+    const lines = [];
+    const toolResults = new Map();
+    for (const message of messages) {
+        for (const block of message.content) {
+            if (block instanceof ToolResultBlock) {
+                toolResults.set(block.toolUseId, block);
+            }
+        }
+    }
+    for (const message of messages) {
+        if (message.role === "user") {
+            const parts = message.content
+                .filter((block) => !(block instanceof ToolResultBlock))
+                .map((block) => blockToFallbackText(block)?.trimEnd() ?? "")
+                .filter(Boolean);
+            if (parts.length > 0) {
+                lines.push({
+                    id: nowId(),
+                    role: "user",
+                    content: parts.join("\n\n"),
+                    done: true,
+                });
+            }
+            continue;
+        }
+        if (message.role !== "assistant") {
+            continue;
+        }
+        for (const block of message.content) {
+            if (block instanceof ToolUseBlock) {
+                const result = toolResults.get(block.toolUseId);
+                lines.push({
+                    id: nowId(),
+                    role: "tool",
+                    title: "tool",
+                    toolName: block.name,
+                    content: stringifyUnknown(block.input ?? {}),
+                    resultContent: result ? toToolResultText(result) : undefined,
+                    phase: result ? "done" : "running",
+                    done: Boolean(result),
+                });
+                continue;
+            }
+            if (block.type === "reasoningBlock") {
+                const text = blockToFallbackText(block)?.trim();
+                if (text) {
+                    lines.push({
+                        id: nowId(),
+                        role: "thought",
+                        content: text,
+                        done: true,
+                        estimatedTokens: estimateReasoningTokens(text),
+                    });
+                }
+                continue;
+            }
+            const text = blockToFallbackText(block)?.trimEnd();
+            if (text) {
+                lines.push({
+                    id: nowId(),
+                    role: "assistant",
+                    content: text,
+                    done: true,
+                });
+            }
+        }
+    }
+    return lines;
+}
 function currentModelName(config) {
     return (config.llms.find((m) => m.default)?.name ??
         config.llms[0]?.name ??
@@ -129,7 +214,7 @@ 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;
@@ -138,7 +223,11 @@ 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 +237,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,15 +268,42 @@ function matchingSlashCommands(input) {
     }
     return SLASH_COMMANDS.filter((item) => item.name.startsWith(query));
 }
-export function ChatApp({ agent, config, sessionId, manager, registry, prompt, onExit, }) {
+function estimateChromeRows(params) {
+    let rows = 8;
+    if (params.running && params.todoCount > 0) {
+        rows += 2 + params.todoCount;
+    }
+    if (params.queueCount > 0) {
+        rows += 2 + params.queueCount;
+    }
+    if (params.pendingApproval) {
+        rows += 4;
+        return rows;
+    }
+    if (params.picker === "model") {
+        rows += 2 + 4;
+        return rows;
+    }
+    if (params.picker === "yolo") {
+        rows += 2 + 2;
+        return rows;
+    }
+    if (params.picker === "mode") {
+        rows += 2 + 3;
+        return rows;
+    }
+    if (params.slashCommandCount > 0) {
+        rows += params.slashCommandCount + 1;
+    }
+    return rows;
+}
+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 windowSize = useWindowSize();
     const [input, setInput] = useState("");
     const [running, setRunning] = useState(false);
     const [status, setStatus] = useState("ready");
-    const [lines, setLines] = useState([]);
+    const [lines, setLines] = useState(() => buildInitialTranscript(agent.messages));
     const [turnCount, setTurnCount] = useState(0);
     const [skillsFound, setSkillsFound] = useState(0);
     const [turnStartedAt, setTurnStartedAt] = useState(null);
@@ -198,16 +318,24 @@ 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 [transcriptScrollOffset, setTranscriptScrollOffset] = 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 +368,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 +389,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 +442,91 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
             return next;
         });
     }, []);
-    const appendAssistantText = useCallback((text) => {
+    const replaceAssistantText = useCallback((text) => {
         const id = assistantLineIdRef.current;
         if (!id) {
             return;
         }
-        setLines((prev) => prev.map((line) => line.id === id ? { ...line, content: `${line.content}${text}` } : line));
+        setLines((prev) => prev.map((line) => (line.id === id ? { ...line, content: text } : line)));
     }, []);
-    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 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;
+        }
+        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 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;
+    }, [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 +564,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 +582,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 +610,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 +639,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 +662,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 +673,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 +685,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);
+            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 ?? "");
                             }
-                            else {
-                                pendingToolLineIdsRef.current.push(toolId);
-                            }
-                            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 +832,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 +845,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 +870,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));
             }
@@ -702,6 +895,7 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
             id: nowId(),
             prompt: { ...normalized, text: trimmed },
         };
+        setTranscriptScrollOffset(0);
         setQueuedPrompts((prev) => [...prev, item]);
         void queueRef.current?.push(item).catch((error) => {
             if (!mountedRef.current) {
@@ -728,8 +922,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,23 +970,42 @@ 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)) {
             return;
         }
+        if (!key.ctrl && !key.meta && !key.super) {
+            if (key.pageUp) {
+                setTranscriptScrollOffset((offset) => Math.min(Math.max(0, lines.length - 1), offset + transcriptScrollStep));
+                return;
+            }
+            if (key.pageDown) {
+                setTranscriptScrollOffset((offset) => Math.max(0, offset - transcriptScrollStep));
+                return;
+            }
+            if (key.home) {
+                setTranscriptScrollOffset(Math.max(0, lines.length - 1));
+                return;
+            }
+            if (key.end) {
+                setTranscriptScrollOffset(0);
+                return;
+            }
+        }
         if (key.ctrl && inputKey.toLowerCase() === "c") {
             if (runningRef.current) {
-                currentAgent.cancel();
+                agent.cancel();
                 setStatus("cancel requested");
                 return;
             }
@@ -781,7 +1023,7 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
                 return;
             }
             if (runningRef.current) {
-                currentAgent.cancel();
+                agent.cancel();
                 setStatus("cancel requested");
                 return;
             }
@@ -798,46 +1040,39 @@ export function ChatApp({ agent, config, sessionId, manager, registry, prompt, o
         const sec = seconds % 60;
         return `${String(min).padStart(2, "0")}:${String(sec).padStart(2, "0")}`;
     }, [turnElapsedMs]);
-    const activeTodo = useMemo(() => todoState.todos.find((todo) => todo.status === "in_progress"), [todoState.todos]);
-    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) => ({
-                            label: `${entry.name} • ${entry.options.provider}/${entry.options.model}${entry.default ? " • current" : ""}`,
-                            value: entry.name,
-                        })), onSelect: (name) => {
-                            setPicker(null);
-                            void handleModelCommand(name);
-                        } })) : null, !pendingApproval && picker === "yolo" ? (_jsx(SelectPicker, { title: "Auto-approve tools (yolo)", items: [
-                            {
-                                label: `Off • confirm each tool${!isYoloEnabled(currentAgent) ? " • current" : ""}`,
-                                value: "off",
-                            },
-                            {
-                                label: `On • run tools without prompts${isYoloEnabled(currentAgent) ? " • 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",
-                            },
-                        ], 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 })] })] }));
+    const inputHint = running && queuedPrompts.length > 0 ? INPUT_HINT_WITH_STEERING : INPUT_HINT;
+    const transcriptRows = useMemo(() => Math.max(6, windowSize.rows -
+        estimateChromeRows({
+            running,
+            todoCount: todoState.visible ? todoState.todos.length : 0,
+            queueCount: queuedPrompts.length,
+            pendingApproval: Boolean(pendingApproval),
+            picker,
+            slashCommandCount: !pendingApproval && !picker ? slashCommands.length : 0,
+        }) -
+        2), [
+        pendingApproval,
+        picker,
+        queuedPrompts.length,
+        running,
+        slashCommands.length,
+        todoState.todos.length,
+        todoState.visible,
+        windowSize.rows,
+    ]);
+    const transcriptScrollStep = useMemo(() => Math.max(1, Math.floor(transcriptRows / 3)), [transcriptRows]);
+    useEffect(() => {
+        setTranscriptScrollOffset((offset) => Math.min(offset, lines.length - 1));
+    }, [lines.length]);
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", paddingX: 1, height: Math.max(1, windowSize.rows - 1), children: [_jsx(Transcript, { lines: lines, assistantName: config.name, showEmptyBanner: lines.length === 0, marginTop: 1, maxRows: transcriptRows, scrollOffset: transcriptScrollOffset }), _jsx(BottomChrome, { config: config, running: running, status: status, sessionId: sessionId, currentModel: currentModelLabel(config), yoloOn: isYoloEnabled(agent), sessionMode: getModeState(agent).mode, elapsedLabel: elapsedLabel, turnCount: turnCount, totalTools: totalTools, skillsFound: skillsFound, manager: manager, usage: usage, todoState: todoState, queuedPrompts: queuedPrompts, pendingApproval: Boolean(pendingApproval), picker: picker, slashCommands: slashCommands, slashHighlightIndex: slashHighlightIndex, input: input, inputHint: inputHint, slashMenu: slashMenu, onApprovalDecision: (decision) => approvals.decide(decision), onModelSelect: (name) => {
+                    setPicker(null);
+                    void handleModelCommand(name);
+                }, onYoloSelect: (value) => {
+                    setPicker(null);
+                    void handleYoloCommand(value);
+                }, onModeSelect: (value) => {
+                    setPicker(null);
+                    void handleModeCommand(value);
+                }, onInputChange: setInput, onSubmit: onSubmit })] }));
 }
 //# sourceMappingURL=app.js.map