feat(chat): scannable tool call rows for every provider

apps/mobile/src/lib/threadActivity.ts

@@ -9,6 +9,7 @@ import type {
   OrchestrationLatestTurn,
   OrchestrationThread,
   OrchestrationThreadActivity,
+  ToolCallFacts,
   ToolLifecycleItemType,
   TurnId,
   UserInputQuestion,
@@ -117,6 +118,8 @@ export interface WorkLogEntry {
     }>;
   };
   toolData?: unknown;
+  /** Server-derived, provider-neutral facts (cwd, exit code, duration, output, files). */
+  facts?: ToolCallFacts;
 }
 
 interface DerivedWorkLogEntry extends WorkLogEntry {
@@ -506,6 +509,10 @@ function toDerivedWorkLogEntry(activity: OrchestrationThreadActivity): DerivedWo
   if (toolCallId) {
     entry.toolCallId = toolCallId;
   }
+  const facts = asRecord(payload?.facts);
+  if (facts) {
+    entry.facts = facts as ToolCallFacts;
+  }
   if (isTaskActivity && payload) {
     if (payload.agentKind !== "agent") {
       entry.isBackgroundTask = true;

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts

@@ -16,6 +16,7 @@ import {
   type OrchestrationThreadActivity,
   type ProviderRuntimeEvent,
   RuntimeRequestId,
+  type ToolCallFacts,
 } from "@t3tools/contracts";
 import * as Cache from "effect/Cache";
 import * as Cause from "effect/Cause";
@@ -50,6 +51,7 @@ import {
 } from "../Services/ProviderRuntimeIngestion.ts";
 import { projectActivityPayload } from "../ActivityPayloadProjection.ts";
 import { forkParked } from "../../serverActivation.ts";
+import { deriveToolCallFacts } from "../toolCallFacts.ts";
 import { ServerSettingsService } from "../../serverSettings.ts";
 import { canReplaceThreadTitle } from "../threadTitles.ts";
 
@@ -163,6 +165,18 @@ function maxCheckpointTurnCount(
   return maxTurnCount;
 }
 
+/**
+ * Provider-neutral facts (cwd, exit code, duration, bounded output, file
+ * stats) derived from the item's native data. Lives beside `data` so the
+ * payload projection keeps it while slimming `data` for the wire.
+ */
+function toolCallFactsField(
+  event: Extract<ProviderRuntimeEvent, { type: "item.updated" | "item.completed" }>,
+): { facts?: ToolCallFacts } {
+  const facts = deriveToolCallFacts({ provider: event.provider, data: event.payload.data });
+  return facts ? { facts } : {};
+}
+
 function truncateDetail(value: string, limit = 180): string {
   return value.length > limit ? `${value.slice(0, limit - 3)}...` : value;
 }
@@ -815,6 +829,7 @@ export function runtimeEventToActivities(
             ...(event.payload.toolIcon ? { toolIcon: event.payload.toolIcon } : {}),
             ...(event.payload.toolSource ? { toolSource: event.payload.toolSource } : {}),
             ...(event.payload.data !== undefined ? { data: event.payload.data } : {}),
+            ...toolCallFactsField(event),
             ...(event.payload.agentId ? { agentId: event.payload.agentId } : {}),
             ...(event.payload.parentToolUseId
               ? { parentToolUseId: event.payload.parentToolUseId }
@@ -847,6 +862,7 @@ export function runtimeEventToActivities(
             ...(event.payload.toolIcon ? { toolIcon: event.payload.toolIcon } : {}),
             ...(event.payload.toolSource ? { toolSource: event.payload.toolSource } : {}),
             ...(event.payload.data !== undefined ? { data: event.payload.data } : {}),
+            ...toolCallFactsField(event),
             ...(event.payload.agentId ? { agentId: event.payload.agentId } : {}),
             ...(event.payload.parentToolUseId
               ? { parentToolUseId: event.payload.parentToolUseId }

apps/server/src/orchestration/toolCallFacts.test.ts

@@ -0,0 +1,196 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import {
+  boundFiles,
+  boundToolOutput,
+  deriveToolCallFacts,
+  textPairStat,
+  TOOL_DIFF_TOTAL_MAX_CHARS,
+  TOOL_FILES_MAX,
+  TOOL_OUTPUT_MAX_LINES,
+  unifiedDiffStat,
+} from "./toolCallFacts.ts";
+
+const DIFF = `--- a/src/app.ts
++++ b/src/app.ts
+@@ -1,3 +1,4 @@
+ import x from "x";
+-const a = 1;
++const a = 2;
++const b = 3;
+`;
+
+describe("deriveToolCallFacts", () => {
+  it("reads Codex command items verbatim", () => {
+    expect(
+      deriveToolCallFacts({
+        provider: "codex",
+        data: {
+          item: {
+            type: "commandExecution",
+            command: "pnpm test",
+            cwd: "/repo/apps/web",
+            exitCode: 1,
+            durationMs: 4210,
+            aggregatedOutput: "FAIL src/a.test.ts\n  expected 1 to be 2\n",
+          },
+        },
+      }),
+    ).toEqual({
+      cwd: "/repo/apps/web",
+      exitCode: 1,
+      durationMs: 4210,
+      output: { text: "FAIL src/a.test.ts\n  expected 1 to be 2", lineCount: 2, truncated: false },
+    });
+  });
+
+  it("keeps Codex file changes with diff stats and a bounded hunk", () => {
+    const facts = deriveToolCallFacts({
+      provider: "codex",
+      data: {
+        item: { type: "fileChange", changes: [{ path: "src/app.ts", kind: "update", diff: DIFF }] },
+      },
+    });
+    expect(facts?.files).toEqual([
+      { path: "src/app.ts", kind: "update", additions: 2, deletions: 1, diff: DIFF },
+    ]);
+  });
+
+  it("reads Claude Bash intent and tool_result text", () => {
+    expect(
+      deriveToolCallFacts({
+        provider: "claudeAgent",
+        data: {
+          toolName: "Bash",
+          input: { command: "ls", description: "List the project root" },
+          result: {
+            type: "tool_result",
+            content: [{ type: "text", text: "a\nb" }],
+            is_error: false,
+          },
+        },
+      }),
+    ).toEqual({
+      intent: "List the project root",
+      output: { text: "a\nb", lineCount: 2, truncated: false },
+    });
+  });
+
+  it("derives edit stats for Claude Edit and Write calls", () => {
+    expect(
+      deriveToolCallFacts({
+        provider: "claudeAgent",
+        data: {
+          toolName: "Edit",
+          input: { file_path: "/repo/a.ts", old_string: "x\ny", new_string: "x\nz\nw" },
+        },
+      })?.files,
+    ).toEqual([{ path: "/repo/a.ts", kind: "update", additions: 2, deletions: 1 }]);
+    expect(
+      deriveToolCallFacts({
+        provider: "claudeAgent",
+        data: { toolName: "Write", input: { file_path: "/repo/b.ts", content: "1\n2\n3" } },
+      })?.files,
+    ).toEqual([{ path: "/repo/b.ts", kind: "write", additions: 3, deletions: 0 }]);
+  });
+
+  it("reads ACP content text and diff parts for Cursor, Grok, and Antigravity", () => {
+    const data = {
+      kind: "edit",
+      content: [
+        { type: "content", content: { type: "text", text: "Applied" } },
+        { type: "diff", path: "src/x.ts", oldText: "a\nb", newText: "a\nc" },
+      ],
+    };
+    for (const provider of ["cursor", "grok", "antigravity"]) {
+      expect(deriveToolCallFacts({ provider, data })).toEqual({
+        output: { text: "Applied", lineCount: 1, truncated: false },
+        files: [{ path: "src/x.ts", additions: 1, deletions: 1 }],
+      });
+    }
+  });
+
+  it("reads OpenCode state timing, output, and exit metadata", () => {
+    expect(
+      deriveToolCallFacts({
+        provider: "opencode",
+        data: {
+          tool: "bash",
+          state: {
+            status: "completed",
+            input: { command: "make" },
+            output: "ok",
+            metadata: { exit: 0 },
+            time: { start: 1000, end: 1750 },
+          },
+        },
+      }),
+    ).toEqual({
+      exitCode: 0,
+      durationMs: 750,
+      output: { text: "ok", lineCount: 1, truncated: false },
+    });
+  });
+
+  it("returns nothing for unknown providers or empty data", () => {
+    expect(deriveToolCallFacts({ provider: "codex", data: {} })).toBeUndefined();
+    expect(deriveToolCallFacts({ provider: "other", data: { item: {} } })).toBeUndefined();
+  });
+});
+
+describe("boundToolOutput", () => {
+  it("caps lines, strips ANSI, and reports the real size", () => {
+    const raw = Array.from({ length: 100 }, (_, i) => `line ${i}`).join("\n");
+    const output = boundToolOutput(raw);
+    expect(output?.lineCount).toBe(100);
+    expect(output?.truncated).toBe(true);
+    expect(output?.text.split("\n")).toHaveLength(TOOL_OUTPUT_MAX_LINES);
+    expect(output?.text.startsWith("line 0")).toBe(true);
+  });
+
+  it("drops empty output", () => {
+    expect(boundToolOutput("  \n ")).toBeUndefined();
+    expect(boundToolOutput(undefined)).toBeUndefined();
+  });
+});
+
+describe("diff stats", () => {
+  it("counts unified diff lines without headers", () => {
+    expect(unifiedDiffStat(DIFF)).toEqual({ additions: 2, deletions: 1 });
+  });
+
+  it("counts before/after line changes", () => {
+    expect(textPairStat("a\nb\nc", "a\nc\nd")).toEqual({ additions: 1, deletions: 1 });
+    expect(textPairStat("", "one\ntwo")).toEqual({ additions: 2, deletions: 0 });
+  });
+
+  it("still detects a same-sized rewrite of a large file", () => {
+    const before = Array.from({ length: 700 }, (_, i) => `a${i}`).join("\n");
+    const after = Array.from({ length: 700 }, (_, i) => `b${i}`).join("\n");
+    expect(textPairStat(before, after)).toEqual({ additions: 700, deletions: 700 });
+  });
+
+  it("bounds file count and total hunk size", () => {
+    const hunk = "+".repeat(10_000);
+    const files = Array.from({ length: 30 }, (_, i) => ({
+      path: `f${i}.ts`,
+      additions: 1,
+      deletions: 0,
+      diff: hunk,
+    }));
+    const bounded = boundFiles(files);
+    expect(bounded).toHaveLength(TOOL_FILES_MAX);
+    const kept = bounded.filter((file) => file.diff !== undefined);
+    expect(kept.length * hunk.length).toBeLessThanOrEqual(TOOL_DIFF_TOTAL_MAX_CHARS);
+    expect(bounded.every((file) => file.additions === 1)).toBe(true);
+  });
+
+  it("combines ACP stdout and stderr", () => {
+    expect(
+      deriveToolCallFacts({
+        provider: "cursor",
+        data: { kind: "execute", rawOutput: { stdout: "ok", stderr: "warn: x" } },
+      })?.output?.text,
+    ).toBe("ok\nwarn: x");
+  });
+});