Merge main (CF-5 first part #287) into the CF-4 parser slice

Coven-Harness: Claude Code / claude-opus-5-5

Author: BunsDev

apps/desktop/e2e/conversation-evidence.spec.ts

@@ -0,0 +1,97 @@
+import { test, expect, type ElectronApplication, type Page } from "@playwright/test";
+import fs from "node:fs";
+import path from "node:path";
+import { currentRow, items, launch, seedHome, tid } from "./support";
+
+/**
+ * What a turn's evidence shows (docs/conversation-evidence.md): the command that actually ran and how
+ * it ended, output bounded with a visible note, a patch labelled as this turn's, a native memory
+ * citation, and model-written links labelled as such. Items are sent to the window as main would.
+ */
+let app: ElectronApplication;
+let page: Page;
+let home: string;
+let repo: string;
+let threadId: string;
+
+const at = () => new Date().toISOString();
+const origin = (item: string) => ({ thread: threadId, turn: "u-evidence", attempt: "E1", backend: "codex", native: { runtime: "R", thread: "nt", turn: "nu", item } });
+async function send(events: Record<string, unknown>[]): Promise<void> {
+  await app.evaluate(({ BrowserWindow }, list) => {
+    for (const event of list) BrowserWindow.getAllWindows()[0]!.webContents.send("thread:event", event);
+  }, events);
+}
+const item = (event: Record<string, unknown>) => ({ type: "item", threadId, item: event });
+
+test.beforeAll(async () => {
+  ({ home, repo } = seedHome());
+  ({ app, page } = await launch(home));
+  const script = path.join(home, "evidence-script.json");
+  fs.writeFileSync(script, JSON.stringify([{ content: "Ready." }]));
+  await page.evaluate((mock_script) => window.modex!.invoke("settings:update", { mock_script }), script);
+  await page.keyboard.press("Meta+n");
+  await expect(tid(page, "composer-input")).toBeFocused();
+  await tid(page, "composer-input").fill("start");
+  await page.keyboard.press("Meta+Enter");
+  await expect(tid(page, "thread-view")).toBeVisible({ timeout: 15_000 });
+  await expect(currentRow(page)).toHaveAttribute("data-status", "idle");
+  threadId = (await currentRow(page).getAttribute("data-thread-id"))!;
+  const tool = (id: string, title: string, extra: Record<string, unknown>) => item({ id, kind: "tool", name: "shell", title, args: {}, status: "done", durationMs: 1200, origin: origin(id), at: at(), ...extra });
+  await send([
+    item({ id: "u-evidence", kind: "user", text: "evidence turn", at: at() }),
+    tool("t-fail", "$ npm test", { exec: { command: "/bin/zsh -lc 'npm test -- --grep \"a b\"'", cwd: "/repo/pkg" }, exitCode: 2, outcome: "failed", ok: false,
+      output: "…last lines\n1 failing\n", outputBytes: 3 * 1024 * 1024, outputTruncated: true }),
+    tool("t-denied", "$ rm -rf build", { exec: { command: "/bin/zsh -lc 'rm -rf build'", cwd: "/repo" }, exitCode: null, outcome: "denied", ok: false }),
+    tool("t-claude", "$ ls", { exec: { command: "ls" }, outcome: "succeeded", ok: true, output: "src\n" }),
+    item({ id: "t-patch", kind: "tool", name: "apply_patch", title: "edit NOTE.md", args: { patch: "*** Begin Patch\n*** Add File: NOTE.md\n+hi\n*** End Patch" }, status: "done", outcome: "succeeded", ok: true, origin: origin("t-patch"), at: at() }),
+    item({ id: "a-final", kind: "assistant", text: "Use the build flags from memory.\n\nSources:\n- [Node.js](https://nodejs.org/)\n- [npm docs](https://docs.npmjs.com/)", phase: "final", outcome: "succeeded", origin: origin("a-final"), at: at(),
+      evidence: [{ kind: "memory", source: "codex", path: "notes/build.md", lineStart: 3, lineEnd: 5, note: "Build flags 🛠" }] }),
+    { type: "status", threadId, status: "idle" },
+  ]);
+  await tid(page, "turn-label").last().click();
+});
+
+test.afterAll(async () => {
+  await app?.close();
+  fs.rmSync(home, { recursive: true, force: true });
+  fs.rmSync(repo, { recursive: true, force: true });
+});
+
+test("a command shows what actually ran, where, and how it ended, apart from its title", async () => {
+  const failed = items(page, "tool").filter({ hasText: "$ npm test" });
+  await tid(failed, "item-toggle").click();
+  await expect(tid(failed, "tool-command")).toHaveText("/bin/zsh -lc 'npm test -- --grep \"a b\"'");
+  await expect(tid(failed, "tool-cwd")).toHaveText("in /repo/pkg");
+  await expect(tid(failed, "tool-exit")).toHaveText("Exit code 2");
+  const denied = items(page, "tool").filter({ hasText: "$ rm -rf build" });
+  await tid(denied, "item-toggle").click();
+  await expect(tid(denied, "tool-exit")).toHaveText("No exit code");
+  const claude = items(page, "tool").filter({ hasText: "$ ls" });
+  await tid(claude, "item-toggle").click();
+  await expect(tid(claude, "tool-exit")).toHaveText("Exit code not reported");
+  await expect(tid(claude, "tool-cwd")).toHaveCount(0);
+});
+
+test("output past the preview says how much is shown", async () => {
+  const failed = items(page, "tool").filter({ hasText: "$ npm test" });
+  await expect(tid(failed, "tool-truncated")).toHaveText("Showing the last 256 KB of 3.0 MB.");
+  await expect(tid(failed, "tool-output")).toContainText("1 failing");
+});
+
+test("a patch is labelled as this turn's, apart from the working tree now", async () => {
+  const patch = items(page, "tool").filter({ hasText: "edit NOTE.md" });
+  await tid(patch, "item-toggle").click();
+  await expect(tid(patch, "tool-patch-note")).toHaveText("The patch as this turn applied it. The working tree may have changed since; Changes shows it now.");
+});
+
+test("a native memory citation is shown as one; links the model wrote are labelled as its own", async () => {
+  const answer = items(page, "assistant").filter({ hasText: "Use the build flags" });
+  const memory = tid(answer, "evidence-memory");
+  await expect(memory).toContainText("Codex memory");
+  await expect(memory).toContainText("notes/build.md · lines 3–5");
+  await expect(memory).toContainText("Build flags 🛠");
+  const sources = tid(answer, "sources");
+  await expect(sources).toHaveAttribute("data-provenance", "reply-text");
+  await expect(sources).toContainText("Links in the reply · 2");
+  await expect(sources).toHaveAttribute("title", "Links the model wrote in its reply. Modex has not checked them.");
+});

apps/desktop/e2e/sources.spec.ts

@@ -52,7 +52,7 @@ test("links in an answer are links, and its Sources list becomes numbered cards"
   await expect(answer.getByRole("link", { name: "https://example.com/pricing", exact: true })).toHaveAttribute("href", "https://example.com/pricing");
 
   const sources = tid(answer, "sources");
-  await expect(sources).toContainText("Sources · 2");
+  await expect(sources).toContainText("Links in the reply · 2");
   const cards = tid(sources, "source-link");
   await expect(cards).toHaveCount(2);
   await expect(cards.nth(0)).toHaveAttribute("href", ANNOUNCEMENT);

apps/desktop/src/main/engine/backends/claude.ts

@@ -407,7 +407,9 @@ export class ClaudeBackend implements Backend {
               continue;
             }
             ctx.started.set(block.id, Date.now());
-            ctx.observe({ type: "tool.start", native: ctx.native(block.id), tool: { name: block.name ?? "tool", title: toolTitle(block.name ?? "tool", block.input ?? {}), args: block.input ?? {} } });
+            // Bash's command is what ran; its working directory is the CLI's own and persists between calls, so none is claimed.
+            const command = block.name === "Bash" && typeof block.input?.command === "string" ? block.input.command : undefined;
+            ctx.observe({ type: "tool.start", native: ctx.native(block.id), tool: { name: block.name ?? "tool", title: toolTitle(block.name ?? "tool", block.input ?? {}), args: block.input ?? {}, ...(command ? { exec: { command } } : {}) } });
           }
         }
         return;

apps/desktop/src/main/engine/backends/codex.ts

@@ -12,6 +12,7 @@ import { codexCall, UsageMeter, withUsage } from "./usage.js";
 import { cliEnvironment, cliSpawn, health, installation } from "./health.js";
 import type { AgentActivity, BackendHealth } from "../../../shared/types.js";
 import type { MessagePhase, NativeRef, SettledOutcome } from "../../../shared/conversation-events.js";
+import { boundOutput, byteLength, memoryEvidence } from "../../../shared/evidence.js";
 
 /**
  * Codex's own wording when the sign-in it loaded at startup no longer matches ~/.codex/auth.json
@@ -283,7 +284,8 @@ export class CodexBackend implements Backend {
     const runtime = this.generation;
     const agents = new AgentTracker(sink, runtime);
     const activities = new Set<string>();
-    const tools = new Map<string, { started: number; output: string }>();
+    // Output is kept bounded as it streams (its last 256 KiB), with the total seen.
+    const tools = new Map<string, { started: number; output: string; bytes: number }>();
     let turnId: string | null = null;
     // Codex announces a fatal error as an `error` notification before `turn/completed` reports the
     // failure. The notification carries the better message and an error code; it is held here and
@@ -401,15 +403,16 @@ export class CodexBackend implements Backend {
             } else if (item.type === "reasoning") {
               sink.observe({ type: "reasoning.start", native: native(item.id) });
             } else if (item.type === "commandExecution") {
-              tools.set(item.id, { started: Date.now(), output: "" });
-              sink.observe({ type: "tool.start", native: native(item.id), tool: { name: "shell", title: `$ ${stripShell(item.command ?? "")}`, args: { command: item.command, cwd: item.cwd } } });
+              tools.set(item.id, { started: Date.now(), output: "", bytes: 0 });
+              sink.observe({ type: "tool.start", native: native(item.id), tool: { name: "shell", title: `$ ${stripShell(item.command ?? "")}`, args: { command: item.command, cwd: item.cwd },
+                ...(item.command ? { exec: { command: item.command, ...(item.cwd ? { cwd: item.cwd } : {}) } } : {}) } });
             } else if (item.type === "fileChange") {
-              tools.set(item.id, { started: Date.now(), output: "" });
+              tools.set(item.id, { started: Date.now(), output: "", bytes: 0 });
               const files = (item.changes ?? []).map((c) => c.path);
               this.changePaths.set(`${tid}:${item.id}`, files);
               sink.observe({ type: "tool.start", native: native(item.id), tool: { name: "apply_patch", title: `edit ${files.join(", ")}`, args: { patch: (item.changes ?? []).map((c) => c.diff).join("\n") } } });
             } else if (item.type === "mcpToolCall" || item.type === "dynamicToolCall" || item.type === "webSearch") {
-              tools.set(item.id, { started: Date.now(), output: "" });
+              tools.set(item.id, { started: Date.now(), output: "", bytes: 0 });
               const label = item.type === "webSearch" ? `search ${item.query ?? ""}` : `${item.server ? item.server + "." : ""}${item.tool ?? item.type}`;
               sink.observe({ type: "tool.start", native: native(item.id), tool: { name: item.type, title: label, args: (item.arguments as Record<string, unknown>) ?? {} } });
             }
@@ -428,8 +431,10 @@ export class CodexBackend implements Backend {
           case "item/commandExecution/outputDelta": {
             const t = tools.get(String(p.itemId));
             if (t) {
-              t.output += String(p.delta ?? "");
-              sink.observe({ type: "tool.update", native: native(p.itemId), progress: { output: t.output } });
+              const delta = String(p.delta ?? "");
+              t.bytes += byteLength(delta);
+              t.output = boundOutput(t.output + delta).text;
+              sink.observe({ type: "tool.update", native: native(p.itemId), progress: { output: t.output, ...(t.bytes > byteLength(t.output) ? { outputBytes: t.bytes, outputTruncated: true } : {}) } });
             }
             break;
           }
@@ -438,11 +443,18 @@ export class CodexBackend implements Backend {
             if (item.type === "fileChange") this.changePaths.delete(`${tid}:${item.id}`);
             if (item.type === "agentMessage") {
               // A message that completes without streaming is kept, commentary included: its phase says what it is.
-              sink.observe({ type: "message.done", native: native(item.id), ...(typeof item.text === "string" ? { text: item.text } : {}), phase: codexPhase(item.phase), ...(item.phase ? { nativePhase: item.phase } : {}) });
+              const evidence = memoryEvidence(item.memoryCitation);
+              sink.observe({ type: "message.done", native: native(item.id), ...(typeof item.text === "string" ? { text: item.text } : {}), phase: codexPhase(item.phase), ...(item.phase ? { nativePhase: item.phase } : {}), ...(evidence.length ? { evidence } : {}) });
             } else if (tools.has(item.id)) {
               const t = tools.get(item.id)!;
               const output = item.type === "commandExecution" ? (item.aggregatedOutput ?? t.output) : item.type === "fileChange" ? (item.changes ?? []).map((c) => `${c.kind?.type ?? "update"} ${c.path}\n${c.diff}`).join("\n") : JSON.stringify(item.result ?? item.error ?? "", null, 2);
-              sink.observe({ type: "tool.done", native: native(item.id), outcome: codexOutcome(item), progress: { ...(output ? { output } : {}), durationMs: item.durationMs ?? Date.now() - t.started } });
+              const total = Math.max(t.bytes, byteLength(output));
+              const shown = boundOutput(output).text;
+              sink.observe({ type: "tool.done", native: native(item.id), outcome: codexOutcome(item), progress: {
+                ...(shown ? { output: shown } : {}), ...(total > byteLength(shown) ? { outputBytes: total, outputTruncated: true } : {}),
+                ...(item.type === "commandExecution" && "exitCode" in item ? { exitCode: item.exitCode ?? null } : {}),
+                durationMs: item.durationMs ?? Date.now() - t.started,
+              } });
             } else if (item.type === "reasoning") {
               sink.observe({ type: "reasoning.done", native: native(item.id), summary: item.summary ?? [], text: item.content ?? [] });
             }
@@ -623,6 +635,7 @@ interface CodexItem {
   agentThreadId?: string;
   agentPath?: string;
   kind?: string;
+  memoryCitation?: unknown;
 }
 
 /** Cancel setup locally without killing the shared server used by other threads. */

apps/desktop/src/main/engine/runner.ts

@@ -28,6 +28,7 @@ import type { PendingCreation, PendingSendRecord } from "./pending-sends.js";
 import { copyComposerRecovery } from "./update-recovery.js";
 import { parseRecoveryJSON, recoveryJSON } from "./attachment-recovery-file.js";
 import type { DraftRemovalScope } from "../../shared/native-drafts.js";
+import { boundOutput } from "../../shared/evidence.js";
 import { CONVERSATION_SCHEMA, applyConversationEvent, initialConversation, okFor, type AttemptMark, type ConversationEvent, type ConversationState, type Observation, type SettledOutcome, type TurnRef } from "../../shared/conversation-events.js";
 
 /** Refused approvals in a routine run: the routine is read-only, and nobody is there to answer. */
@@ -1165,10 +1166,18 @@ export class ThreadRunner {
 /** How a backend's turn result ends its attempt. */
 const ATTEMPT_OUTCOME: Record<TurnResult["status"], SettledOutcome> = { completed: "succeeded", interrupted: "interrupted", failed: "failed" };
 
-/** Tool args at the size the UI keeps. */
+/** Tool args and output at the size the transcript keeps: output is its last 256 KiB, with the total. */
 function redactObservation(o: Observation): Observation {
   if (o.type === "tool.start") return { ...o, tool: { ...o.tool, args: redact(o.tool.args) } };
-  if ((o.type === "tool.update" || o.type === "tool.done") && o.progress?.args) return { ...o, progress: { ...o.progress, args: redact(o.progress.args) } };
+  if ((o.type === "tool.update" || o.type === "tool.done") && o.progress) {
+    const progress = { ...o.progress, ...(o.progress.args ? { args: redact(o.progress.args) } : {}) };
+    if (progress.output !== undefined) {
+      const bounded = boundOutput(progress.output);
+      progress.output = bounded.text;
+      if (bounded.truncated) Object.assign(progress, { outputBytes: Math.max(progress.outputBytes ?? 0, bounded.truncated.totalBytes), outputTruncated: true });
+    }
+    return { ...o, progress } as Observation;
+  }
   return o;
 }