@nanhara/hara 0.0.1 → 0.33.0

package/dist/tools/patch.js

@@ -0,0 +1,123 @@
+// apply_patch — change MULTIPLE files atomically (all-or-nothing). Everything is validated and
+// computed in memory first; nothing is written unless every change applies cleanly.
+import { readFile, writeFile, mkdir, unlink } from "node:fs/promises";
+import { isAbsolute, resolve, dirname } from "node:path";
+import { registerTool } from "./registry.js";
+import { applyEdits } from "./apply-core.js";
+import { emitDiff } from "../diff.js";
+import { recordEdit } from "../undo.js";
+registerTool({
+    name: "apply_patch",
+    description: "Change SEVERAL files in one atomic step (all-or-nothing). `changes` is an array of " +
+        "{path, type:'update'|'create'|'delete', edits?:[{old_string,new_string,replace_all?}], content?}. " +
+        "update applies edits (or replaces the whole file with content); create writes a new file; delete removes it. " +
+        "If ANY change fails to apply, nothing is written. Prefer this over multiple edit_file calls for multi-file changes.",
+    input_schema: {
+        type: "object",
+        properties: {
+            changes: {
+                type: "array",
+                description: "the file changes to apply together",
+                items: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string" },
+                        type: { type: "string", enum: ["update", "create", "delete"] },
+                        content: { type: "string", description: "full file content (for create, or whole-file update)" },
+                        edits: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    old_string: { type: "string" },
+                                    new_string: { type: "string" },
+                                    replace_all: { type: "boolean" },
+                                },
+                                required: ["old_string", "new_string"],
+                            },
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+        },
+        required: ["changes"],
+    },
+    kind: "edit",
+    async run(input, ctx) {
+        const changes = Array.isArray(input.changes) ? input.changes : [];
+        if (!changes.length)
+            return "Error: apply_patch needs a non-empty `changes` array.";
+        const abs = (pth) => (isAbsolute(pth) ? pth : resolve(ctx.cwd, pth));
+        // PHASE 1 — validate + compute every change in memory; bail before writing anything.
+        const plans = [];
+        for (let i = 0; i < changes.length; i++) {
+            const ch = changes[i];
+            const tag = `change ${i + 1}/${changes.length}`;
+            if (typeof ch.path !== "string" || !ch.path)
+                return `Error: ${tag} is missing a path. Nothing written.`;
+            const p = abs(ch.path);
+            const type = ch.type ?? (ch.edits ? "update" : "create");
+            if (type === "delete") {
+                let before;
+                try {
+                    before = await readFile(p, "utf8");
+                }
+                catch {
+                    return `Error: ${tag} delete ${ch.path}: file not found. Nothing written.`;
+                }
+                plans.push({ path: ch.path, abs: p, type, before, after: null, existed: true });
+            }
+            else if (type === "create") {
+                if (typeof ch.content !== "string")
+                    return `Error: ${tag} create ${ch.path} needs \`content\`. Nothing written.`;
+                let before = "";
+                let existed = false;
+                try {
+                    before = await readFile(p, "utf8");
+                    existed = true;
+                }
+                catch {
+                    /* new file */
+                }
+                plans.push({ path: ch.path, abs: p, type, before, after: ch.content, existed });
+            }
+            else {
+                // update
+                let before;
+                try {
+                    before = await readFile(p, "utf8");
+                }
+                catch {
+                    return `Error: ${tag} update ${ch.path}: cannot read (use type:create for a new file). Nothing written.`;
+                }
+                if (typeof ch.content === "string" && !ch.edits) {
+                    plans.push({ path: ch.path, abs: p, type, before, after: ch.content, existed: true });
+                }
+                else {
+                    const res = applyEdits(before, ch.edits ?? []);
+                    if ("error" in res)
+                        return `Error: ${tag} ${ch.path} — ${res.error}. Nothing written.`;
+                    plans.push({ path: ch.path, abs: p, type, before, after: res.text, existed: true });
+                }
+            }
+        }
+        // PHASE 2 — commit all changes + show each diff.
+        const summary = [];
+        for (const pl of plans) {
+            if (pl.type === "delete") {
+                await unlink(pl.abs);
+                emitDiff(pl.path, pl.before, "", ctx.ui);
+                summary.push(`deleted ${pl.path}`);
+            }
+            else {
+                await mkdir(dirname(pl.abs), { recursive: true });
+                await writeFile(pl.abs, pl.after, "utf8");
+                emitDiff(pl.path, pl.before, pl.after, ctx.ui);
+                summary.push(`${pl.type === "create" ? "created" : "updated"} ${pl.path}`);
+            }
+        }
+        recordEdit(plans.map((pl) => ({ path: pl.path, absPath: pl.abs, before: pl.existed ? pl.before : null })));
+        return `apply_patch: ${plans.length} file(s) — ${summary.join("; ")}.`;
+    },
+});

package/dist/tools/registry.js

@@ -0,0 +1,18 @@
+const registry = new Map();
+export function registerTool(t) {
+    registry.set(t.name, t);
+}
+export function getTool(name) {
+    return registry.get(name);
+}
+export function getTools() {
+    return [...registry.values()];
+}
+/** Provider-neutral tool specs derived from the registry. */
+export function toolSpecs() {
+    return getTools().map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.input_schema,
+    }));
+}

package/dist/tools/search.js

@@ -0,0 +1,176 @@
+// Search/listing tools — grep (regex across files), glob (path patterns), ls (one directory).
+// All read-only (kind: "read"), so they never hit the approval gate and run in parallel.
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { isAbsolute, resolve, join, relative, sep } from "node:path";
+import { registerTool } from "./registry.js";
+import { walkFiles, isProbablyBinary } from "../fs-walk.js";
+const MAX_OUT = 60_000;
+const MAX_MATCHES = 300;
+const MAX_FILE_BYTES = 2 * 1024 * 1024;
+const toPosix = (p) => (sep === "/" ? p : p.split(sep).join("/"));
+const absOf = (p, cwd) => (p ? (isAbsolute(p) ? p : resolve(cwd, p)) : cwd);
+/** Convert a glob (supports **, *, ?) to an anchored RegExp over POSIX paths. */
+function globToRegExp(glob) {
+    let re = "";
+    for (let i = 0; i < glob.length; i++) {
+        const ch = glob[i];
+        if (ch === "*") {
+            if (glob[i + 1] === "*") {
+                // ** matches across path separators (optionally swallow a trailing slash)
+                i++;
+                if (glob[i + 1] === "/")
+                    i++;
+                re += "(?:.*/)?";
+            }
+            else {
+                re += "[^/]*";
+            }
+        }
+        else if (ch === "?")
+            re += "[^/]";
+        else if (".+^${}()|[]\\".includes(ch))
+            re += "\\" + ch;
+        else
+            re += ch;
+    }
+    return new RegExp("^" + re + "$");
+}
+registerTool({
+    name: "grep",
+    description: "Search file contents by regular expression. Returns matching `path:line: text`. " +
+        "Scopes to `path` (dir or file, default cwd); optional `glob` filters which files; `ignore_case`.",
+    input_schema: {
+        type: "object",
+        properties: {
+            pattern: { type: "string", description: "JavaScript regular expression" },
+            path: { type: "string", description: "directory or file to search (default: cwd)" },
+            glob: { type: "string", description: "only search files whose path matches this glob (e.g. **/*.ts)" },
+            ignore_case: { type: "boolean" },
+        },
+        required: ["pattern"],
+    },
+    kind: "read",
+    async run(input, ctx) {
+        let re;
+        try {
+            re = new RegExp(input.pattern, input.ignore_case ? "i" : "");
+        }
+        catch (e) {
+            return `Error: invalid regex: ${e.message}`;
+        }
+        const root = absOf(input.path, ctx.cwd);
+        let isFile = false;
+        try {
+            isFile = statSync(root).isFile();
+        }
+        catch {
+            return `Error: no such path: ${input.path ?? "."}`;
+        }
+        const rel = (abs) => toPosix(relative(ctx.cwd, abs)) || toPosix(relative(root, abs));
+        const files = isFile ? [root] : walkFiles(root).map((f) => join(root, f));
+        const globRe = input.glob ? globToRegExp(input.glob) : null;
+        const lines = [];
+        let matches = 0;
+        let scanned = 0;
+        for (const abs of files) {
+            if (matches >= MAX_MATCHES)
+                break;
+            const r = toPosix(relative(ctx.cwd, abs));
+            if (globRe && !globRe.test(toPosix(relative(isFile ? ctx.cwd : root, abs))))
+                continue;
+            let buf;
+            try {
+                if (statSync(abs).size > MAX_FILE_BYTES)
+                    continue;
+                buf = readFileSync(abs);
+            }
+            catch {
+                continue;
+            }
+            if (isProbablyBinary(buf))
+                continue;
+            scanned++;
+            const text = buf.toString("utf8");
+            const fileLines = text.split("\n");
+            for (let i = 0; i < fileLines.length; i++) {
+                if (re.test(fileLines[i])) {
+                    lines.push(`${r}:${i + 1}: ${fileLines[i].trim().slice(0, 300)}`);
+                    if (++matches >= MAX_MATCHES)
+                        break;
+                }
+            }
+        }
+        if (!lines.length)
+            return `No matches for /${input.pattern}/ (scanned ${scanned} files).`;
+        let body = lines.join("\n");
+        if (body.length > MAX_OUT)
+            body = body.slice(0, MAX_OUT) + "\n…[truncated]";
+        const head = matches >= MAX_MATCHES ? `(showing first ${MAX_MATCHES} matches)\n` : "";
+        return head + body;
+    },
+});
+registerTool({
+    name: "glob",
+    description: "List files whose path matches a glob pattern (supports **, *, ?). Scopes to `path` (default cwd).",
+    input_schema: {
+        type: "object",
+        properties: {
+            pattern: { type: "string", description: "e.g. **/*.ts, src/**/index.*" },
+            path: { type: "string", description: "base directory (default: cwd)" },
+        },
+        required: ["pattern"],
+    },
+    kind: "read",
+    async run(input, ctx) {
+        const root = absOf(input.path, ctx.cwd);
+        const re = globToRegExp(input.pattern);
+        const hits = walkFiles(root).filter((f) => re.test(f));
+        if (!hits.length)
+            return `No files match ${input.pattern}.`;
+        const shown = hits.slice(0, 400);
+        const head = hits.length > shown.length ? `(${hits.length} matches, showing 400)\n` : "";
+        return head + shown.join("\n");
+    },
+});
+registerTool({
+    name: "ls",
+    description: "List the entries of one directory (name, type, size). Non-recursive; use glob/grep to search deeper.",
+    input_schema: {
+        type: "object",
+        properties: { path: { type: "string", description: "directory (default: cwd)" } },
+    },
+    kind: "read",
+    async run(input, ctx) {
+        const dir = absOf(input.path, ctx.cwd);
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch (e) {
+            return `Error: cannot list ${input.path ?? "."}: ${e.message}`;
+        }
+        const rows = entries
+            .filter((e) => !(e.isDirectory() && e.name === ".git"))
+            .sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name))
+            .map((e) => {
+            if (e.isDirectory())
+                return `  ${e.name}/`;
+            let size = 0;
+            try {
+                size = statSync(join(dir, e.name)).size;
+            }
+            catch {
+                /* ignore */
+            }
+            return `  ${e.name}  ${c_size(size)}`;
+        });
+        return rows.length ? rows.join("\n") : "(empty directory)";
+    },
+});
+function c_size(n) {
+    if (n < 1024)
+        return `${n}B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)}K`;
+    return `${(n / 1024 / 1024).toFixed(1)}M`;
+}

package/dist/tools/skill.js

@@ -0,0 +1,30 @@
+// The `skill` tool — load a skill's full instructions on demand. The system prompt lists available
+// skills (id + description); the model calls this to pull the body before doing a task the skill covers.
+// Returning the body as a tool RESULT (not editing the system prompt) keeps the cached prefix stable.
+import { registerTool } from "./registry.js";
+import { loadSkillIndex, loadSkillBody } from "../skills/skills.js";
+import { scanMemory } from "../memory/guard.js";
+registerTool({
+    name: "skill",
+    description: "Load the full instructions for a skill by id. The system prompt's Skills list shows what's available; " +
+        "call this to get a skill's steps before performing a task it covers, then follow them.",
+    input_schema: { type: "object", properties: { id: { type: "string", description: "the skill id from the Skills list" } }, required: ["id"] },
+    kind: "read",
+    async run(input, ctx) {
+        const id = String(input.id ?? "").trim();
+        const sk = loadSkillIndex(ctx.cwd).find((s) => s.id === id);
+        if (!sk)
+            return `No skill '${id}'. See the Skills list in the system prompt for available ids.`;
+        const body = loadSkillBody(sk);
+        if (!body)
+            return `Skill '${id}' has no instructions.`;
+        const scan = scanMemory(body); // skills may come from plugins (untrusted) — guard at load time
+        if (!scan.ok)
+            return `Skill '${id}' blocked: its content looks unsafe (${scan.hits.join(", ")}).`;
+        if (sk.context === "fork" && ctx.spawn) {
+            // fork: run the skill as a delegated sub-agent rather than inlining it into this turn
+            return await ctx.spawn(`Follow this skill to complete the current task:\n\n${body}`);
+        }
+        return body; // inline (default): the body enters the conversation as this tool's result
+    },
+});

package/dist/tools/web.js

@@ -0,0 +1,73 @@
+// web_fetch — fetch an http(s) URL and return readable text (HTML reduced to text). Read-only.
+// Uses Node's global fetch (Node >=20). NOT sandboxed (network egress is in-process, not via bash).
+import { registerTool } from "./registry.js";
+const MAX = 60_000;
+/** Strip HTML to a readable-ish plain-text approximation (no dependency). */
+export function htmlToText(html) {
+    return html
+        .replace(/<head[\s\S]*?<\/head>/gi, " ")
+        .replace(/<script[\s\S]*?<\/script>/gi, " ")
+        .replace(/<style[\s\S]*?<\/style>/gi, " ")
+        .replace(/<!--[\s\S]*?-->/g, " ")
+        .replace(/<li[^>]*>/gi, "\n- ")
+        .replace(/<\/(p|div|h[1-6]|li|tr|section|article|header|footer|ul|ol|blockquote)>/gi, "\n")
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/[ \t]+/g, " ")
+        .replace(/ *\n */g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+registerTool({
+    name: "web_fetch",
+    description: "Fetch an http(s) URL and return its text content (HTML is reduced to readable text). Read-only. " +
+        "Use for docs, references, or pages the user mentions. Not sandboxed.",
+    input_schema: {
+        type: "object",
+        properties: {
+            url: { type: "string", description: "http:// or https:// URL" },
+            max_chars: { type: "number", description: "cap on returned text (default 60000)" },
+        },
+        required: ["url"],
+    },
+    kind: "read",
+    async run(input) {
+        let url;
+        try {
+            url = new URL(input.url);
+        }
+        catch {
+            return `Error: invalid URL: ${input.url}`;
+        }
+        if (url.protocol !== "http:" && url.protocol !== "https:")
+            return "Error: only http/https URLs are supported.";
+        const cap = Math.min(Math.max(1000, input.max_chars ?? MAX), 200_000);
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), 30_000);
+        try {
+            const res = await fetch(url, {
+                signal: ctrl.signal,
+                redirect: "follow",
+                headers: { "user-agent": "hara-cli", accept: "text/html,text/plain,application/json,*/*" },
+            });
+            const ct = res.headers.get("content-type") ?? "";
+            const raw = await res.text();
+            let text = /html/i.test(ct) ? htmlToText(raw) : raw;
+            if (text.length > cap)
+                text = text.slice(0, cap) + `\n…[truncated ${text.length - cap} chars]`;
+            return `# ${url.href} (HTTP ${res.status})\n\n${text || "(empty body)"}`;
+        }
+        catch (e) {
+            return `Error fetching ${url.href}: ${e?.name === "AbortError" ? "timed out (30s)" : (e?.message ?? e)}`;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    },
+});

package/dist/tui/App.js

@@ -0,0 +1,165 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The hara TUI (ink). Layout, top to bottom:
+//   <Static>   committed transcript — rendered once each, scrolls into native scrollback
+//   current    the in-progress turn's blocks (assistant text / reasoning / tool / diff), live
+//   <Working>  spinner while a turn runs (Esc interrupts)
+//   <InputBox> the pinned, bordered prompt (or a confirm prompt when a tool needs approval)
+//
+// The agent machinery is injected via `onSubmit` (a turn runner) so this view is testable with
+// ink-testing-library against a fake runner — no provider/network needed.
+import { Box, Static, Text, useApp, useInput } from "ink";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { InputBox } from "./InputBox.js";
+import { activity } from "../activity.js";
+import { ctxPctFor } from "../statusbar.js";
+import { accent } from "./theme.js";
+let _id = 0;
+const nid = () => ++_id;
+const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+function Block({ item, open }) {
+    switch (item.kind) {
+        case "user":
+            return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "cyan", children: "\u203A " }), _jsx(Text, { children: item.text })] }));
+        case "assistant":
+            return _jsx(Text, { children: item.text });
+        case "reasoning": {
+            // fixed-height window: show the last 5 lines while thinking; ctrl-r toggles the full text.
+            const lines = item.text.replace(/\n+$/, "").split("\n");
+            const long = lines.length > 5;
+            const shown = open || !long ? lines : lines.slice(-5);
+            const hint = long ? (open ? " · ctrl-r collapse" : " · ctrl-r expand") : "";
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: accent(), dimColor: true, children: `✻ thinking … ${lines.length} line${lines.length === 1 ? "" : "s"}${hint}` }), shown.map((l, i) => (_jsx(Text, { dimColor: true, children: `│ ${l}` }, i)))] }));
+        }
+        case "tool":
+            return _jsx(Text, { dimColor: true, children: "  " + item.text });
+        case "diff":
+            return _jsx(Text, { children: item.text });
+        case "notice":
+            return _jsx(Text, { dimColor: true, children: item.text });
+    }
+}
+// ASCII rendering of the nanhara "Λi" mark (small peak + big peak + italic i), in the brand violet.
+// hara wordmark — FIGlet "ANSI Shadow". A recognizable banner reads better in a terminal than a
+// pixel-faithful logo. Printed once at the top of the session; scrolls away with the transcript.
+const BANNER = [
+    "██╗  ██╗ █████╗ ██████╗  █████╗",
+    "██║  ██║██╔══██╗██╔══██╗██╔══██╗",
+    "███████║███████║██████╔╝███████║",
+    "██╔══██║██╔══██║██╔══██╗██╔══██║",
+    "██║  ██║██║  ██║██║  ██║██║  ██║",
+    "╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝",
+];
+function HeaderCard({ version, model, cwd, tip, vision, session }) {
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [BANNER.map((row, i) => (_jsx(Text, { color: accent(), children: row }, i))), _jsx(Text, { dimColor: true, children: ` the coding agent that runs like an org   ·   v${version}` }), _jsx(Text, { dimColor: true, children: ` ${model}  ·  ${cwd}` }), session ? _jsx(Text, { dimColor: true, children: ` session ${session}` }) : null, vision ? (_jsxs(Text, { children: [_jsx(Text, { color: accent(), children: " 👁 " }), _jsx(Text, { dimColor: true, children: vision })] })) : null, tip ? _jsx(Text, { dimColor: true, children: ` ${tip}` }) : null] }));
+}
+function Working() {
+    const [n, setN] = useState(0);
+    useEffect(() => {
+        const id = setInterval(() => setN((x) => x + 1), 100);
+        return () => clearInterval(id);
+    }, []);
+    const frames = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏";
+    return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "yellow", children: frames[n % frames.length] }), _jsx(Text, { dimColor: true, children: ` working ${Math.floor(n / 10)}s · esc to interrupt` })] }));
+}
+export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval, onClipboardImage }) {
+    const { exit } = useApp();
+    const [history, setHistory] = useState([]);
+    const [current, setCurrent] = useState([]);
+    const [working, setWorking] = useState(false);
+    const [status, setStatus] = useState({ ...initialStatus, agents: 0 });
+    const [prompt, setPrompt] = useState(null);
+    const [promptSel, setPromptSel] = useState(0);
+    const [reasoningOpen, setReasoningOpen] = useState(false);
+    const ctrlRef = useRef(null);
+    const currentRef = useRef([]);
+    currentRef.current = current;
+    const statusRef = useRef(status);
+    statusRef.current = status;
+    useEffect(() => {
+        const fn = () => setStatus((s) => ({ ...s, agents: activity.running }));
+        activity.onChange(fn);
+        return () => activity.onChange(null);
+    }, []);
+    const pushCurrent = useCallback((kind, text, merge = false) => {
+        setCurrent((cur) => {
+            const last = cur[cur.length - 1];
+            if (merge && last && last.kind === kind)
+                return [...cur.slice(0, -1), { ...last, text: last.text + text }];
+            return [...cur, { id: nid(), kind, text }];
+        });
+    }, []);
+    const handleSubmit = useCallback(async (line, images) => {
+        const t = line.trim();
+        if ((!t && !images?.length) || working || prompt)
+            return; // allow image-only turns
+        setHistory((h) => [...h, { id: nid(), kind: "user", text: t }]); // t already carries any [Image #N] tokens
+        const ctrl = new AbortController();
+        ctrlRef.current = ctrl;
+        setWorking(true);
+        const sink = {
+            assistantDelta: (d) => pushCurrent("assistant", d, true),
+            reasoningDelta: (d) => pushCurrent("reasoning", d, true),
+            tool: (name, preview) => pushCurrent("tool", `↳ ${name}${preview ? " " + preview : ""}`),
+            diff: (text) => pushCurrent("diff", text),
+            notice: (text) => pushCurrent("notice", text),
+            usage: (input, output) => setStatus((s) => ({ ...s, input: s.input + input, output: s.output + output, ctxPct: ctxPctFor(model, input) })),
+            session: (name) => setStatus((s) => ({ ...s, sessionName: name })),
+        };
+        const openPrompt = (title, options) => new Promise((resolve) => {
+            setPromptSel(0);
+            setPrompt({ title, options: options, resolve: resolve });
+        });
+        const confirmFn = (q) => openPrompt(q, [
+            { label: "Yes", value: true, key: "y" },
+            { label: "Yes, and don't ask again this session", value: "always", key: "a" },
+            { label: "No  (esc)", value: false, key: "n" },
+        ]);
+        const selectFn = (title, options) => openPrompt(title, options);
+        const setApprovalFn = (m) => setStatus((s) => ({ ...s, approval: m }));
+        try {
+            await onSubmit(t, { sink, confirm: confirmFn, select: selectFn, setApproval: setApprovalFn, signal: ctrl.signal, exit, approval: statusRef.current.approval }, images);
+        }
+        catch (e) {
+            pushCurrent("notice", `error: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        const committed = currentRef.current.map((it) => it.kind === "reasoning"
+            ? { ...it, kind: "notice", text: `✻ thought · ${it.text.split("\n").filter((l) => l.trim()).length} lines` }
+            : it);
+        setHistory((h) => [...h, ...committed]);
+        setCurrent([]);
+        setWorking(false);
+        ctrlRef.current = null;
+    }, [working, prompt, onSubmit, pushCurrent, model, exit]);
+    useInput((input, key) => {
+        if (prompt) {
+            const opts = prompt.options;
+            if (key.upArrow)
+                setPromptSel((s) => (s - 1 + opts.length) % opts.length);
+            else if (key.downArrow)
+                setPromptSel((s) => (s + 1) % opts.length);
+            else if (key.return) {
+                prompt.resolve(opts[Math.min(promptSel, opts.length - 1)].value);
+                setPrompt(null);
+            }
+            else if (key.escape) {
+                prompt.resolve(opts[opts.length - 1].value); // last option = cancel/no
+                setPrompt(null);
+            }
+            else if (input) {
+                const hit = opts.find((o) => o.key && o.key === input.toLowerCase());
+                if (hit) {
+                    prompt.resolve(hit.value);
+                    setPrompt(null);
+                }
+            }
+            return;
+        }
+        if (key.ctrl && input === "r")
+            return setReasoningOpen((x) => !x);
+        if (key.escape && working)
+            ctrlRef.current?.abort();
+        else if (key.tab && key.shift && cycleApproval)
+            setStatus((s) => ({ ...s, approval: cycleApproval(s.approval) }));
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: header ? [{ id: -1, kind: "notice", text: "" }, ...history] : history, children: (item) => (item.id === -1 ? _jsx(HeaderCard, { ...header }, "hdr") : _jsx(Block, { item: item }, item.id)) }), current.map((item) => (_jsx(Block, { item: item, open: reasoningOpen }, item.id))), working && !prompt && _jsx(Working, {}), prompt && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "yellow", children: `  ${stripAnsi(prompt.title)}` }), prompt.options.map((o, i) => (_jsx(Text, { color: i === promptSel ? "cyan" : undefined, bold: i === promptSel, children: (i === promptSel ? " ❯ " : "   ") + o.label }, i)))] })), _jsx(InputBox, { status: status, cwd: cwd, isActive: !working && !prompt, onSubmit: handleSubmit, onClipboardImage: onClipboardImage })] }));
+}