@baique/pi-web-sky 0.1.35 → 0.1.37

package/lib/terminal-manager.ts

@@ -0,0 +1,245 @@
+import { randomUUID, randomBytes } from "crypto";
+import type { IPty } from "@lydell/node-pty";
+
+type IPtyModule = typeof import("@lydell/node-pty");
+
+// ============================================================================
+// Terminal session registry — server-side keepalive terminals.
+// Sessions outlive browser refreshes: pty output is kept in a ring buffer and
+// replayed by byte offset when a client re-attaches (SSE ?since=<offset>).
+// Registry lives on globalThis so Next.js hot-reload doesn't kill running
+// shells (same pattern as the agent session registry in rpc-manager.ts).
+// ============================================================================
+
+const RING_BUFFER_BYTES = 256 * 1024;
+export const MAX_TERMINALS = 12;
+
+export interface TerminalSessionMeta {
+  id: string;
+  /** 展示用名称：默认 `<cwd basename>-<4位随机nanoid>`，创建时生成、持久稳定，用于区分同项目多终端。 */
+  name: string;
+  cwd: string;
+  projectRoot: string | null;
+  projectLabel: string;
+  cols: number;
+  rows: number;
+  running: boolean;
+  exitCode: number | null;
+  createdAt: number;
+}
+
+/** URL 安全字母表上的 4 位随机串（近似 nanoid 的短 id）。 */
+const ID4_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+export function randomId4(): string {
+  const bytes = randomBytes(4);
+  let out = "";
+  for (let i = 0; i < 4; i++) out += ID4_ALPHABET[bytes[i] % ID4_ALPHABET.length];
+  return out;
+}
+
+interface TerminalSession extends TerminalSessionMeta {
+  pty: IPty | null; // null once exited
+  buffer: string; // ring buffer of recent output
+  /** Monotonic offset = total bytes ever written minus buffer.length. */
+  baseOffset: number;
+  listeners: Set<(chunk: string) => void>;
+}
+
+type Registry = {
+  sessions: Map<string, TerminalSession>;
+};
+
+function registry(): Registry {
+  const g = globalThis as typeof globalThis & { __piTerminals?: Registry };
+  if (!g.__piTerminals) g.__piTerminals = { sessions: new Map() };
+  return g.__piTerminals;
+}
+
+/**
+ * Drop the excess prefix of a ring buffer, cutting just after the last
+ * newline at/at-before the overflow point. Replays start from the buffer
+ * head, so a byte-granular cut can land inside a multi-byte char or an ANSI
+ * escape sequence — xterm does NOT tolerate that (garbage chars at the top
+ * of the terminal after a re-attach). Falls back to the plain cut when the
+ * overflow lands in a newline-free run (no way to align; rare and benign).
+ * Returns [kept, droppedBytes].
+ */
+export function trimRingBuffer(buffer: string, maxBytes: number): [string, number] {
+  if (buffer.length <= maxBytes) return [buffer, 0];
+  let drop = buffer.length - maxBytes;
+  const nl = buffer.lastIndexOf("\n", drop);
+  if (nl >= 0) drop = nl + 1;
+  return [buffer.slice(drop), drop];
+}
+
+/** Append output to the ring buffer and fan out to live SSE listeners. */
+function pushOutput(s: TerminalSession, data: string) {
+  s.buffer += data;
+  if (s.buffer.length > RING_BUFFER_BYTES) {
+    const [kept, dropped] = trimRingBuffer(s.buffer, RING_BUFFER_BYTES);
+    s.buffer = kept;
+    s.baseOffset += dropped;
+  }
+  for (const fn of s.listeners) fn(data);
+}
+
+/**
+ * Bytes buffered starting from `since`; null when the offset has fallen out
+ * of the ring buffer (caller should fall back to fullBuffer()).
+ */
+export function outputSince(id: string, since: number): string | null {
+  const s = registry().sessions.get(id);
+  if (!s) return null;
+  const bufStart = s.baseOffset;
+  if (since < bufStart) return null;
+  return s.buffer.slice(Math.max(0, since - bufStart));
+}
+
+/** Entire ring buffer with its absolute start offset. */
+export function fullBuffer(id: string): { data: string; startOffset: number } | null {
+  const s = registry().sessions.get(id);
+  if (!s) return null;
+  return { data: s.buffer, startOffset: s.baseOffset };
+}
+
+function toMeta(s: TerminalSession): TerminalSessionMeta {
+  return {
+    id: s.id, name: s.name, cwd: s.cwd, projectRoot: s.projectRoot, projectLabel: s.projectLabel,
+    cols: s.cols, rows: s.rows, running: s.running, exitCode: s.exitCode,
+    createdAt: s.createdAt,
+  };
+}
+
+export function listTerminals(): TerminalSessionMeta[] {
+  return [...registry().sessions.values()].map(toMeta);
+}
+
+export function getTerminal(id: string): TerminalSessionMeta | undefined {
+  const s = registry().sessions.get(id);
+  return s ? toMeta(s) : undefined;
+}
+
+export function currentOffset(id: string): number {
+  const s = registry().sessions.get(id);
+  return s ? s.baseOffset + s.buffer.length : 0;
+}
+
+export async function createTerminal(opts: {
+  cwd: string;
+  projectRoot: string | null;
+  projectLabel: string;
+  cols?: number;
+  rows?: number;
+}): Promise<TerminalSessionMeta> {
+  const sessions = registry().sessions;
+
+  // Cap total sessions; reclaim exited ones first (oldest exit first).
+  if (sessions.size >= MAX_TERMINALS) {
+    const exited = [...sessions.values()]
+      .filter((s) => !s.running)
+      .sort((a, b) => a.createdAt - b.createdAt);
+    const victim = exited[0];
+    if (!victim) throw new Error(`Terminal limit reached (${MAX_TERMINALS})`);
+    removeTerminal(victim.id);
+  }
+
+  const cols = opts.cols ?? 80;
+  const rows = opts.rows ?? 24;
+  const shell = process.platform === "win32" ? "powershell.exe" : process.env.SHELL || "bash";
+  const args = process.platform === "win32" || process.env.SHELL?.endsWith("fish") ? [] : ["-l"];
+
+  // Webpack bundles external packages as plain CJS require()s, so the ESM
+  // interop `default` can be missing in the production build — fall back to
+  // the module object itself (dev keeps `default`, node-pty exports both).
+  const ptyMod = (await import("@lydell/node-pty")) as { default?: IPtyModule };
+  const pty = (ptyMod.default ?? ptyMod) as IPtyModule;
+  const proc = pty.spawn(shell, args, {
+    name: "xterm-256color",
+    cwd: opts.cwd,
+    cols,
+    rows,
+    env: process.env as Record<string, string>,
+  });
+
+  const id = randomUUID();
+  const base = opts.cwd.split(/[\\/]/).filter(Boolean).pop() || "term";
+  const session: TerminalSession = {
+    id,
+    name: `${base}-${randomId4()}`,
+    cwd: opts.cwd,
+    projectRoot: opts.projectRoot,
+    projectLabel: opts.projectLabel,
+    cols,
+    rows,
+    running: true,
+    exitCode: null,
+    createdAt: Date.now(),
+    pty: proc,
+    buffer: "",
+    baseOffset: 0,
+    listeners: new Set(),
+  };
+  proc.onData((data) => pushOutput(session, data));
+  proc.onExit(({ exitCode }) => {
+    session.running = false;
+    session.exitCode = exitCode;
+    session.pty = null;
+    pushOutput(session, `\r\n\x1b[2m[进程已退出，exit code ${exitCode}]\x1b[0m\r\n`);
+  });
+  sessions.set(id, session);
+  return getTerminal(id)!;
+}
+
+export function writeTerminal(id: string, data: string): boolean {
+  const s = registry().sessions.get(id);
+  if (!s?.pty) return false;
+  s.pty.write(data);
+  return true;
+}
+
+export function resizeTerminal(id: string, cols: number, rows: number): boolean {
+  const s = registry().sessions.get(id);
+  if (!s) return false;
+  s.cols = cols;
+  s.rows = rows;
+  try {
+    s.pty?.resize(cols, rows);
+  } catch {
+    // resize after exit races onExit; harmless.
+  }
+  return true;
+}
+
+/** Kill the process. Output stays inspectable until removeTerminal(). */
+export function killTerminal(id: string): boolean {
+  const s = registry().sessions.get(id);
+  if (!s) return false;
+  if (s.pty) {
+    try {
+      s.pty.kill();
+    } catch {
+      // already dead
+    }
+  }
+  return true;
+}
+
+export function removeTerminal(id: string): boolean {
+  const s = registry().sessions.get(id);
+  if (!s) return false;
+  killTerminal(id);
+  for (const fn of s.listeners) fn(""); // release SSE streams
+  s.listeners.clear();
+  return registry().sessions.delete(id);
+}
+
+export function addListener(id: string, fn: (chunk: string) => void): boolean {
+  const s = registry().sessions.get(id);
+  if (!s) return false;
+  s.listeners.add(fn);
+  return true;
+}
+
+export function removeListener(id: string, fn: (chunk: string) => void): void {
+  registry().sessions.get(id)?.listeners.delete(fn);
+}

package/lib/tool-execution-progress.test.mjs

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const { getToolExecutionProgress } = await jiti.import("./tool-execution-progress.ts");
+
+test("uses the latest non-empty text line from a partial tool result", () => {
+  assert.equal(getToolExecutionProgress({
+    content: [
+      { type: "text", text: "Phase 1 complete\n" },
+      { type: "image", data: "ignored" },
+      { type: "text", text: "\nProcessing item 4 of 10\n" },
+    ],
+  }), "Processing item 4 of 10");
+});
+
+test("ignores partial tool results without displayable text", () => {
+  assert.equal(getToolExecutionProgress(null), null);
+  assert.equal(getToolExecutionProgress({ content: [{ type: "image" }] }), null);
+  assert.equal(getToolExecutionProgress({ content: [{ type: "text", text: "  \n" }] }), null);
+});
+
+test("bounds long progress lines while preserving the latest text", () => {
+  const progress = getToolExecutionProgress({
+    content: [{ type: "text", text: `prefix-${"x".repeat(600)}-latest` }],
+  });
+
+  assert.equal(progress.length, 500);
+  assert.match(progress, /^\.\.\./);
+  assert.match(progress, /-latest$/);
+});

package/lib/tool-execution-progress.ts

@@ -0,0 +1,29 @@
+const MAX_PROGRESS_LENGTH = 500;
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function getToolExecutionProgress(partialResult: unknown): string | null {
+  if (!isObject(partialResult)) return null;
+
+  const content = partialResult.content;
+  if (!Array.isArray(content)) return null;
+
+  const text = content
+    .filter((block) => isObject(block) && block.type === "text" && typeof block.text === "string")
+    .map((block) => block.text as string)
+    .join("\n");
+  const lines = text.split(/\r?\n/);
+  let latest = "";
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    latest = lines[index].trim();
+    if (latest) break;
+  }
+  if (!latest) return null;
+
+  const normalized = latest.replace(/\s+/g, " ");
+  return normalized.length <= MAX_PROGRESS_LENGTH
+    ? normalized
+    : `...${normalized.slice(-(MAX_PROGRESS_LENGTH - 3))}`;
+}

package/lib/tool-names.ts

@@ -0,0 +1,25 @@
+/**
+ * Tool-name predicates shared by the chat views.
+ *
+ * Pi's built-in names are plain `write` / `edit`, but MCP servers expose the
+ * same operations under prefixed or namespaced names, so each predicate also
+ * accepts the common decorated forms.
+ */
+
+export function isWriteToolName(toolName: string): boolean {
+  const name = toolName.toLowerCase();
+  return name === "write" ||
+    name.startsWith("write_") ||
+    name.endsWith(".write") ||
+    name.endsWith("_write");
+}
+
+export function isEditToolName(toolName: string): boolean {
+  const name = toolName.toLowerCase();
+  return name === "edit" ||
+    name.startsWith("edit_") ||
+    name.endsWith(".edit") ||
+    name.endsWith("_edit") ||
+    name.includes("str_replace") ||
+    name.includes("replace_editor");
+}

package/lib/tool-preset-preference.test.mjs

@@ -0,0 +1,72 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const {
+  getPreferredToolPreset,
+  setPreferredToolPreset,
+} = await jiti.import("./tool-preset-preference.ts");
+const { TOOL_PRESET_VALUES } = await jiti.import("./tool-presets.ts");
+
+function createStorage(initial = {}) {
+  const values = new Map(Object.entries(initial));
+  return {
+    values,
+    getItem(key) {
+      return values.get(key) ?? null;
+    },
+    setItem(key, value) {
+      values.set(key, value);
+    },
+  };
+}
+
+test("defaults missing or invalid preferences to the default preset", () => {
+  assert.equal(getPreferredToolPreset(createStorage()), "default");
+  assert.equal(
+    getPreferredToolPreset(createStorage({ "pi-tool-preset": "legacy-value" })),
+    "default",
+  );
+});
+
+test("round-trips every supported tool preset", () => {
+  const storage = createStorage();
+  for (const preset of TOOL_PRESET_VALUES) {
+    setPreferredToolPreset(preset, storage);
+    assert.equal(storage.values.get("pi-tool-preset"), preset);
+    assert.equal(getPreferredToolPreset(storage), preset);
+  }
+});
+
+test("falls back safely when browser storage is unavailable", () => {
+  const unavailable = {
+    getItem() { throw new Error("blocked"); },
+    setItem() { throw new Error("blocked"); },
+  };
+
+  assert.equal(getPreferredToolPreset(unavailable), "default");
+  assert.doesNotThrow(() => setPreferredToolPreset("full", unavailable));
+  assert.equal(getPreferredToolPreset(null), "default");
+  assert.doesNotThrow(() => setPreferredToolPreset("full", null));
+});
+
+test("falls back when accessing window.localStorage throws", () => {
+  const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
+  const blockedWindow = {};
+  Object.defineProperty(blockedWindow, "localStorage", {
+    get() { throw new DOMException("blocked", "SecurityError"); },
+  });
+  Object.defineProperty(globalThis, "window", {
+    configurable: true,
+    value: blockedWindow,
+  });
+
+  try {
+    assert.equal(getPreferredToolPreset(), "default");
+    assert.doesNotThrow(() => setPreferredToolPreset("full"));
+  } finally {
+    if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
+    else delete globalThis.window;
+  }
+});

package/lib/tool-preset-preference.ts

@@ -0,0 +1,41 @@
+import { isToolPreset, type ToolPreset } from "./tool-presets";
+
+const STORAGE_KEY = "pi-tool-preset";
+
+interface StorageLike {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+function getBrowserStorage(): StorageLike | null {
+  if (typeof window === "undefined") return null;
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+
+export function getPreferredToolPreset(
+  storage: StorageLike | null = getBrowserStorage(),
+): ToolPreset {
+  if (!storage) return "default";
+  try {
+    const value = storage.getItem(STORAGE_KEY);
+    return isToolPreset(value) ? value : "default";
+  } catch {
+    return "default";
+  }
+}
+
+export function setPreferredToolPreset(
+  preset: ToolPreset,
+  storage: StorageLike | null = getBrowserStorage(),
+): void {
+  if (!storage) return;
+  try {
+    storage.setItem(STORAGE_KEY, preset);
+  } catch {
+    // Browser storage is best-effort.
+  }
+}

package/lib/tool-presets.test.mjs

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const {
+  PRESET_DEFAULT,
+  PRESET_FULL,
+  PRESET_NONE,
+  PRESET_READ_ONLY,
+  getPresetFromTools,
+  getToolNamesForPreset,
+} = await jiti.import("./tool-presets.ts");
+
+const BUILTIN_NAMES = ["bash", "read", "edit", "write", "grep", "find", "ls"];
+
+function toolEntries(activeNames, customNames = []) {
+  const active = new Set(activeNames);
+  return [...BUILTIN_NAMES, ...customNames].map((name) => ({
+    name,
+    description: name,
+    active: active.has(name),
+  }));
+}
+
+test("maps every tool preset to its built-in tools", () => {
+  assert.deepEqual(getToolNamesForPreset("none"), PRESET_NONE);
+  assert.deepEqual(getToolNamesForPreset("read-only"), PRESET_READ_ONLY);
+  assert.deepEqual(getToolNamesForPreset("default"), PRESET_DEFAULT);
+  assert.deepEqual(getToolNamesForPreset("full"), PRESET_FULL);
+  assert.deepEqual(PRESET_READ_ONLY, ["read", "grep", "find", "ls"]);
+});
+
+test("recognizes presets while ignoring active custom tools", () => {
+  const customNames = ["web_search", "delegate"];
+
+  assert.equal(getPresetFromTools(toolEntries([], customNames)), "none");
+  assert.equal(
+    getPresetFromTools(toolEntries([...PRESET_READ_ONLY, ...customNames], customNames)),
+    "read-only",
+  );
+  assert.equal(
+    getPresetFromTools(toolEntries([...PRESET_DEFAULT, ...customNames], customNames)),
+    "default",
+  );
+  assert.equal(
+    getPresetFromTools(toolEntries([...PRESET_FULL, ...customNames], customNames)),
+    "full",
+  );
+});
+
+test("returns fresh tool arrays that callers can safely modify", () => {
+  const names = getToolNamesForPreset("read-only");
+  names.push("custom");
+  assert.deepEqual(getToolNamesForPreset("read-only"), PRESET_READ_ONLY);
+});

package/lib/tool-presets.ts

@@ -0,0 +1,42 @@
+export interface ToolEntry {
+  name: string;
+  description: string;
+  active: boolean;
+}
+
+export const TOOL_PRESET_VALUES = ["none", "read-only", "default", "full"] as const;
+export type ToolPreset = typeof TOOL_PRESET_VALUES[number];
+
+export const PRESET_NONE: string[] = [];
+export const PRESET_READ_ONLY: string[] = ["read", "grep", "find", "ls"];
+export const PRESET_DEFAULT: string[] = ["read", "bash", "edit", "write"];
+export const PRESET_FULL: string[] = ["bash", "read", "edit", "write", "grep", "find", "ls"];
+
+const BUILTIN_TOOL_NAMES = new Set(PRESET_FULL);
+
+export function isToolPreset(value: unknown): value is ToolPreset {
+  return typeof value === "string" && (TOOL_PRESET_VALUES as readonly string[]).includes(value);
+}
+
+export function getPresetFromTools(tools: ToolEntry[]): ToolPreset {
+  const activeTools = tools.filter((t) => t.active);
+  if (activeTools.length === 0) return "none";
+
+  const active = activeTools
+    .map((t) => t.name)
+    .filter((name) => BUILTIN_TOOL_NAMES.has(name))
+    .sort()
+    .join(",");
+
+  if (active === [...PRESET_READ_ONLY].sort().join(",")) return "read-only";
+  if (active === [...PRESET_DEFAULT].sort().join(",")) return "default";
+  if (active === [...PRESET_FULL].sort().join(",")) return "full";
+  return "default";
+}
+
+export function getToolNamesForPreset(preset: ToolPreset): string[] {
+  if (preset === "none") return [...PRESET_NONE];
+  if (preset === "read-only") return [...PRESET_READ_ONLY];
+  if (preset === "full") return [...PRESET_FULL];
+  return [...PRESET_DEFAULT];
+}

package/lib/turn-written-files.test.mjs

@@ -0,0 +1,137 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, { tsconfigPaths: true });
+const { extractTurnWrittenFiles } = await jiti.import("./turn-written-files.ts");
+
+function toolCall(toolCallId, toolName, input) {
+  return { type: "toolCall", toolCallId, toolName, input };
+}
+
+function okResult(toolCallId) {
+  return { role: "toolResult", toolCallId, content: [{ type: "text", text: "ok" }] };
+}
+
+function errorResult(toolCallId) {
+  return { role: "toolResult", toolCallId, content: [{ type: "text", text: "boom" }], isError: true };
+}
+
+function results(...entries) {
+  return new Map(entries.map((r) => [r.toolCallId, r]));
+}
+
+function paths(content, toolResults, cwd) {
+  return extractTurnWrittenFiles(content, toolResults, cwd).map((f) => f.filePath);
+}
+
+test("extracts a file from a successful write tool call", () => {
+  const content = [toolCall("1", "write", { file_path: "/abs/out/report.html" })];
+  assert.deepEqual(paths(content, results(okResult("1"))), ["/abs/out/report.html"]);
+});
+
+test("extracts a file from a successful edit tool call using input.path", () => {
+  const content = [toolCall("1", "edit", { path: "/abs/src/a.ts" })];
+  assert.deepEqual(paths(content, results(okResult("1"))), ["/abs/src/a.ts"]);
+});
+
+test("accepts namespaced write/edit tool names from MCP servers", () => {
+  const content = [
+    toolCall("1", "write_file", { file_path: "/abs/a.txt" }),
+    toolCall("2", "fs.edit", { file_path: "/abs/b.txt" }),
+    toolCall("3", "str_replace_editor", { file_path: "/abs/c.txt" }),
+  ];
+  assert.deepEqual(
+    paths(content, results(okResult("1"), okResult("2"), okResult("3"))),
+    ["/abs/a.txt", "/abs/b.txt", "/abs/c.txt"],
+  );
+});
+
+test("skips a tool call whose result errored", () => {
+  const content = [toolCall("1", "write", { file_path: "/abs/out/report.html" })];
+  assert.deepEqual(paths(content, results(errorResult("1"))), []);
+});
+
+test("skips a tool call whose result has not arrived (streaming)", () => {
+  const content = [toolCall("1", "write", { file_path: "/abs/out/report.html" })];
+  assert.deepEqual(paths(content, results()), []);
+  assert.deepEqual(paths(content, undefined), []);
+});
+
+test("deduplicates the same file written then edited", () => {
+  const content = [
+    toolCall("1", "write", { file_path: "/abs/out/report.html" }),
+    toolCall("2", "edit", { path: "/abs/out/report.html" }),
+  ];
+  assert.deepEqual(paths(content, results(okResult("1"), okResult("2"))), ["/abs/out/report.html"]);
+});
+
+test("resolves a relative path against cwd", () => {
+  const content = [toolCall("1", "write", { file_path: "out/report.html" })];
+  assert.deepEqual(paths(content, results(okResult("1")), "/abs"), ["/abs/out/report.html"]);
+});
+
+test("resolves extensionless and dot-prefixed filenames against cwd", () => {
+  const content = [
+    toolCall("1", "write", { path: "LICENSE" }),
+    toolCall("2", "write", { path: ".env" }),
+  ];
+  assert.deepEqual(
+    paths(content, results(okResult("1"), okResult("2")), "/repo"),
+    ["/repo/LICENSE", "/repo/.env"],
+  );
+});
+
+test("preserves path characters that have special meaning in hrefs", () => {
+  const content = [
+    toolCall("1", "write", { path: "release#1.md" }),
+    toolCall("2", "write", { path: "query?.json" }),
+    toolCall("3", "write", { path: "report.md:42" }),
+  ];
+  assert.deepEqual(
+    paths(content, results(okResult("1"), okResult("2"), okResult("3")), "/repo"),
+    ["/repo/release#1.md", "/repo/query?.json", "/repo/report.md:42"],
+  );
+});
+
+test("normalizes Windows-relative tool paths against a Windows cwd", () => {
+  const content = [toolCall("1", "write", { path: "src\\report.html" })];
+  assert.deepEqual(
+    paths(content, results(okResult("1")), "C:\\repo"),
+    ["C:/repo/src/report.html"],
+  );
+});
+
+test("skips non-writing tools like read and bash", () => {
+  const content = [
+    toolCall("1", "read", { file_path: "/abs/a.ts" }),
+    toolCall("2", "bash", { command: "echo hi > /abs/a.txt" }),
+  ];
+  assert.deepEqual(paths(content, results(okResult("1"), okResult("2"))), []);
+});
+
+test("ignores paths that only appear in the reply text", () => {
+  // A path the assistant merely writes in prose is not evidence of a write.
+  const content = [
+    { type: "text", text: "I saved the report to /abs/out/report.html for you." },
+  ];
+  assert.deepEqual(paths(content, results()), []);
+});
+
+test("lists only the file actually written, not others named in the text", () => {
+  const content = [
+    toolCall("1", "write", { file_path: "/abs/out/real.html" }),
+    { type: "text", text: "See also /abs/out/imagined.html and /etc/passwd" },
+  ];
+  assert.deepEqual(paths(content, results(okResult("1"))), ["/abs/out/real.html"]);
+});
+
+test("skips a write call missing both file_path and path", () => {
+  const content = [toolCall("1", "write", { content: "hi" })];
+  assert.deepEqual(paths(content, results(okResult("1"))), []);
+});
+
+test("returns an empty array for an empty or text-only turn", () => {
+  assert.deepEqual(paths([], results()), []);
+  assert.deepEqual(paths([{ type: "text", text: "hi" }], results()), []);
+});