@scira/cli 0.1.5 → 0.1.7

package/dist/ui/ink/hooks/use-keyboard.js

@@ -16,6 +16,9 @@ export function useKeyboard(o) {
     const { setScrollOffset, contentRows, maxScrollOffset, pendingRerun, setPendingRerun, busy, stopTurn, submitChat, toggleAllGroups, toggleFocusedGroup, focusPrevGroup, focusNextGroup, unfocusGroup, hasFocusedGroup } = o.chat;
     const { sessionsModalOpen, setSessionsModalOpen, sessionsModalIdx, setSessionsModalIdx, sessions, deleteSession, selectedIdx, setSelectedIdx, setHeroHidden, openRun, submitHome } = o.home;
     const deleteArmedRef = useRef(null);
+    // Quit requires confirmation: first Ctrl+C arms, second within the window quits.
+    const quitArmedRef = useRef(false);
+    const quitTimerRef = useRef(null);
     const editInput = (char, key) => {
         const deleteWordBefore = () => {
             const match = inputText.slice(0, cursorPos).match(/\S+\s*$/u);
@@ -95,6 +98,30 @@ export function useKeyboard(o) {
         // OSC background-color query responses leak as stdin when terminals reply to theme probes.
         if (char && (/\]11;rgb:/u.test(char) || /^11;rgb:/u.test(char)))
             return;
+        // Quit handling (all screens): Ctrl+C twice (with warning) or Ctrl+D.
+        if (key.ctrl && char === "c") {
+            if (busy) {
+                stopTurn();
+                quitArmedRef.current = false;
+                return;
+            }
+            if (quitArmedRef.current) {
+                exit();
+                return;
+            }
+            quitArmedRef.current = true;
+            setNotice("Press Ctrl+C again to quit (or Ctrl+D).");
+            if (quitTimerRef.current)
+                clearTimeout(quitTimerRef.current);
+            quitTimerRef.current = setTimeout(() => { quitArmedRef.current = false; }, 3000);
+            // Don't let the disarm timer keep the process alive after a quit.
+            quitTimerRef.current.unref?.();
+            return;
+        }
+        if (key.ctrl && char === "d" && !inputText) {
+            exit();
+            return;
+        }
         if (approvalPending) {
             if (char === "y" || char === "Y" || key.return) {
                 const p = approvalPending;
@@ -303,7 +330,7 @@ export function useKeyboard(o) {
                     setSessionsModalIdx(0);
                 }
                 else if (selectedIdx === newIdx) {
-                    setNotice("Type a question below to start a new research run.");
+                    setNotice("Type a question below to start a new session.");
                 }
                 else if (selectedIdx === quitIdx) {
                     exit();
@@ -312,10 +339,6 @@ export function useKeyboard(o) {
                     void submitHome("");
                 }
             }
-            else if (char === "q" && !inputText)
-                exit();
-            else if (key.ctrl && char === "d" && !inputText)
-                exit();
             else
                 editInput(char, key);
         }

package/dist/ui/ink/hooks/use-session.js

@@ -1,10 +1,9 @@
 import { useCallback } from "react";
-import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { listRuns, summarizeRun } from "../../../storage/run-store.js";
 import { getSession, attachSubscriber } from "../session-manager.js";
 export function useSession(o) {
-    const { config, currentRunPath, conversationRef, feedRef, turnsRef, startedRef, setSessions, setRunState, setCurrentRunPath, setInputText, setCursorPos, setFeed, setUsage, setScrollOffset, setScreen, setMode, setPlanMode, setBusy, setApprovalPending, getSubscriber, } = o;
+    const { config, currentRunPath, conversationRef, feedRef, turnsRef, startedRef, pendingPlanModeRef, setSessions, setRunState, setCurrentRunPath, setInputText, setCursorPos, setFeed, setUsage, setScrollOffset, setScreen, setMode, setPlanMode, setPendingPlanMode, setBusy, setApprovalPending, getSubscriber, } = o;
     const refreshSessions = useCallback(async () => {
         const runs = await listRuns(config);
         setSessions(runs);
@@ -14,8 +13,11 @@ export function useSession(o) {
             setRunState(await summarizeRun(currentRunPath));
     }, [currentRunPath]);
     const openRun = useCallback(async (runPath, initialQuestion) => {
-        if (runPath !== currentRunPath)
-            setPlanMode(false);
+        if (runPath !== currentRunPath) {
+            // Honor a plan-mode preference armed from the home screen, then disarm it.
+            setPlanMode(pendingPlanModeRef.current);
+            setPendingPlanMode(false);
+        }
         setCurrentRunPath(runPath);
         setInputText("");
         setCursorPos(0);
@@ -39,7 +41,7 @@ export function useSession(o) {
             return undefined;
         }
         try {
-            const raw = await readFile(join(runPath, "convo.json"), "utf8");
+            const raw = await Bun.file(join(runPath, "convo.json")).text();
             const saved = JSON.parse(raw);
             if (saved.feed && saved.feed.length > 0) {
                 const filteredFeed = saved.feed.filter((item) => !(item.kind === "status" && item.text === "This will wipe the conversation history. Press /rerun again to confirm."));

package/dist/ui/ink/hooks/use-settings.js

@@ -146,6 +146,26 @@ export function useSettings({ config, setConfig, screen, pushFeed, setNotice })
             await setEnvKey(name, value);
             return `${name} saved to ~/.scira/.env and active for this session. Use .scira/.env in a project to scope keys to that repo.`;
         }
+        if (cmd === "/thinking") {
+            if (!arg)
+                return `Claude Code thinking: ${config.harness.thinking}\nOptions: off, on, adaptive`;
+            if (!["off", "on", "adaptive"].includes(arg))
+                return `Unknown thinking mode "${arg}". Options: off, on, adaptive`;
+            const next = { ...config, harness: { ...config.harness, thinking: arg } };
+            setConfig(next);
+            await saveGlobalConfig(next);
+            return `Claude Code thinking set to ${arg}.`;
+        }
+        if (cmd === "/reasoning") {
+            if (!arg)
+                return `Codex reasoning effort: ${config.harness.reasoningEffort}\nOptions: low, medium, high`;
+            if (!["low", "medium", "high"].includes(arg))
+                return `Unknown reasoning effort "${arg}". Options: low, medium, high`;
+            const next = { ...config, harness: { ...config.harness, reasoningEffort: arg } };
+            setConfig(next);
+            await saveGlobalConfig(next);
+            return `Codex reasoning effort set to ${arg}.`;
+        }
         if (cmd === "/theme") {
             if (!arg) {
                 const terminal = detectTerminalTheme();

package/dist/ui/ink/hooks/use-submit.js

@@ -1,5 +1,4 @@
 import { useCallback, useRef } from "react";
-import { readFile } from "node:fs/promises";
 import { createRun, getRunPaths, setRunTitle } from "../../../storage/run-store.js";
 import { readJsonl } from "../../../storage/jsonl.js";
 import { fmtDuration, fmtTokens, copyToClipboard } from "../lib/utils.js";
@@ -7,8 +6,8 @@ import { detachSubscriber, abortSession } from "../session-manager.js";
 import { saveGlobalMcpConfig } from "../../../config/load-config.js";
 export function useSubmit(o) {
     const { config, currentRunPath, sessions, selectedIdx, busy, usage, pendingRerun } = o.state;
-    const { queuedPromptRef, fullModeRef, planModeRef, conversationRef, feedRef } = o.refs;
-    const { setApprovalPending, setInputText, setCursorPos, setInputHistory, setHistoryIndex, setHelpOpen, setNotice, setBusy, setScreen, setFeed, setRunState, setPendingRerun, setMode, setPlanMode, setConfig, setMcpOpen, setHeroHidden, } = o.setters;
+    const { queuedPromptRef, fullModeRef, planModeRef, pendingPlanModeRef, conversationRef, feedRef } = o.refs;
+    const { setApprovalPending, setInputText, setCursorPos, setInputHistory, setHistoryIndex, setHelpOpen, setNotice, setBusy, setScreen, setFeed, setRunState, setPendingRerun, setMode, setPlanMode, setPendingPlanMode, setConfig, setMcpOpen, setHeroHidden, } = o.setters;
     const { pushFeed, refreshSessions, openRun, openMenu, handleSettings, runTurn, exit } = o.actions;
     const rerunConfirmRef = useRef(false);
     const abortTurn = useCallback(() => {
@@ -27,7 +26,7 @@ export function useSubmit(o) {
                 void openRun(selected.path);
             return;
         }
-        if (text === "q" || text === "/quit" || text === "/q") {
+        if (text === "/quit" || text === "/q") {
             exit();
             return;
         }
@@ -60,7 +59,15 @@ export function useSubmit(o) {
                 setMcpOpen(true);
                 return;
             }
-            setNotice("Open a research session first to use /mcp enable/disable/add.");
+            setNotice("Open a session first to use /mcp enable/disable/add.");
+            return;
+        }
+        if (text === "/plan") {
+            const next = !pendingPlanModeRef.current;
+            setPendingPlanMode(next);
+            setNotice(next
+                ? "Plan mode armed — the next run you start will open in plan mode."
+                : "Plan mode disarmed.");
             return;
         }
         if (text.startsWith("/")) {
@@ -136,7 +143,7 @@ export function useSubmit(o) {
             void openMenu("provider");
             return;
         }
-        if (["/key", "/keys", "/llm", "/theme"].includes(text.split(/\s+/u)[0])) {
+        if (["/key", "/keys", "/llm", "/theme", "/thinking", "/reasoning"].includes(text.split(/\s+/u)[0])) {
             void (async () => {
                 const result = await handleSettings(text);
                 if (result)
@@ -147,7 +154,7 @@ export function useSubmit(o) {
         if (text === "/report") {
             void (async () => {
                 try {
-                    const report = await readFile(getRunPaths(currentRunPath).report, "utf8");
+                    const report = await Bun.file(getRunPaths(currentRunPath).report).text();
                     pushFeed({ kind: "text", text: report });
                 }
                 catch {
@@ -290,7 +297,7 @@ export function useSubmit(o) {
             void (async () => {
                 const currentSession = sessions.find(s => s.path === currentRunPath);
                 const report = currentSession?.isFull
-                    ? await readFile(getRunPaths(currentRunPath).report, "utf8").catch(() => "")
+                    ? await Bun.file(getRunPaths(currentRunPath).report).text().catch(() => "")
                     : "";
                 const lastText = [...feedRef.current].reverse().find((it) => it.kind === "text")?.text ?? "";
                 const content = report.trim() || lastText;

package/dist/ui/ink/lib/file-mentions.js

@@ -1,5 +1,4 @@
 import { readdirSync, statSync } from "node:fs";
-import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { FILE_MENTION_SKIP, FILE_MENTION_MAX_CHARS } from "../constants.js";
 export function listMentionableFiles(root = process.cwd(), max = 300) {
@@ -52,7 +51,7 @@ export async function promptWithFileMentions(prompt) {
     for (const file of files) {
         const abs = join(process.cwd(), file);
         try {
-            const content = await readFile(abs, "utf8");
+            const content = await Bun.file(abs).text();
             const body = content.length > FILE_MENTION_MAX_CHARS
                 ? `${content.slice(0, FILE_MENTION_MAX_CHARS)}\n...[truncated ${content.length - FILE_MENTION_MAX_CHARS} chars]`
                 : content;

package/dist/ui/ink/lib/tool-result.js

@@ -1,8 +1,45 @@
+import { diffLines } from "diff";
 import { markdownToSegLines } from "./markdown.js";
 import { wrapText } from "./utils.js";
+const HARNESS_TOOL_PREFIX = "mcp__harness-tools__";
+/** Map Claude Code / Codex built-in (and harness host) tool names onto Scira's renderers. */
+const CANONICAL_TOOL = {
+    // Scira host tools exposed to the CLI
+    multiWebSearch: "webSearch",
+    // Claude Code built-ins
+    Read: "readFile",
+    Write: "writeFile",
+    Edit: "editFile",
+    MultiEdit: "editFile",
+    NotebookEdit: "editFile",
+    Bash: "bash",
+    BashOutput: "bash",
+    Grep: "grepWorkspace",
+    Glob: "listWorkspaceDir",
+    LS: "listWorkspaceDir",
+    TodoWrite: "todo",
+    WebFetch: "readUrl",
+    WebSearch: "webSearch",
+    // Codex built-ins
+    shell: "bash",
+};
+/** Strip the harness host-tool MCP prefix so `mcp__harness-tools__readUrl` reads as `readUrl`. */
+export function displayToolName(name) {
+    return name.startsWith(HARNESS_TOOL_PREFIX) ? name.slice(HARNESS_TOOL_PREFIX.length) : name;
+}
+/**
+ * Resolve a harness/CLI tool name to the Scira renderer key. The harness exposes
+ * our host tools as `mcp__harness-tools__*` and the CLIs have their own builtin
+ * names (Read, Bash, Grep, …); both should render like Scira's equivalents.
+ */
+export function canonicalToolName(name) {
+    const stripped = displayToolName(name);
+    return CANONICAL_TOOL[stripped] ?? stripped;
+}
 /** Tools that start collapsed in the timeline (long output). */
 export const DEFAULT_COLLAPSED_TOOLS = new Set([
     "webSearch",
+    "multiWebSearch",
     "readUrl",
     "readFile",
     "readWorkspaceFile",
@@ -185,9 +222,15 @@ function formatListSkills(result, width, theme) {
     });
 }
 function formatShellOutput(result, width, theme) {
-    if (!result.trim())
+    // Codex returns `{ exitCode, output }`; Claude returns the output string directly.
+    let text = result;
+    const obj = parseObj(result);
+    if (obj && typeof obj.output === "string") {
+        text = typeof obj.exitCode === "number" && obj.exitCode !== 0 ? `[exit ${obj.exitCode}]\n${obj.output}` : obj.output;
+    }
+    if (!text.trim())
         return [[seg("(no output)", { dim: true, color: theme.textDim })]];
-    return result.split("\n").flatMap((line) => plainLines(line, width, { color: theme.textDim }));
+    return text.split("\n").flatMap((line) => plainLines(line, width, { color: theme.textDim }));
 }
 function formatFileContent(result, width, theme) {
     const rows = result.split("\n");
@@ -291,7 +334,8 @@ function formatBody(name, result, width, theme) {
     }
 }
 /** One-line preview for a collapsed tool header. */
-export function formatToolResultPreview(name, inputSummary, result, status) {
+export function formatToolResultPreview(rawName, inputSummary, result, status) {
+    const name = canonicalToolName(rawName);
     const input = inputSummary.replace(/\s+/gu, " ").trim();
     if (status === "running")
         return input ? `${input} · running…` : "running…";
@@ -345,10 +389,181 @@ export function formatToolResultPreview(name, inputSummary, result, status) {
     const first = result.replace(/\s+/gu, " ").trim();
     return first.length > 140 ? `${first.slice(0, 137)}…` : first;
 }
+// --- Dedicated renderers for Claude Code / Codex built-in tools ---
+function parseObj(s) {
+    if (!s)
+        return null;
+    try {
+        const v = JSON.parse(s);
+        return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Unified-ish diff between two strings: removed lines red, added green, a little context dim. */
+function diffSegLines(oldStr, newStr, width, theme) {
+    const parts = diffLines(oldStr ?? "", newStr ?? "");
+    const out = [];
+    const MAX = 60;
+    let count = 0;
+    for (const part of parts) {
+        const sign = part.added ? "+" : part.removed ? "-" : " ";
+        const color = part.added ? theme.success : part.removed ? theme.error : theme.textDim;
+        const linesIn = part.value.replace(/\n$/u, "").split("\n");
+        for (const ln of linesIn) {
+            if (count >= MAX) {
+                out.push([seg("… diff truncated", { dim: true, color: theme.textDim })]);
+                return out;
+            }
+            for (const wrapped of wrapText(`${sign} ${ln}`, width)) {
+                out.push([seg(wrapped, { color, dim: !part.added && !part.removed })]);
+            }
+            count++;
+        }
+    }
+    return out;
+}
+function pathHeader(p, theme) {
+    return [seg("path  ", { dim: true, color: theme.textDim }), seg(String(p ?? ""), { color: theme.text })];
+}
+/** Edit / MultiEdit → file path + colored diff(s). */
+function formatEditBody(input, width, theme) {
+    const lines = [pathHeader(input.file_path ?? input.notebook_path, theme)];
+    const edits = Array.isArray(input.edits)
+        ? input.edits
+        : [{ old_string: input.old_string, new_string: input.new_string }];
+    edits.forEach((e, i) => {
+        if (edits.length > 1)
+            lines.push([seg(`edit ${i + 1}`, { dim: true, color: theme.textDim })]);
+        lines.push(...diffSegLines(String(e.old_string ?? ""), String(e.new_string ?? input.new_source ?? ""), width, theme));
+    });
+    return lines;
+}
+/** TodoWrite → checklist with status glyphs. */
+function formatTodoBody(input, width, theme) {
+    const todos = Array.isArray(input.todos) ? input.todos : [];
+    if (todos.length === 0)
+        return [[seg("(no todos)", { dim: true, color: theme.textDim })]];
+    return todos.flatMap((t) => {
+        const status = String(t.status ?? "pending");
+        const glyph = status === "completed" ? "☑" : status === "in_progress" ? "◐" : "☐";
+        const color = status === "completed" ? theme.success : status === "in_progress" ? theme.warning : theme.textDim;
+        const text = String(t.content ?? t.activeForm ?? "");
+        const wrapped = wrapText(text, Math.max(8, width - 2));
+        return wrapped.map((w, i) => [seg(i === 0 ? `${glyph} ` : "  ", { color }), seg(w, { color: status === "completed" ? theme.textDim : theme.text })]);
+    });
+}
+/** Write → file path + content preview. */
+function formatWriteBody(input, width, theme) {
+    const lines = [pathHeader(input.file_path, theme), blank()];
+    const allLines = String(input.content ?? "").split("\n");
+    const shown = allLines.slice(0, 40);
+    for (const ln of shown)
+        lines.push(...plainLines(ln, width, { color: theme.text }));
+    if (allLines.length > shown.length)
+        lines.push([seg(`… +${allLines.length - shown.length} more lines`, { dim: true, color: theme.textDim })]);
+    return lines;
+}
+/** WebFetch → url + fetched/answer text. */
+function formatWebFetchBody(input, result, width, theme) {
+    const lines = [];
+    const url = input?.url;
+    if (url)
+        lines.push([seg("url  ", { dim: true, color: theme.textDim }), seg(String(url), { color: theme.accent, underline: true, url: String(url) })]);
+    if (result.trim()) {
+        if (lines.length > 0)
+            lines.push(blank());
+        lines.push(...plainLines(result, width, { color: theme.text }));
+    }
+    return lines;
+}
+/** Task / Agent (subagent) → description + output. */
+function formatSubagentBody(input, result, width, theme) {
+    const lines = [];
+    const desc = input?.description ?? input?.subagent_type;
+    if (desc)
+        lines.push([seg("task  ", { dim: true, color: theme.textDim }), seg(String(desc), { color: theme.text })]);
+    if (result.trim()) {
+        if (lines.length > 0)
+            lines.push(blank());
+        lines.push(...markdownToSegLines(result, width, theme));
+    }
+    return lines;
+}
+/** ToolSearch → query + which tool reference it loaded. */
+function formatToolSearchBody(input, result, width, theme) {
+    const lines = [];
+    if (input?.query)
+        lines.push([seg("query  ", { dim: true, color: theme.textDim }), seg(String(input.query), { color: theme.text })]);
+    const ref = parseObj(result);
+    if (ref?.tool_name)
+        lines.push([seg("loaded  ", { dim: true, color: theme.textDim }), seg(String(ref.tool_name), { color: theme.accent })]);
+    else if (result.trim())
+        lines.push(...plainLines(result, width, { color: theme.textDim }));
+    return lines;
+}
+/**
+ * Dedicated body for a Claude Code / Codex built-in tool, keyed by its real
+ * (un-prefixed) name. Returns null to fall through to the generic renderer.
+ */
+function formatBuiltinBody(real, rawInput, result, width, theme) {
+    const input = parseObj(rawInput);
+    switch (real) {
+        case "Edit":
+        case "edit":
+        case "MultiEdit":
+        case "NotebookEdit":
+            return input ? formatEditBody(input, width, theme) : null;
+        case "TodoWrite":
+            return input ? formatTodoBody(input, width, theme) : null;
+        case "Write":
+        case "write":
+            return input ? formatWriteBody(input, width, theme) : null;
+        case "WebFetch":
+            return formatWebFetchBody(input, result, width, theme);
+        case "Task":
+        case "Agent":
+            return formatSubagentBody(input, result, width, theme);
+        case "ToolSearch":
+            return formatToolSearchBody(input, result, width, theme);
+        case "fileChange":
+            return formatFileChangeBody(input ?? parseObj(result), theme);
+        default:
+            return null;
+    }
+}
+/** Codex/Claude file mutation event → a single colored "<event>  <path>" line. */
+function formatFileChangeBody(fc, theme) {
+    if (!fc)
+        return null;
+    const event = String(fc.event ?? "change");
+    const color = event === "delete" ? theme.error : event === "create" ? theme.success : theme.accent;
+    return [[seg(`${event}  `, { color }), seg(String(fc.path ?? ""), { color: theme.text })]];
+}
 /** Multi-line formatted tool output for the feed panel. */
-export function formatToolResultLines(name, inputSummary, result, status, contentWidth, theme, expanded = true) {
+export function formatToolResultLines(rawName, inputSummary, rawResult, status, contentWidth, theme, expanded = true, rawInput) {
+    const name = canonicalToolName(rawName);
+    const real = displayToolName(rawName);
     if (!expanded)
         return [];
+    // Bound the text we lay out per render — a terminal can't show a 1MB result,
+    // and wrapping/parsing that much on every frame is what stalls the renderer.
+    // The full result stays in the stored feed; only what we format is capped.
+    const MAX_RENDER = 60_000;
+    const result = rawResult && rawResult.length > MAX_RENDER
+        ? `${rawResult.slice(0, MAX_RENDER)}\n\n… [${rawResult.length - MAX_RENDER} more chars not shown]`
+        : rawResult;
+    // Dedicated built-in tool rendering (diffs, checklists, …). Input-driven ones
+    // (Edit, Write, TodoWrite) render even while the tool is still running.
+    if (status !== "error") {
+        const builtin = formatBuiltinBody(real, rawInput, result ?? "", Math.max(16, contentWidth), theme);
+        if (builtin && builtin.length > 0) {
+            if (status === "running" && !result?.trim())
+                builtin.push([seg("running…", { dim: true, color: theme.textDim })]);
+            return builtin;
+        }
+    }
     const width = Math.max(16, contentWidth);
     const lines = [];
     const input = inputSummary.replace(/\s+/gu, " ").trim();

package/dist/ui/ink/lib/utils.js

@@ -1,29 +1,31 @@
 import { readFileSync } from "node:fs";
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { spawn } from "node:child_process";
+import * as Bun from "bun";
+import { mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { FULL_MODE_TRIGGERS } from "../constants.js";
 export const pkgVersion = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "../../../../package.json"), "utf8")).version;
 /** Pipe text to the OS clipboard (pbcopy / clip / xclip). Resolves false when unavailable. */
-export function copyToClipboard(text) {
-    return new Promise((res) => {
-        const cmd = process.platform === "darwin" ? "pbcopy" : process.platform === "win32" ? "clip" : "xclip";
-        const args = cmd === "xclip" ? ["-selection", "clipboard"] : [];
-        const child = spawn(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
-        child.on("error", () => res(false));
-        child.on("close", (code) => res(code === 0));
-        child.stdin.write(text);
-        child.stdin.end();
-    });
+export async function copyToClipboard(text) {
+    const cmd = process.platform === "darwin" ? "pbcopy" : process.platform === "win32" ? "clip" : "xclip";
+    const args = cmd === "xclip" ? ["-selection", "clipboard"] : [];
+    try {
+        const proc = Bun.spawn([cmd, ...args], { stdin: "pipe", stdout: "ignore", stderr: "ignore" });
+        proc.stdin.write(text);
+        await proc.stdin.end();
+        return (await proc.exited) === 0;
+    }
+    catch {
+        return false;
+    }
 }
 function historyFile(runDirectory) {
     return resolve(process.cwd(), runDirectory, "..", "input-history.json");
 }
 export async function loadInputHistory(runDirectory) {
     try {
-        const parsed = JSON.parse(await readFile(historyFile(runDirectory), "utf8"));
+        const parsed = await Bun.file(historyFile(runDirectory)).json();
         return Array.isArray(parsed) ? parsed.filter((x) => typeof x === "string").slice(-50) : [];
     }
     catch {
@@ -34,7 +36,7 @@ export async function saveInputHistory(runDirectory, history) {
     try {
         const file = historyFile(runDirectory);
         await mkdir(dirname(file), { recursive: true });
-        await writeFile(file, JSON.stringify(history.slice(-50), null, 2));
+        await Bun.write(file, JSON.stringify(history.slice(-50), null, 2));
     }
     catch { /* non-fatal */ }
 }
@@ -200,15 +202,17 @@ export function linkAtMouseColumn(links, x) {
     return undefined;
 }
 /** Open a URL in the system browser. */
-export function openExternalUrl(url) {
-    return new Promise((res) => {
-        const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
-        const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-        const child = spawn(cmd, args, { stdio: "ignore", detached: true });
-        child.on("error", () => res(false));
-        child.on("close", (code) => res(code === 0));
-        child.unref();
-    });
+export async function openExternalUrl(url) {
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+    try {
+        const proc = Bun.spawn([cmd, ...args], { stdout: "ignore", stderr: "ignore" });
+        proc.unref();
+        return (await proc.exited) === 0;
+    }
+    catch {
+        return false;
+    }
 }
 /** True if the prompt clearly asks for full, report-grade research. */
 export function wantsFullResearch(prompt) {
@@ -279,16 +283,32 @@ function toolOutputText(output) {
         return String(output);
     }
 }
-export function summarizeToolInput(name, input) {
+// Harness/CLI tool names mapped to Scira renderer keys. Kept local to avoid a
+// circular import with tool-result.ts (which imports from this file).
+const HARNESS_TOOL_PREFIX = "mcp__harness-tools__";
+const SUMMARY_CANONICAL = {
+    multiWebSearch: "webSearch",
+    Read: "readFile", Write: "writeFile", Edit: "editFile", MultiEdit: "editFile", NotebookEdit: "editFile",
+    Bash: "bash", BashOutput: "bash", shell: "bash",
+    Grep: "grepWorkspace", Glob: "listWorkspaceDir", LS: "listWorkspaceDir",
+    TodoWrite: "todo", WebFetch: "readUrl", WebSearch: "webSearch",
+};
+export function summarizeToolInput(rawName, input) {
+    const stripped = rawName.startsWith(HARNESS_TOOL_PREFIX) ? rawName.slice(HARNESS_TOOL_PREFIX.length) : rawName;
+    const name = SUMMARY_CANONICAL[stripped] ?? stripped;
     const obj = (input ?? {});
+    const path = obj.path ?? obj.file_path ?? obj.notebook_path;
     if (name === "bash" || name === "runBash" || name === "runWorkspaceCommand") {
         const action = obj.action;
         if (action && action !== "run")
             return `${action}${obj.taskId ? ` ${obj.taskId}` : ""}`;
         return String(obj.command ?? "");
     }
-    if (name === "todo")
+    if (name === "todo") {
+        if (Array.isArray(obj.todos))
+            return `${obj.todos.length} item(s)`;
         return `${String(obj.action ?? "list")}${obj.id ? ` ${obj.id}` : ""}`;
+    }
     if (name === "webSearch" || name === "xSearch") {
         const queries = Array.isArray(obj.queries) ? obj.queries : [];
         return queries.length > 0 ? queries.slice(0, 2).join(" · ") + (queries.length > 2 ? ` +${queries.length - 2}` : "") : String(obj.query ?? "");
@@ -296,14 +316,20 @@ export function summarizeToolInput(name, input) {
     if (name === "readUrl")
         return String(obj.url ?? "");
     if (name === "writeFile" || name === "editFile" || name === "readFile" || name === "readWorkspaceFile" || name === "writeWorkspaceFile" || name === "editWorkspaceFile") {
-        return String(obj.path ?? "");
+        return String(path ?? "");
     }
     if (name === "listWorkspaceDir" || name === "grepWorkspace")
-        return String(obj.path ?? obj.pattern ?? "");
+        return String(obj.pattern ?? path ?? "");
     if (name === "readSkill" || name === "listSkills")
-        return String(obj.name ?? "");
+        return String(obj.name ?? obj.skill ?? "");
     if (name === "createClaim" || name === "verifyClaim")
         return String(obj.id ?? "");
+    if (name === "fileChange")
+        return `${String(obj.event ?? "change")} ${String(obj.path ?? "")}`.trim();
+    if (stripped === "ToolSearch")
+        return String(obj.query ?? "");
+    if (stripped === "Task" || stripped === "Agent")
+        return String(obj.description ?? obj.subagent_type ?? "");
     try {
         return JSON.stringify(obj).slice(0, 80);
     }

package/dist/ui/ink/theme.js

@@ -1,5 +1,4 @@
 import { readFileSync, unwatchFile, watchFile } from "node:fs";
-import { execSync } from "node:child_process";
 import { homedir } from "node:os";
 import { join } from "node:path";
 export const DARK_THEME = {
@@ -124,11 +123,9 @@ function readEditorColorTheme() {
 function readSystemAppearance() {
     if (process.platform === "darwin") {
         try {
-            const style = execSync("defaults read -g AppleInterfaceStyle 2>/dev/null", {
-                encoding: "utf8",
-                stdio: ["ignore", "pipe", "ignore"],
-            }).trim();
-            return style === "Dark" ? "dark" : "light";
+            const r = Bun.spawnSync(["defaults", "read", "-g", "AppleInterfaceStyle"], { stdout: "pipe", stderr: "ignore" });
+            // The key is absent (and `defaults` exits non-zero) in light mode.
+            return r.stdout.toString().trim() === "Dark" ? "dark" : "light";
         }
         catch {
             return "light";
@@ -136,10 +133,8 @@ function readSystemAppearance() {
     }
     if (process.platform === "linux") {
         try {
-            const scheme = execSync("gsettings get org.gnome.desktop.interface color-scheme 2>/dev/null", {
-                encoding: "utf8",
-                stdio: ["ignore", "pipe", "ignore"],
-            }).trim();
+            const r = Bun.spawnSync(["gsettings", "get", "org.gnome.desktop.interface", "color-scheme"], { stdout: "pipe", stderr: "ignore" });
+            const scheme = r.stdout.toString().trim();
             if (/dark/i.test(scheme))
                 return "dark";
             if (/light/i.test(scheme))