@scira/cli 0.1.5 → 0.1.6

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",
@@ -291,7 +328,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 +383,171 @@ 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);
+        default:
+            return null;
+    }
+}
 /** 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,18 @@ 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 (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))

package/dist/watch/runner.js

@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { diffLines } from "diff";
 import { createRun, listRuns, getRunPaths } from "../storage/run-store.js";
-import { runResearchAgent } from "../agent/research-agent.js";
+import { runResearchAgent } from "../agent/main-agent.js";
 /** Compare two report.md texts and return a human-readable diff summary. */
 export function diffReports(prev, next) {
     const changes = diffLines(prev, next);
@@ -47,7 +47,7 @@ export async function watchLoop(opts, signal) {
         opts.onRunStart?.(runPath, tick);
         try {
             await runResearchAgent(runPath, goal, config);
-            const nextReport = await readFile(getRunPaths(runPath).report, "utf8").catch(() => "");
+            const nextReport = await Bun.file(getRunPaths(runPath).report).text().catch(() => "");
             const diffText = diffReports(prevReport, nextReport);
             opts.onRunComplete?.(runPath, diffText, tick);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scira/cli",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Scira — terminal-native AI research agent with grounded sources, verified claims, and local run storage.",
   "license": "MIT",
   "type": "module",
@@ -35,22 +35,26 @@
     "dev": "bun src/cli/index.ts",
     "docs:dev": "bun run --cwd docs dev",
     "docs:build": "NODE_ENV=production bun run --cwd docs build",
-    "test": "vitest run",
-    "test:watch": "vitest"
+    "test": "bun test src",
+    "test:watch": "bun test --watch src"
   },
   "dependencies": {
-    "@ai-sdk/mcp": "^1.0.49",
+    "@ai-sdk/harness": "^1.0.0-canary.9",
+    "@ai-sdk/harness-claude-code": "^1.0.0-canary.5",
+    "@ai-sdk/harness-codex": "^1.0.0-canary.5",
+    "@ai-sdk/mcp": "^1.0.50",
     "@ai-sdk/openai-compatible": "^2.0.50",
     "@ai-sdk/xai": "^3.0.95",
     "@clack/prompts": "^1.5.1",
-    "@mendable/firecrawl-js": "^4.25.3",
+    "@mendable/firecrawl-js": "^4.25.4",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@mozilla/readability": "^0.6.0",
-    "ai": "^6.0.203",
+    "ai": "^6.0.204",
+    "bun": "^1.3.14",
     "diff": "^9.0.0",
     "exa-js": "^2.13.0",
     "files-sdk": "^1.8.0",
-    "ink": "^7.0.5",
+    "ink": "^7.0.6",
     "ink-link": "^5.0.0",
     "jsdom": "^29.1.1",
     "parallel-web": "^1.1.0",
@@ -62,14 +66,12 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "bun-types": "^1.3.14",
+    "@types/bun": "^1.3.14",
     "@types/jsdom": "^28.0.3",
     "@types/node": "^25.9.3",
     "@types/react": "^19.2.17",
-    "@vitest/coverage-v8": "^4.1.8",
     "tsx": "^4.22.4",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.8"
+    "typescript": "^6.0.3"
   },
   "engines": {
     "bun": ">=1.2.0"

package/dist/agent/background-tasks.js

@@ -1,173 +0,0 @@
-import { spawn } from "node:child_process";
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
-const MAX_OUTPUT_LINES = 500;
-const MAX_TAIL_CHARS = 4000;
-function nextTaskId(existing) {
-    const nums = existing
-        .map((t) => /^task_(\d+)$/u.exec(t.id)?.[1])
-        .filter((n) => Boolean(n))
-        .map((n) => Number.parseInt(n, 10));
-    const next = nums.length > 0 ? Math.max(...nums) + 1 : 1;
-    return `task_${String(next).padStart(3, "0")}`;
-}
-function tailText(lines, maxChars = MAX_TAIL_CHARS) {
-    const joined = lines.join("\n");
-    if (joined.length <= maxChars)
-        return joined;
-    return `…[truncated]\n${joined.slice(-maxChars)}`;
-}
-export class BackgroundTaskManager {
-    persistPath;
-    defaultCwd;
-    runtime = new Map();
-    records = [];
-    loaded = false;
-    constructor(persistPath, defaultCwd) {
-        this.persistPath = persistPath;
-        this.defaultCwd = defaultCwd;
-    }
-    async ensureLoaded() {
-        if (this.loaded)
-            return;
-        this.loaded = true;
-        try {
-            const raw = await readFile(this.persistPath, "utf8");
-            const parsed = JSON.parse(raw);
-            if (Array.isArray(parsed)) {
-                this.records = parsed.filter((t) => typeof t === "object" && t !== null && typeof t.id === "string");
-            }
-        }
-        catch {
-            this.records = [];
-        }
-    }
-    async persist() {
-        await mkdir(dirname(this.persistPath), { recursive: true });
-        await writeFile(this.persistPath, JSON.stringify(this.records, null, 2) + "\n");
-    }
-    syncRecord(task) {
-        const idx = this.records.findIndex((r) => r.id === task.record.id);
-        task.record.outputTail = tailText(task.output);
-        if (idx === -1)
-            this.records.push({ ...task.record });
-        else
-            this.records[idx] = { ...task.record };
-    }
-    async spawn(command, cwd) {
-        await this.ensureLoaded();
-        const id = nextTaskId(this.records);
-        const workDir = cwd ?? this.defaultCwd;
-        const proc = spawn(command, {
-            cwd: workDir,
-            shell: "/bin/bash",
-            env: process.env,
-            detached: false,
-            stdio: ["ignore", "pipe", "pipe"]
-        });
-        const record = {
-            id,
-            command,
-            cwd: workDir,
-            pid: proc.pid ?? 0,
-            startedAt: new Date().toISOString(),
-            status: "running",
-            exitCode: null,
-            outputTail: ""
-        };
-        const output = [];
-        const append = (chunk) => {
-            const text = chunk.toString();
-            for (const line of text.split("\n")) {
-                if (line.length > 0)
-                    output.push(line);
-            }
-            while (output.length > MAX_OUTPUT_LINES)
-                output.shift();
-            const rt = this.runtime.get(id);
-            if (rt) {
-                rt.output = output;
-                rt.record.outputTail = tailText(output);
-            }
-        };
-        proc.stdout?.on("data", append);
-        proc.stderr?.on("data", append);
-        const runtime = { record, proc, output };
-        this.runtime.set(id, runtime);
-        this.records.push({ ...record });
-        await this.persist();
-        proc.on("close", (code) => {
-            record.status = "exited";
-            record.exitCode = code;
-            record.outputTail = tailText(output);
-            this.syncRecord(runtime);
-            void this.persist();
-            this.runtime.delete(id);
-        });
-        proc.on("error", (err) => {
-            output.push(`[spawn error] ${err.message}`);
-            record.status = "exited";
-            record.exitCode = 1;
-            record.outputTail = tailText(output);
-            this.syncRecord(runtime);
-            void this.persist();
-            this.runtime.delete(id);
-        });
-        return { ...record };
-    }
-    async list() {
-        await this.ensureLoaded();
-        for (const rt of this.runtime.values()) {
-            rt.record.outputTail = tailText(rt.output);
-            this.syncRecord(rt);
-        }
-        return this.records.map((r) => {
-            const live = this.runtime.get(r.id);
-            return live ? { ...live.record } : { ...r };
-        });
-    }
-    async getOutput(taskId, tailLines = 50) {
-        await this.ensureLoaded();
-        const live = this.runtime.get(taskId);
-        if (live) {
-            const lines = live.output.slice(-tailLines);
-            return lines.length > 0 ? lines.join("\n") : "(no output yet)";
-        }
-        const rec = this.records.find((r) => r.id === taskId);
-        if (!rec)
-            return `Task "${taskId}" not found.`;
-        const lines = rec.outputTail.split("\n").slice(-tailLines);
-        return lines.length > 0 ? lines.join("\n") : "(no output)";
-    }
-    async kill(taskId) {
-        await this.ensureLoaded();
-        const live = this.runtime.get(taskId);
-        if (live) {
-            live.proc.kill("SIGTERM");
-            live.record.status = "killed";
-            live.record.exitCode = live.record.exitCode ?? 143;
-            this.syncRecord(live);
-            await this.persist();
-            return `Killed ${taskId} (pid ${live.record.pid}).`;
-        }
-        const rec = this.records.find((r) => r.id === taskId);
-        if (!rec)
-            return `Task "${taskId}" not found.`;
-        if (rec.status !== "running")
-            return `${taskId} is already ${rec.status}.`;
-        rec.status = "killed";
-        await this.persist();
-        return `Marked ${taskId} as killed (process not tracked in this session).`;
-    }
-    async formatContextForAgent() {
-        const tasks = await this.list();
-        const active = tasks.filter((t) => t.status === "running");
-        if (active.length === 0)
-            return "";
-        const lines = active.map((t) => `  - ${t.id}: [running pid ${t.pid}] ${t.command} (cwd: ${t.cwd})`);
-        return `\nActive background tasks:\n${lines.join("\n")}\nUse bash with action "output" and taskId to read logs, or action "kill" to stop a task.\n`;
-    }
-}
-export function createBackgroundTaskManager(runPath, workspacePath) {
-    return new BackgroundTaskManager(join(runPath, "background-tasks.json"), workspacePath);
-}