s-app-scoder-agent 0.4.0 → 0.6.0

package/dist/tui/app.js

@@ -0,0 +1,315 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Full-screen Ink TUI for scoder — "mission control for the build loop".
+ *
+ * Identity (deliberately distinct from chat-first agent UIs): the build is
+ * the mission, so the screen is organized around it —
+ *   · Build Rail (top): brand, build-status lamp, step fuel gauge ▰▰▰▱▱▱
+ *   · Flight-recorder log: each tool entry is stamped `07 ▸ name(args)`
+ *   · `✎` diff cards rendered inline for every file edit
+ * Driven entirely by AgentEvents (the same stream the HTTP/SSE server uses).
+ */
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import { Agent } from "../agent.js";
+import { setQuiet } from "../ui.js";
+import { applyEvent, initialState, markAborted } from "./state.js";
+import { formatSlashHelp, parseSlashCommand } from "./commands.js";
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/** Fuel gauge is scaled to this many cells regardless of maxSteps. */
+const GAUGE_CELLS = 10;
+function useSpinner(active) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        if (!active)
+            return;
+        const timer = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), 80);
+        return () => clearInterval(timer);
+    }, [active]);
+    return SPINNER_FRAMES[frame];
+}
+function formatArgs(args) {
+    return Object.entries(args)
+        .map(([k, v]) => {
+        const s = typeof v === "string" ? v : JSON.stringify(v) ?? "";
+        return `${k}=${s.length > 60 ? s.slice(0, 60) + "…" : s.replace(/\n/g, " ")}`;
+    })
+        .join(" ");
+}
+/** Scaled step fuel gauge: ▰ filled / ▱ remaining, e.g. ▰▰▰▰▱▱▱▱ 4/40. */
+function fuelGauge(step, maxSteps) {
+    if (maxSteps <= 0)
+        return null;
+    const filled = Math.min(GAUGE_CELLS, Math.round((Math.min(step, maxSteps) / maxSteps) * GAUGE_CELLS));
+    return "▰".repeat(filled) + "▱".repeat(GAUGE_CELLS - filled);
+}
+const OUTPUT_PREVIEW_LINES = 4;
+function ToolItemView({ item, spinner }) {
+    const running = item.ok === null;
+    const icon = running ? _jsx(Text, { color: "cyan", children: spinner }) : item.ok ? _jsx(Text, { color: "green", children: "\u2714" }) : _jsx(Text, { color: "red", children: "\u2718" });
+    const lines = item.output.length > 0 ? item.output.replace(/\n+$/, "").split("\n") : [];
+    const preview = lines.slice(-OUTPUT_PREVIEW_LINES);
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [String(item.step).padStart(2, "0"), "\u25B8"] }), " ", icon, " ", _jsx(Text, { color: "cyan", children: item.name }), _jsxs(Text, { dimColor: true, children: ["(", formatArgs(item.args), ")"] }), running && _jsx(Text, { dimColor: true, children: " \u00B7 running\u2026" })] }), preview.map((line, i) => (_jsx(Text, { dimColor: i < preview.length - 1, children: line.length > 160 ? line.slice(0, 160) + "…" : line }, i)))] }));
+}
+/** One colored line of a unified diff (+ green, - red, @@ cyan, header bold). */
+function DiffLine({ line }) {
+    if (line.startsWith("+++") || line.startsWith("---"))
+        return _jsx(Text, { bold: true, children: line });
+    if (line.startsWith("@@"))
+        return _jsx(Text, { color: "cyan", children: line });
+    if (line.startsWith("+"))
+        return _jsx(Text, { color: "green", children: line });
+    if (line.startsWith("-"))
+        return _jsx(Text, { color: "red", children: line });
+    return _jsx(Text, { children: line });
+}
+const MAX_DIFF_RENDER_LINES = 24;
+function DiffItemView({ item }) {
+    const lines = item.text.length > 0 ? item.text.split("\n") : [];
+    const shown = lines.slice(0, MAX_DIFF_RENDER_LINES);
+    const hidden = lines.length - shown.length;
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [String(item.step).padStart(2, "0"), "\u25B8"] }), " ", _jsx(Text, { color: "magenta", bold: true, children: "\u270E" }), " ", _jsxs(Text, { color: "green", children: ["+", item.added] }), " ", _jsxs(Text, { color: "red", children: ["-", item.removed] }), " ", _jsx(Text, { bold: true, children: item.path }), item.truncated && _jsx(Text, { color: "yellow", children: " (diff truncated)" })] }), shown.map((line, i) => (_jsx(DiffLine, { line: line.length > 160 ? line.slice(0, 160) + "…" : line }, i))), hidden > 0 && _jsxs(Text, { dimColor: true, children: ["\u2026 +", hidden, " more diff lines"] })] }));
+}
+function ChatItemView({ item, spinner }) {
+    switch (item.kind) {
+        case "user":
+            return (_jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: "blue", bold: true, children: ["\u276F", " "] }), _jsx(Text, { bold: true, children: item.text })] }));
+        case "assistant":
+            return (_jsx(Box, { marginTop: item.text ? 1 : 0, paddingLeft: 1, children: _jsx(Text, { dimColor: item.streaming, children: item.text || (item.streaming ? "" : "(no text)") }) }));
+        case "tool":
+            return _jsx(ToolItemView, { item: item, spinner: spinner });
+        case "diff":
+            return _jsx(DiffItemView, { item: item });
+        case "build":
+            return (_jsxs(Box, { paddingLeft: 1, children: [item.success ? _jsx(Text, { color: "green", bold: true, children: "\u2714 build passed" }) : _jsx(Text, { color: "red", bold: true, children: "\u2718 build failed" }), _jsxs(Text, { dimColor: true, children: [" \u2014 ", item.command] })] }));
+        case "notice":
+            return (_jsx(Box, { paddingLeft: 1, children: _jsxs(Text, { color: item.level === "error" ? "red" : item.level === "warn" ? "yellow" : "gray", children: [item.level === "error" ? "✘ " : "⚠ ", item.text.length > 500 ? item.text.slice(0, 500) + "…" : item.text] }) }));
+    }
+}
+/** Build Rail — scoder's signature top bar: lamp + build command + fuel gauge. */
+function BuildRail({ state, config }) {
+    const lampColor = state.buildLamp === "ok" ? "green" : state.buildLamp === "fail" ? "red" : "gray";
+    const lampLabel = state.buildLamp === "ok" ? "build ok" : state.buildLamp === "fail" ? "build fail" : "no build yet";
+    const gauge = fuelGauge(state.step, state.maxSteps);
+    return (_jsxs(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, justifyContent: "space-between", children: [_jsx(Text, { bold: true, color: "magenta", children: "scoder" }), _jsxs(Text, { children: [_jsxs(Text, { color: lampColor, children: ["\u25CF ", lampLabel] }), _jsxs(Text, { dimColor: true, children: [" ", state.buildCmd || config.buildCmd || "auto"] })] }), _jsxs(Text, { children: [gauge && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "magenta", children: gauge }), _jsxs(Text, { dimColor: true, children: [" ", state.step, "/", state.maxSteps] })] })), !gauge && _jsx(Text, { dimColor: true, children: "\u2014 idle" })] })] }));
+}
+function StatusBar({ state, spinner }) {
+    const statusColor = state.status === "running" ? "cyan" : state.status === "success" ? "green" : state.status === "failed" ? "red" : "gray";
+    const statusLabel = state.status === "running" ? `running ${state.step}/${state.maxSteps}` : state.status === "idle" ? "idle" : state.status;
+    return (_jsxs(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, justifyContent: "space-between", children: [_jsxs(Text, { children: [_jsx(Text, { color: statusColor, children: state.status === "running" ? `${spinner} ${statusLabel}` : statusLabel }), _jsxs(Text, { dimColor: true, children: [" \u00B7 ", state.model || "—"] }), state.usage.calls > 0 && (_jsxs(Text, { dimColor: true, children: [" ", "\u00B7 tok ", state.usage.inputTokens, "/", state.usage.outputTokens, state.usage.cachedTokens > 0 ? ` (+${state.usage.cachedTokens} cached)` : ""] }))] }), _jsx(Text, { dimColor: true, children: "\u23CE send \u00B7 pgup/pgdn scroll \u00B7 esc abort \u00B7 ctrl+c quit" })] }));
+}
+function Input({ valueRef, value, onChange, onSubmit }) {
+    useInput((input, key) => {
+        const current = valueRef.current;
+        if (key.return) {
+            onSubmit(current);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            const next = current.slice(0, -1);
+            valueRef.current = next;
+            onChange(next);
+            return;
+        }
+        if (input.length > 0 && !key.ctrl && !key.meta && !key.escape && !key.upArrow && !key.downArrow && !key.tab) {
+            // A chunk may contain several pasted chars — even a trailing newline
+            // (terminal pastes / PTY writes deliver "exit\r" as one chunk).
+            const parts = input.split(/[\r\n]+/);
+            const next = current + parts[0];
+            valueRef.current = next;
+            onChange(next);
+            if (parts.length > 1)
+                onSubmit(next); // newline in the chunk = submit
+        }
+    });
+    return (_jsxs(Box, { children: [_jsx(Text, { color: "magenta", bold: true, children: "❯ " }), _jsx(Text, { children: value }), _jsx(Text, { dimColor: true, children: "\u258C" })] }));
+}
+export function TuiApp({ config, initialTask, bootNotice }) {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [state, setState] = useState(initialState);
+    const [input, setInput] = useState(initialTask ?? "");
+    const [scrollOffset, setScrollOffset] = useState(0); // 0 = pinned to bottom
+    const inputRef = useRef(initialTask ?? "");
+    const writeInput = useCallback((v) => {
+        inputRef.current = v;
+        setInput(v);
+    }, []);
+    const runningRef = useRef(false);
+    const agentRef = useRef(null);
+    const spinner = useSpinner(state.status === "running");
+    // Boot notice (e.g. "permission=ask is not supported in the TUI") as a chat
+    // item, so it scrolls with the conversation instead of being lost off-screen.
+    const bootedRef = useRef(false);
+    useEffect(() => {
+        if (bootedRef.current)
+            return;
+        bootedRef.current = true;
+        if (bootNotice)
+            setState((s) => ({ ...s, items: [{ kind: "notice", text: bootNotice, level: "warn" }, ...s.items] }));
+    }, [bootNotice]);
+    const pushNotice = useCallback((text, level = "info") => setState((s) => ({ ...s, items: [...s.items, { kind: "notice", text, level }] })), []);
+    const submit = useCallback(async (text) => {
+        const task = text.trim();
+        if (!task)
+            return;
+        // "exit"/"quit" always works — aborts a running agent first.
+        if (task === "exit" || task === "quit") {
+            agentRef.current?.abort();
+            exit();
+            return;
+        }
+        // Slash commands — handled by the UI itself, never sent to the LLM.
+        const slash = parseSlashCommand(task);
+        if (slash) {
+            writeInput("");
+            if (slash.cmd === "/exit" || slash.cmd === "/quit") {
+                agentRef.current?.abort();
+                exit();
+                return;
+            }
+            if (slash.cmd === "/help") {
+                pushNotice(formatSlashHelp("scoder tui"));
+                return;
+            }
+            if (slash.cmd === "/clear") {
+                agentRef.current?.abort();
+                agentRef.current = null;
+                runningRef.current = false;
+                writeInput("");
+                setScrollOffset(0);
+                setState(initialState());
+                return;
+            }
+            if (slash.cmd === "/cost") {
+                const u = stateRef.current.usage;
+                pushNotice(u.calls > 0
+                    ? `session usage: ${u.calls} LLM calls · tokens in ${u.inputTokens} / out ${u.outputTokens}` +
+                        (u.cachedTokens > 0 ? ` (+${u.cachedTokens} cached)` : "")
+                    : "no LLM calls yet in this session");
+                return;
+            }
+            if (slash.cmd === "/model") {
+                const s = stateRef.current;
+                pushNotice(`model: ${s.model || config.model || "—"} · provider: ${s.provider || config.provider || "auto"}`);
+                return;
+            }
+            pushNotice(`unknown command ${slash.cmd} — try /help`, "warn");
+            return;
+        }
+        if (runningRef.current)
+            return; // keep the typed text for when the agent is idle
+        writeInput("");
+        runningRef.current = true;
+        setScrollOffset(0);
+        // isFirst must be computed BEFORE pushing the user item below.
+        const isFirst = stateRef.current.items.every((i) => i.kind !== "user");
+        // runTurn() doesn't emit run_start, so the TUI shows the user's message
+        // itself; applyEvent's run_start dedupe keeps turn 1 from doubling.
+        setState((s) => ({ ...s, items: [...s.items, { kind: "user", text: task }], status: "running", summary: null }));
+        let agent = agentRef.current;
+        if (!agent) {
+            agent = new Agent(config);
+            // Functional updates: React feeds each updater the latest queued
+            // state, so events can never land on a stale snapshot (a ref mirror
+            // updated in useEffect races events arriving within one render batch
+            // — tool results then miss their items and stay "running…" forever).
+            agent.onEvent = (ev) => setState((prev) => {
+                const next = applyEvent(prev, ev);
+                return { ...next, items: [...next.items] };
+            });
+            agentRef.current = agent;
+        }
+        try {
+            // First submission runs the full closed loop; later ones continue the session.
+            const result = isFirst ? await agent.run(task) : await agent.runTurn(task);
+            void result;
+            runningRef.current = false;
+        }
+        catch (err) {
+            runningRef.current = false;
+            setState((s) => applyEvent({ ...s, items: [...s.items] }, { type: "error", message: err.message }));
+        }
+    }, [config, pushNotice, writeInput, exit]);
+    // Mirror of state for the submit path (isFirst, /cost, /model) and the
+    // abort handler — approximate between renders, exact whenever idle.
+    const stateRef = useRef(state);
+    useEffect(() => {
+        stateRef.current = state;
+    }, [state]);
+    // Esc aborts the running task (like SIGINT in the CLI); when scrolled up,
+    // the first Esc returns to the bottom instead.
+    const scrollOffsetRef = useRef(0);
+    useEffect(() => {
+        scrollOffsetRef.current = scrollOffset;
+    }, [scrollOffset]);
+    useInput((_input, key) => {
+        if (key.pageUp)
+            setScrollOffset((o) => Math.min(stateRef.current.items.length, o + 10));
+        if (key.pageDown)
+            setScrollOffset((o) => Math.max(0, o - 10));
+        if (key.escape) {
+            if (scrollOffsetRef.current > 0) {
+                setScrollOffset(0);
+                return;
+            }
+            if (runningRef.current) {
+                setState((s) => ({ ...markAborted(s), items: [...s.items] }));
+                agentRef.current?.abort();
+            }
+        }
+    });
+    // Ctrl+C quits (press again within 2s to confirm while running).
+    const ctrlCArmed = useRef(null);
+    useInput((_input, key) => {
+        if (!key.ctrl || _input !== "c")
+            return;
+        if (runningRef.current && ctrlCArmed.current === null) {
+            ctrlCArmed.current = Date.now();
+            setState((s) => ({ ...s, items: [...s.items, { kind: "notice", text: "Press Ctrl+C again to quit", level: "warn" }] }));
+            setTimeout(() => (ctrlCArmed.current = null), 2000);
+            return;
+        }
+        agentRef.current?.abort();
+        exit();
+    });
+    // Submit an initial task passed on the command line once, after mount.
+    const bootRef = useRef(false);
+    useEffect(() => {
+        if (initialTask && !bootRef.current && input === initialTask) {
+            bootRef.current = true;
+            void submit(initialTask);
+        }
+    }, [initialTask, input, submit]);
+    const lastSummary = useMemo(() => {
+        if (state.status === "running" || state.status === "idle")
+            return null;
+        return state.summary;
+    }, [state.status, state.summary]);
+    // Scrollback viewport: by default pin to the newest items that fit on
+    // screen; PgUp/PgDn moves the window over the flight-recorder log.
+    const rows = stdout.rows ?? 24;
+    const viewItems = Math.max(6, rows - 9);
+    const total = state.items.length;
+    const start = Math.max(0, Math.min(total - viewItems, total - viewItems - scrollOffset));
+    const end = Math.max(start, Math.min(total, total - scrollOffset));
+    const visible = state.items.slice(start, end);
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [_jsx(BuildRail, { state: state, config: config }), _jsxs(Box, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [total === 0 && (_jsx(Text, { dimColor: true, children: "Type a task and press Enter. The agent works autonomously until the build passes. (/help for commands)" })), scrollOffset > 0 && _jsx(Text, { dimColor: true, children: "\u2191 scrollback \u2014 PgDn to return to the newest" }), visible.map((item, i) => (_jsx(ChatItemView, { item: item, spinner: spinner }, start + i))), state.status === "running" && state.step > 0 && (_jsxs(Text, { dimColor: true, children: [spinner, " step ", state.step, "/", state.maxSteps, " \u2014 thinking\u2026"] })), lastSummary && (_jsx(Box, { marginTop: 1, children: state.status === "success" ? (_jsxs(Text, { color: "green", bold: true, children: ["\u2714 ", lastSummary] })) : state.status === "aborted" ? (_jsxs(Text, { color: "yellow", bold: true, children: ["\u23F9 ", lastSummary] })) : (_jsxs(Text, { color: "red", bold: true, children: ["\u2718 ", lastSummary] })) }))] }), _jsx(Box, { paddingX: 1, children: _jsx(Input, { valueRef: inputRef, value: input, onChange: writeInput, onSubmit: (v) => void submit(v) }) }), _jsx(StatusBar, { state: state, spinner: spinner })] }));
+}
+/** Mount the TUI (called from the `scoder tui` subcommand). */
+export async function runTui(config, initialTask) {
+    setQuiet(true);
+    // `ask` prompts via readline on stdin, which corrupts the alt-screen TUI
+    // (same rule as `scoder serve`): fall back to auto with an in-pane notice.
+    let bootNotice = null;
+    if (config.permissionMode === "ask") {
+        config = { ...config, permissionMode: "auto" };
+        bootNotice = "permission=ask is not supported in the TUI — falling back to auto";
+    }
+    const { render } = await import("ink");
+    const { waitUntilExit } = render(_jsx(TuiApp, { config: config, initialTask: initialTask, bootNotice: bootNotice }));
+    await waitUntilExit();
+    // Ink restores the terminal on unmount; exit explicitly so provider
+    // keep-alive sockets (undici pool) can't keep the event loop alive.
+    process.exit(0);
+}

package/dist/tui/commands.js

@@ -0,0 +1,24 @@
+/**
+ * Slash commands shared by the classic REPL (src/index.ts) and the Ink TUI
+ * (src/tui/app.tsx). Pure parsing/formatting only — each frontend executes
+ * the command against its own context, so both stay in sync on the surface.
+ */
+export const SLASH_COMMANDS = [
+    { cmd: "/help", desc: "show this command list" },
+    { cmd: "/clear", desc: "clear the conversation and reset agent context" },
+    { cmd: "/cost", desc: "token usage of the current session" },
+    { cmd: "/model", desc: "show the active model & provider" },
+    { cmd: "/exit", desc: "quit (aliases: /quit, exit, quit)" },
+];
+/** Parse "/cmd arg…"; returns null when the input is not a slash command. */
+export function parseSlashCommand(input) {
+    const m = /^\/([a-zA-Z][a-zA-Z0-9]*)(?:\s+(.*\S))?\s*$/.exec(input.trim());
+    if (!m)
+        return null;
+    return { cmd: "/" + m[1].toLowerCase(), arg: m[2] ?? "" };
+}
+/** Format the /help listing (shared so both frontends render identically). */
+export function formatSlashHelp(commandName) {
+    const rows = SLASH_COMMANDS.map((c) => `  ${c.cmd.padEnd(8)} ${c.desc}`).join("\n");
+    return `Commands (${commandName}):\n${rows}\n  Anything else is sent to the agent as a task.`;
+}

package/dist/tui/state.js

@@ -0,0 +1,166 @@
+export function initialState() {
+    return {
+        items: [],
+        status: "idle",
+        step: 0,
+        maxSteps: 0,
+        model: "",
+        provider: "",
+        workdir: "",
+        buildCmd: "",
+        buildLamp: "none",
+        usage: { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 0 },
+        summary: null,
+    };
+}
+const MAX_ITEMS = 400;
+const MAX_OUTPUT_CHARS = 20_000;
+const MAX_TEXT_CHARS = 40_000;
+function appendItem(state, item) {
+    state.items.push(item);
+    if (state.items.length > MAX_ITEMS)
+        state.items.splice(0, state.items.length - MAX_ITEMS);
+}
+function lastItem(state) {
+    return state.items[state.items.length - 1];
+}
+/** Cap long strings, keeping the tail (errors usually live at the end). */
+function capTail(text, max = MAX_OUTPUT_CHARS) {
+    if (text.length <= max)
+        return text;
+    return `…[truncated ${text.length - max} chars]\n${text.slice(text.length - max)}`;
+}
+/**
+ * Fold one AgentEvent into the state (mutates `state`, returns it for
+ * reducer-style chaining). Unknown events are ignored.
+ */
+export function applyEvent(state, ev) {
+    switch (ev.type) {
+        case "run_start": {
+            state.model = ev.model;
+            state.provider = ev.provider;
+            state.workdir = ev.workdir;
+            state.buildCmd = ev.buildCmd;
+            state.buildLamp = "none";
+            state.status = "running";
+            state.step = 0;
+            state.summary = null;
+            state.usage = { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 0 };
+            // The TUI pushes the user's message itself when submitting; avoid a
+            // duplicate when run_start carries the same task.
+            const last = lastItem(state);
+            if (!(last && last.kind === "user" && last.text === ev.task)) {
+                appendItem(state, { kind: "user", text: ev.task });
+            }
+            break;
+        }
+        case "step": {
+            state.step = ev.step;
+            state.maxSteps = ev.maxSteps;
+            // A new step starts: close any still-"streaming" assistant message.
+            const last = lastItem(state);
+            if (last && last.kind === "assistant" && last.streaming)
+                last.streaming = false;
+            break;
+        }
+        case "llm_delta": {
+            const last = lastItem(state);
+            if (last && last.kind === "assistant" && last.streaming) {
+                last.text += ev.delta;
+                if (last.text.length > MAX_TEXT_CHARS)
+                    last.text = last.text.slice(-MAX_TEXT_CHARS);
+            }
+            else {
+                if (last && last.kind === "assistant" && last.streaming === false && last.text === "") {
+                    // reuse an empty assistant placeholder from a previous step
+                    last.streaming = true;
+                }
+                else {
+                    appendItem(state, { kind: "assistant", text: ev.delta, streaming: true });
+                }
+            }
+            break;
+        }
+        case "llm_usage": {
+            state.usage.calls += 1;
+            state.usage.inputTokens += ev.usage.input_tokens ?? 0;
+            state.usage.outputTokens += ev.usage.output_tokens ?? 0;
+            state.usage.cachedTokens += ev.usage.cached_tokens ?? 0;
+            break;
+        }
+        case "tool_call": {
+            appendItem(state, { kind: "tool", name: ev.name, args: ev.args, ok: null, output: "", step: ev.step });
+            break;
+        }
+        case "tool_output": {
+            // Live stdout/stderr chunks attach to the most recent running tool item.
+            for (let i = state.items.length - 1; i >= 0; i--) {
+                const it = state.items[i];
+                if (it.kind === "tool" && it.ok === null && it.name === ev.name) {
+                    it.output += ev.delta;
+                    if (it.output.length > MAX_OUTPUT_CHARS)
+                        it.output = capTail(it.output);
+                    break;
+                }
+                // Stop searching at the previous tool boundary to avoid cross-attachment.
+                if (it.kind === "tool")
+                    break;
+            }
+            break;
+        }
+        case "tool_result": {
+            for (let i = state.items.length - 1; i >= 0; i--) {
+                const it = state.items[i];
+                if (it.kind === "tool" && it.name === ev.name && it.ok === null) {
+                    it.ok = ev.ok;
+                    // Prefer the final (complete) result over accumulated live chunks.
+                    if (ev.output.length >= it.output.length)
+                        it.output = ev.output;
+                    break;
+                }
+            }
+            // File-writing tools attach a unified diff — render it as its own item
+            // so edits are reviewable at a glance (the scoder "✎" signature).
+            if (ev.diff) {
+                appendItem(state, {
+                    kind: "diff",
+                    path: ev.diff.path,
+                    text: ev.diff.text,
+                    added: ev.diff.added,
+                    removed: ev.diff.removed,
+                    truncated: ev.diff.truncated,
+                    step: ev.step,
+                });
+            }
+            break;
+        }
+        case "build": {
+            state.buildLamp = ev.success ? "ok" : "fail";
+            appendItem(state, { kind: "build", success: ev.success, command: ev.command });
+            break;
+        }
+        case "finish": {
+            state.status = ev.success ? "success" : /interrupted|aborted/i.test(ev.summary) ? "aborted" : "failed";
+            state.summary = ev.summary;
+            // Close any dangling streaming assistant message.
+            const last = lastItem(state);
+            if (last && last.kind === "assistant")
+                last.streaming = false;
+            break;
+        }
+        case "error": {
+            appendItem(state, { kind: "notice", text: ev.message, level: "error" });
+            break;
+        }
+    }
+    return state;
+}
+/** Mark the current run aborted from the UI side (before the finish event). */
+export function markAborted(state) {
+    state.status = "aborted";
+    state.summary = "abort requested…";
+    const last = lastItem(state);
+    if (last && last.kind === "assistant")
+        last.streaming = false;
+    return state;
+}

package/dist/tui-direct.mjs

@@ -0,0 +1,4 @@
+import { runTui } from "./tui/app.js";
+console.log("calling runTui");
+await runTui({ workdir: process.cwd(), model: "m", provider: "openai", apiKey: "k", permissionMode: "auto", baseUrl: "http://127.0.0.1:1", maxSteps: 5, stream: false }, null);
+console.log("returned");