@scira/cli 0.1.0 → 0.1.1

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

@@ -0,0 +1,319 @@
+import { markdownToSegLines } from "./markdown.js";
+import { wrapText } from "./utils.js";
+/** Tools that start collapsed in the timeline (long output). */
+export const DEFAULT_COLLAPSED_TOOLS = new Set([
+    "readUrl",
+    "readFile",
+    "readWorkspaceFile",
+    "readSkill",
+    "bash",
+    "runWorkspaceCommand",
+    "grepWorkspace",
+]);
+export function feedToolItemId(feedIndex, toolCallId) {
+    return toolCallId ?? `feed-${feedIndex}`;
+}
+export function isCollapsibleToolName(name) {
+    return name.length > 0;
+}
+export function defaultCollapsedToolName(name) {
+    return DEFAULT_COLLAPSED_TOOLS.has(name);
+}
+export function isToolItemCollapsed(id, name, status, expandState) {
+    if (status === "running" || !isCollapsibleToolName(name))
+        return false;
+    const override = expandState.get(id);
+    if (override === true)
+        return false;
+    if (override === false)
+        return true;
+    return defaultCollapsedToolName(name);
+}
+function seg(text, style = {}) {
+    return { text, ...style };
+}
+function blank() {
+    return [];
+}
+function plainLines(text, width, style = {}) {
+    return wrapText(text, width).map((line) => [seg(line, style)]);
+}
+function tryPrettyJson(text, width, theme) {
+    try {
+        const parsed = JSON.parse(text);
+        const pretty = JSON.stringify(parsed, null, 2);
+        return plainLines(pretty, width, { color: theme.textDim });
+    }
+    catch {
+        return null;
+    }
+}
+function dedupeSearchHits(groups) {
+    const seen = new Set();
+    const out = [];
+    for (const group of groups) {
+        for (const hit of group.results ?? []) {
+            const key = hit.url?.trim().toLowerCase() || `${hit.title ?? ""}:${hit.snippet ?? ""}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push(hit);
+        }
+    }
+    return out;
+}
+function mdLinkLabel(text) {
+    return text.replace(/\\/gu, "\\\\").replace(/\[/gu, "\\[").replace(/\]/gu, "\\]");
+}
+function searchHitToMarkdown(hit) {
+    const title = hit.title?.trim() || hit.url || "(no title)";
+    const url = hit.url?.trim() ?? "";
+    let block = url ? `- [${mdLinkLabel(title)}](${url})` : `- ${mdLinkLabel(title)}`;
+    if (hit.publishedDate)
+        block += ` — *${hit.publishedDate}*`;
+    if (hit.snippet) {
+        const snippet = hit.snippet.replace(/\s+/gu, " ").trim();
+        if (snippet)
+            block += `\n  *${snippet}*`;
+    }
+    return block;
+}
+function webSearchQueriesMarkdown(groups) {
+    const queries = groups.map((g) => g.query?.trim()).filter((q) => Boolean(q));
+    if (queries.length === 0)
+        return "";
+    return `## Queries\n\n${queries.map((q, i) => `${i + 1}. ${q}`).join("\n")}`;
+}
+function webSearchSourcesMarkdown(hits) {
+    if (hits.length === 0)
+        return "";
+    return `## Sources (${hits.length})\n\n${hits.map(searchHitToMarkdown).join("\n\n")}`;
+}
+function webSearchToMarkdown(groups) {
+    const queries = webSearchQueriesMarkdown(groups);
+    const sources = webSearchSourcesMarkdown(dedupeSearchHits(groups));
+    if (!queries && !sources)
+        return "";
+    if (!queries)
+        return sources;
+    if (!sources)
+        return queries;
+    return `${queries}\n\n${sources}`;
+}
+function parseInputQueries(input) {
+    return input
+        .split(" · ")
+        .map((part) => part.replace(/\s+\+\d+$/u, "").trim())
+        .filter(Boolean);
+}
+function webSearchRunningMarkdown(input) {
+    const queries = parseInputQueries(input);
+    if (queries.length === 0)
+        return `## Queries\n\n${input}`;
+    return `## Queries\n\n${queries.map((q, i) => `${i + 1}. ${q}`).join("\n")}`;
+}
+function formatWebSearch(result, width, theme) {
+    try {
+        const groups = JSON.parse(result);
+        if (!Array.isArray(groups))
+            return plainLines(result, width, { color: theme.textDim });
+        const md = webSearchToMarkdown(groups);
+        if (!md.trim())
+            return plainLines(result, width, { color: theme.textDim });
+        return markdownToSegLines(md, width, theme);
+    }
+    catch {
+        return plainLines(result, width, { color: theme.textDim });
+    }
+}
+function formatReadUrl(result, width, theme) {
+    const lines = [];
+    const titleMatch = result.match(/^#\s+(.+)/m);
+    const snapshotMatch = result.match(/\(snapshot saved to ([^)]+)\)/);
+    if (titleMatch?.[1]) {
+        lines.push([seg(titleMatch[1].trim(), { bold: true, color: theme.text })]);
+    }
+    if (snapshotMatch?.[1]) {
+        lines.push([
+            seg("saved ", { dim: true, color: theme.textDim }),
+            seg(snapshotMatch[1], { color: theme.accent }),
+        ]);
+    }
+    const bodyMarker = result.indexOf("\n\n");
+    const body = bodyMarker >= 0 ? result.slice(bodyMarker + 2).trim() : result.trim();
+    if (body) {
+        if (lines.length > 0)
+            lines.push(blank());
+        lines.push(...plainLines(body, width, { color: theme.textDim }));
+    }
+    return lines.length > 0 ? lines : plainLines(result, width, { color: theme.textDim });
+}
+function formatListSkills(result, width, theme) {
+    const rows = result.split("\n").map((l) => l.trim()).filter(Boolean);
+    if (rows.length === 0)
+        return [[seg("no skills", { dim: true, color: theme.textDim })]];
+    return rows.flatMap((row, idx) => {
+        const colon = row.indexOf(":");
+        const name = colon >= 0 ? row.slice(0, colon).trim() : row;
+        const desc = colon >= 0 ? row.slice(colon + 1).trim() : "";
+        const prefix = `${idx + 1}. `;
+        if (!desc) {
+            return [[seg(prefix, { dim: true, color: theme.textDim }), seg(name, { bold: true, color: theme.text })]];
+        }
+        const out = [[
+                seg(prefix, { dim: true, color: theme.textDim }),
+                seg(name, { bold: true, color: theme.text }),
+                seg(": ", { color: theme.textDim }),
+            ]];
+        for (const part of wrapText(desc, width - prefix.length - name.length - 2)) {
+            out.push([seg("   ", {}), seg(part, { color: theme.textDim })]);
+        }
+        return out;
+    });
+}
+function formatShellOutput(result, width, theme) {
+    if (!result.trim())
+        return [[seg("(no output)", { dim: true, color: theme.textDim })]];
+    return result.split("\n").flatMap((line) => plainLines(line, width, { color: theme.textDim }));
+}
+function formatFileContent(result, width, theme) {
+    const rows = result.split("\n");
+    const numbered = rows.map((line, i) => {
+        const n = String(i + 1).padStart(String(rows.length).length, " ");
+        return `${n} │ ${line}`;
+    });
+    return numbered.flatMap((line) => plainLines(line, width, { color: theme.textDim }));
+}
+function formatGrep(result, width, theme) {
+    const rows = result.split("\n").filter((l) => l.trim());
+    if (rows.length === 0)
+        return [[seg("no matches", { dim: true, color: theme.textDim })]];
+    return rows.flatMap((row) => {
+        const colon = row.indexOf(":");
+        if (colon > 0) {
+            return [[
+                    seg(row.slice(0, colon + 1), { color: theme.accent }),
+                    seg(row.slice(colon + 1), { color: theme.textDim }),
+                ]];
+        }
+        return plainLines(row, width, { color: theme.textDim });
+    });
+}
+function formatBody(name, result, width, theme) {
+    switch (name) {
+        case "webSearch":
+            return formatWebSearch(result, width, theme);
+        case "readUrl":
+            return formatReadUrl(result, width, theme);
+        case "listSkills":
+            return formatListSkills(result, width, theme);
+        case "bash":
+        case "runWorkspaceCommand":
+            return formatShellOutput(result, width, theme);
+        case "readFile":
+        case "readWorkspaceFile":
+            return formatFileContent(result, width, theme);
+        case "grepWorkspace":
+            return formatGrep(result, width, theme);
+        case "writeFile":
+        case "writeWorkspaceFile":
+        case "editFile":
+        case "editWorkspaceFile":
+        case "createClaim":
+        case "verifyClaim":
+        case "requestFullResearch":
+        case "readSkill":
+            return plainLines(result, width, { color: theme.text });
+        default: {
+            const json = tryPrettyJson(result, width, theme);
+            return json ?? plainLines(result, width, { color: theme.textDim });
+        }
+    }
+}
+/** One-line preview for a collapsed tool header. */
+export function formatToolResultPreview(name, inputSummary, result, status) {
+    const input = inputSummary.replace(/\s+/gu, " ").trim();
+    if (status === "running")
+        return input ? `${input} · running…` : "running…";
+    if (status === "error")
+        return input || "failed";
+    if (!result?.trim())
+        return input || "done";
+    if (name === "readUrl") {
+        const titleMatch = result.match(/^#\s+(.+)/m);
+        const snapshotMatch = result.match(/\(snapshot saved to ([^)]+)\)/);
+        const title = titleMatch?.[1]?.trim();
+        const snap = snapshotMatch?.[1];
+        if (title && snap)
+            return `${title} · ${snap}`;
+        if (title)
+            return title;
+        return input || (result.split("\n")[0]?.slice(0, 120) ?? "page loaded");
+    }
+    if (name === "webSearch") {
+        try {
+            const groups = JSON.parse(result);
+            if (Array.isArray(groups)) {
+                const queries = groups.map((g) => g.query?.trim()).filter(Boolean);
+                const total = dedupeSearchHits(groups).length;
+                const q = queries.length > 0 ? queries.slice(0, 2).join(" · ") + (queries.length > 2 ? ` +${queries.length - 2}` : "") : input;
+                return q ? `${q} · ${total} sources` : `${total} sources`;
+            }
+        }
+        catch { /* fall through */ }
+    }
+    if (name === "readFile" || name === "readWorkspaceFile") {
+        const lines = result.split("\n").length;
+        return input ? `${input} · ${lines} lines` : `${lines} lines`;
+    }
+    if (name === "bash" || name === "runWorkspaceCommand") {
+        const tail = result.split("\n").filter((l) => l.trim()).slice(-1)[0] ?? "";
+        return input ? `$ ${input}` : tail.slice(0, 100) || "done";
+    }
+    const first = result.replace(/\s+/gu, " ").trim();
+    return first.length > 140 ? `${first.slice(0, 137)}…` : first;
+}
+/** Multi-line formatted tool output for the feed panel. */
+export function formatToolResultLines(name, inputSummary, result, status, contentWidth, theme, expanded = true) {
+    if (!expanded)
+        return [];
+    const width = Math.max(16, contentWidth);
+    const lines = [];
+    const input = inputSummary.replace(/\s+/gu, " ").trim();
+    const skipInput = name === "webSearch" && status === "done" && Boolean(result?.trim());
+    if (input && !skipInput) {
+        if (name === "bash" || name === "runWorkspaceCommand") {
+            lines.push([seg("$ ", { color: theme.accent }), seg(input, { color: theme.text })]);
+        }
+        else if (name === "webSearch") {
+            lines.push(...markdownToSegLines(webSearchRunningMarkdown(input), width, theme));
+        }
+        else if (name === "readUrl") {
+            lines.push([seg("url  ", { dim: true, color: theme.textDim }), seg(input, { color: theme.accent, underline: true, url: input })]);
+        }
+        else if (name === "readFile" || name === "readWorkspaceFile" || name === "writeFile" || name === "writeWorkspaceFile" || name === "editFile" || name === "editWorkspaceFile") {
+            lines.push([seg("path  ", { dim: true, color: theme.textDim }), seg(input, { color: theme.text })]);
+        }
+        else {
+            lines.push([seg(input, { color: theme.textDim })]);
+        }
+    }
+    if (status === "running") {
+        lines.push([seg("running…", { dim: true, color: theme.textDim })]);
+        return lines;
+    }
+    if (!result?.trim()) {
+        lines.push([seg(status === "error" ? "failed" : "done", { dim: true, color: theme.textDim })]);
+        return lines;
+    }
+    if (status === "error") {
+        if (lines.length > 0)
+            lines.push(blank());
+        lines.push(...plainLines(result, width, { color: theme.error }));
+        return lines;
+    }
+    if (lines.length > 0)
+        lines.push(blank());
+    lines.push(...formatBody(name, result, width, theme));
+    return lines;
+}

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

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { DARK_THEME } from "../theme.js";
+import { formatToolResultLines, formatToolResultPreview, isToolItemCollapsed, defaultCollapsedToolName, } from "./tool-result.js";
+function textOf(lines) {
+    return lines.map((row) => row.map((s) => s.text).join("")).join("\n");
+}
+describe("formatToolResultLines", () => {
+    it("shows queries then a flat sources list", () => {
+        const result = JSON.stringify([
+            {
+                query: "ai news",
+                results: [
+                    { title: "Alpha", url: "https://a.com", snippet: "First hit snippet." },
+                    { title: "Beta", url: "https://b.com", snippet: "Second hit snippet." },
+                ],
+            },
+            {
+                query: "ai frameworks",
+                results: [
+                    { title: "Alpha", url: "https://a.com", snippet: "Duplicate should drop." },
+                    { title: "Gamma", url: "https://c.com", snippet: "Third hit snippet." },
+                ],
+            },
+        ]);
+        const out = textOf(formatToolResultLines("webSearch", "ai news · ai frameworks", result, "done", 80, DARK_THEME));
+        expect(out.indexOf("Queries")).toBeLessThan(out.indexOf("Sources"));
+        expect(out).toContain("ai news");
+        expect(out).toContain("ai frameworks");
+        expect(out).toContain("Sources (3)");
+        expect(out).toContain("Alpha");
+        expect(out).toContain("First hit snippet.");
+        expect(out).toContain("Gamma");
+        expect(out).not.toContain("Duplicate should drop");
+    });
+    it("shows shell command and full output", () => {
+        const out = textOf(formatToolResultLines("bash", "ls -la", "total 0\nfile.txt", "done", 80, DARK_THEME));
+        expect(out).toContain("$ ls -la");
+        expect(out).toContain("total 0");
+        expect(out).toContain("file.txt");
+    });
+    it("shows readUrl title and body when expanded", () => {
+        const result = "# Example\n(snapshot saved to snapshots/example.md)\n\nBody paragraph here.";
+        const out = textOf(formatToolResultLines("readUrl", "https://example.com", result, "done", 80, DARK_THEME, true));
+        expect(out).toContain("Example");
+        expect(out).toContain("snapshots/example.md");
+        expect(out).toContain("Body paragraph here.");
+    });
+    it("hides readUrl body when collapsed", () => {
+        const result = "# Example\n(snapshot saved to snapshots/example.md)\n\nBody paragraph here.";
+        expect(formatToolResultLines("readUrl", "https://example.com", result, "done", 80, DARK_THEME, false)).toEqual([]);
+        expect(formatToolResultPreview("readUrl", "https://example.com", result, "done")).toContain("Example");
+    });
+    it("defaults readUrl collapsed and webSearch expanded", () => {
+        expect(defaultCollapsedToolName("readUrl")).toBe(true);
+        expect(defaultCollapsedToolName("webSearch")).toBe(false);
+        expect(isToolItemCollapsed("id", "readUrl", "done", new Map())).toBe(true);
+        expect(isToolItemCollapsed("id", "webSearch", "done", new Map())).toBe(false);
+        expect(isToolItemCollapsed("id", "readUrl", "done", new Map([["id", true]]))).toBe(false);
+    });
+});

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

@@ -4,7 +4,6 @@ import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import stringWidth from "string-width";
 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. */
@@ -53,16 +52,16 @@ export function prettifyModelId(id) {
 }
 /** Terminal-cell width of a string (CJK/emoji aware, strips ANSI). */
 export function displayWidth(text) {
-    return stringWidth(text);
+    return Bun.stringWidth(text);
 }
 /** Longest prefix of `text` whose terminal-cell width fits in `width`; returns its char length. */
 function fitChars(text, width) {
-    if (stringWidth(text) === text.length)
+    if (Bun.stringWidth(text) === text.length)
         return Math.min(text.length, width);
     let cells = 0;
     let chars = 0;
     for (const ch of text) {
-        const w = stringWidth(ch);
+        const w = Bun.stringWidth(ch);
         if (cells + w > width)
             break;
         cells += w;
@@ -203,9 +202,24 @@ export function aggregateTurns(turns) {
     }
     return { total, byModel, turns };
 }
+function oneLine(text, max) {
+    return text.replace(/\s+/gu, " ").trim().slice(0, max);
+}
+function toolOutputText(output) {
+    if (output == null)
+        return "";
+    if (typeof output === "string")
+        return output;
+    try {
+        return JSON.stringify(output);
+    }
+    catch {
+        return String(output);
+    }
+}
 export function summarizeToolInput(name, input) {
     const obj = (input ?? {});
-    if (name === "bash")
+    if (name === "bash" || name === "runWorkspaceCommand")
         return String(obj.command ?? "");
     if (name === "webSearch") {
         const queries = Array.isArray(obj.queries) ? obj.queries : [];
@@ -213,8 +227,15 @@ export function summarizeToolInput(name, input) {
     }
     if (name === "readUrl")
         return String(obj.url ?? "");
-    if (name === "writeFile" || name === "editFile" || name === "readFile")
+    if (name === "writeFile" || name === "editFile" || name === "readFile" || name === "readWorkspaceFile" || name === "writeWorkspaceFile" || name === "editWorkspaceFile") {
         return String(obj.path ?? "");
+    }
+    if (name === "listWorkspaceDir" || name === "grepWorkspace")
+        return String(obj.path ?? obj.pattern ?? "");
+    if (name === "readSkill" || name === "listSkills")
+        return String(obj.name ?? "");
+    if (name === "createClaim" || name === "verifyClaim")
+        return String(obj.id ?? "");
     try {
         return JSON.stringify(obj).slice(0, 80);
     }
@@ -222,3 +243,64 @@ export function summarizeToolInput(name, input) {
         return "";
     }
 }
+/** Short one-line summary of a completed tool's output for the feed. */
+export function summarizeToolOutput(name, output) {
+    const text = toolOutputText(output);
+    if (name === "webSearch") {
+        try {
+            const parsed = JSON.parse(text);
+            if (Array.isArray(parsed)) {
+                const total = parsed.reduce((n, s) => n + (s.results?.length ?? 0), 0);
+                const titles = parsed
+                    .flatMap((s) => (s.results ?? []).slice(0, 2).map((r) => r.title?.trim()).filter(Boolean))
+                    .slice(0, 3);
+                const head = total > 0 ? `${total} result${total === 1 ? "" : "s"}` : "no results";
+                return titles.length > 0 ? `${head} · ${titles.join(" · ")}` : head;
+            }
+        }
+        catch { /* fall through */ }
+    }
+    if (name === "readUrl") {
+        const titleMatch = text.match(/^#\s+(.+)/m);
+        if (titleMatch?.[1])
+            return titleMatch[1].trim();
+        const snapshot = text.match(/\(snapshot saved to ([^)]+)\)/);
+        if (snapshot?.[1])
+            return `snapshot ${snapshot[1]}`;
+        return oneLine(text, 160);
+    }
+    if (name === "listSkills") {
+        const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);
+        if (lines.length === 0)
+            return "no skills";
+        const preview = lines.slice(0, 2).map((l) => l.split(":")[0]?.trim() || l).join(", ");
+        return `${lines.length} skill${lines.length === 1 ? "" : "s"} · ${preview}${lines.length > 2 ? ", …" : ""}`;
+    }
+    if (name === "readFile" || name === "readWorkspaceFile") {
+        const lineCount = text.split("\n").length;
+        const preview = oneLine(text.split("\n")[0] ?? "", 60);
+        return `${lineCount} line${lineCount === 1 ? "" : "s"}${preview ? ` · ${preview}` : ""}`;
+    }
+    if (name === "writeFile" || name === "writeWorkspaceFile" || name === "editFile" || name === "editWorkspaceFile") {
+        return oneLine(text, 120) || "ok";
+    }
+    if (name === "bash" || name === "runWorkspaceCommand") {
+        const lines = text.split("\n").filter((l) => l.trim());
+        if (lines.length === 0)
+            return "done";
+        return lines.slice(-3).map((l) => oneLine(l, 80)).join(" · ").slice(0, 200);
+    }
+    if (name === "listWorkspaceDir") {
+        const lines = text.split("\n").filter((l) => l.trim());
+        const preview = lines.slice(0, 3).map((l) => oneLine(l, 40)).join(", ");
+        const head = `${lines.length} entr${lines.length === 1 ? "y" : "ies"}`;
+        return preview ? `${head} · ${preview}${lines.length > 3 ? ", …" : ""}` : head;
+    }
+    if (name === "grepWorkspace") {
+        const lines = text.split("\n").filter((l) => l.trim());
+        if (lines.length === 0)
+            return "no matches";
+        return `${lines.length} match${lines.length === 1 ? "" : "es"} · ${oneLine(lines[0], 80)}`;
+    }
+    return oneLine(text, 200);
+}

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

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { summarizeToolInput, summarizeToolOutput } from "./utils.js";
+describe("summarizeToolInput", () => {
+    it("formats webSearch queries", () => {
+        expect(summarizeToolInput("webSearch", { queries: ["a", "b", "c"] })).toBe("a · b +1");
+    });
+    it("formats readUrl url", () => {
+        expect(summarizeToolInput("readUrl", { url: "https://example.com" })).toBe("https://example.com");
+    });
+});
+describe("summarizeToolOutput", () => {
+    it("summarizes webSearch json results", () => {
+        const output = JSON.stringify([
+            { query: "q1", results: [{ title: "Alpha" }, { title: "Beta" }] },
+            { query: "q2", results: [{ title: "Gamma" }] },
+        ]);
+        expect(summarizeToolOutput("webSearch", output)).toBe("3 results · Alpha · Beta · Gamma");
+    });
+    it("extracts readUrl page title", () => {
+        const output = "# Example Page\n(snapshot saved to snapshots/example.md)\n\nBody text";
+        expect(summarizeToolOutput("readUrl", output)).toBe("Example Page");
+    });
+    it("summarizes listSkills output", () => {
+        const output = "plan: Write a research plan\nsources: Gather sources";
+        expect(summarizeToolOutput("listSkills", output)).toBe("2 skills · plan, sources");
+    });
+    it("passes through predetermined string results", () => {
+        expect(summarizeToolOutput("requestFullResearch", "Approved. Stop now and do not call more tools."))
+            .toBe("Approved. Stop now and do not call more tools.");
+    });
+});

package/dist/ui/ink/session-manager.js

@@ -42,6 +42,38 @@ export function abortSession(runPath) {
 export function removeSession(runPath) {
     sessions.delete(runPath);
 }
+/** Merge full tool results from the session buffer into a feed snapshot before persisting. */
+export function mergeFeedToolResults(feed, buffer) {
+    const toolById = new Map();
+    for (const item of buffer) {
+        if (item.kind === "tool" && item.toolCallId && item.result) {
+            toolById.set(item.toolCallId, item);
+        }
+    }
+    if (toolById.size === 0)
+        return feed;
+    return feed.map((item) => {
+        if (item.kind !== "tool" || !item.toolCallId)
+            return item;
+        const buffered = toolById.get(item.toolCallId);
+        if (!buffered?.result)
+            return item;
+        const keepLonger = !item.result || buffered.result.length >= item.result.length;
+        if (!keepLonger && item.status !== "running")
+            return item;
+        return {
+            ...item,
+            status: buffered.status,
+            result: keepLonger ? buffered.result : item.result,
+            summary: item.summary || buffered.summary,
+            name: item.name || buffered.name,
+        };
+    });
+}
+export function getSessionFeedBuffer(runPath) {
+    const session = sessions.get(runPath);
+    return session ? [...session.feedBuffer] : [];
+}
 /** Route a feed item to the correct subscriber method and buffer it. */
 export function sessionPushFeed(runPath, item) {
     const session = sessions.get(runPath);
@@ -74,12 +106,14 @@ export function sessionPushFeed(runPath, item) {
             return;
         }
         if (item.kind === "tool" && (item.status === "done" || item.status === "error") && item.toolCallId) {
-            sub.markToolDone(item.toolCallId, item.status, item.result);
-            // Update existing tool item in buffer
+            const resultText = item.result;
+            if (!resultText)
+                return;
+            sub.markToolDone(item.toolCallId, item.status, resultText);
             for (let i = session.feedBuffer.length - 1; i >= 0; i--) {
                 const b = session.feedBuffer[i];
                 if (b.kind === "tool" && b.status === "running" && (b.toolCallId === item.toolCallId || !item.toolCallId)) {
-                    session.feedBuffer[i] = { ...b, status: item.status, result: item.result };
+                    session.feedBuffer[i] = { ...b, status: item.status, result: resultText };
                     break;
                 }
             }
@@ -89,10 +123,13 @@ export function sessionPushFeed(runPath, item) {
     }
     // No subscriber — always buffer
     if (item.kind === "tool" && (item.status === "done" || item.status === "error") && item.toolCallId) {
+        const resultText = item.result;
+        if (!resultText)
+            return;
         for (let i = session.feedBuffer.length - 1; i >= 0; i--) {
             const b = session.feedBuffer[i];
             if (b.kind === "tool" && b.status === "running" && (b.toolCallId === item.toolCallId || !item.toolCallId)) {
-                session.feedBuffer[i] = { ...b, status: item.status, result: item.result };
+                session.feedBuffer[i] = { ...b, status: item.status, result: resultText };
                 return;
             }
         }

package/dist/ui/ink/session-manager.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { mergeFeedToolResults } from "./session-manager.js";
+describe("mergeFeedToolResults", () => {
+    it("replaces truncated tool results with full buffer copies", () => {
+        const feed = [
+            {
+                kind: "tool",
+                name: "webSearch",
+                toolCallId: "call-1",
+                summary: "query a",
+                status: "done",
+                result: "truncated…",
+            },
+        ];
+        const buffer = [
+            {
+                kind: "tool",
+                name: "webSearch",
+                toolCallId: "call-1",
+                summary: "query a",
+                status: "done",
+                result: "x".repeat(5000),
+            },
+        ];
+        const merged = mergeFeedToolResults(feed, buffer);
+        expect(merged[0].kind).toBe("tool");
+        if (merged[0].kind === "tool") {
+            expect(merged[0].result).toHaveLength(5000);
+        }
+    });
+});