@stigmer/ink 3.1.2 → 3.1.4

package/src/__tests__/file-change-progress.test.tsx

@@ -0,0 +1,295 @@
+import React from "react";
+import { describe, it, expect } from "vitest";
+import { render } from "ink-testing-library";
+import { create } from "@bufbuild/protobuf";
+import {
+  FileChangeProgressSchema,
+  FileChangeProgressEntrySchema,
+  CapturedFileChangeSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/filereview_pb";
+import type {
+  FileChangeProgress,
+  FileChangeProgressEntry,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/filereview_pb";
+import { FileChangeKind } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { FileChangeProgressBar } from "../components/FileChangeProgressBar.js";
+import { changeDisplayPath, progressEntryDisplayPath } from "../file-review.js";
+
+// --- fixtures -------------------------------------------------------------
+
+interface EntryOpts {
+  readonly pathBefore?: string;
+  readonly pathAfter?: string;
+  readonly kind?: FileChangeKind;
+  readonly linesAdded?: number;
+  readonly linesRemoved?: number;
+}
+
+function makeEntry(opts: EntryOpts): FileChangeProgressEntry {
+  return create(FileChangeProgressEntrySchema, {
+    pathBefore: opts.pathBefore ?? "",
+    pathAfter: opts.pathAfter ?? "",
+    kind: opts.kind ?? FileChangeKind.MODIFY,
+    linesAdded: opts.linesAdded ?? 0,
+    linesRemoved: opts.linesRemoved ?? 0,
+  });
+}
+
+interface ProgressOpts {
+  readonly filesChanged?: number;
+  readonly linesAdded?: number;
+  readonly linesRemoved?: number;
+  readonly entries?: FileChangeProgressEntry[];
+}
+
+function makeProgress(opts: ProgressOpts): FileChangeProgress {
+  const entries = opts.entries ?? [];
+  return create(FileChangeProgressSchema, {
+    changeSetId: "cs-1",
+    filesChanged: opts.filesChanged ?? entries.length,
+    linesAdded: opts.linesAdded ?? 0,
+    linesRemoved: opts.linesRemoved ?? 0,
+    entries,
+    capturedAt: "2026-07-05T00:00:00Z",
+  });
+}
+
+// --- FileChangeProgressBar: visibility ------------------------------------
+
+describe("FileChangeProgressBar — visibility", () => {
+  it("renders nothing when progress is undefined", () => {
+    const { lastFrame } = render(<FileChangeProgressBar progress={undefined} />);
+    expect((lastFrame() ?? "").trim()).toBe("");
+  });
+
+  it("renders nothing when no files have changed yet", () => {
+    const { lastFrame } = render(
+      <FileChangeProgressBar progress={makeProgress({ filesChanged: 0 })} />,
+    );
+    expect((lastFrame() ?? "").trim()).toBe("");
+  });
+});
+
+// --- FileChangeProgressBar: compact summary -------------------------------
+
+describe("FileChangeProgressBar — compact summary", () => {
+  it("uses the singular noun for a single file", () => {
+    const { lastFrame } = render(
+      <FileChangeProgressBar
+        progress={makeProgress({
+          filesChanged: 1,
+          entries: [makeEntry({ pathAfter: "one.ts" })],
+        })}
+      />,
+    );
+    expect(lastFrame() ?? "").toContain("1 file changing");
+  });
+
+  it("uses the plural noun for multiple files", () => {
+    const { lastFrame } = render(
+      <FileChangeProgressBar
+        progress={makeProgress({
+          filesChanged: 3,
+          entries: [makeEntry({ pathAfter: "one.ts" })],
+        })}
+      />,
+    );
+    expect(lastFrame() ?? "").toContain("3 files changing");
+  });
+
+  it("shows the aggregate +N -M when counts exist", () => {
+    const { lastFrame } = render(
+      <FileChangeProgressBar
+        progress={makeProgress({
+          filesChanged: 2,
+          linesAdded: 12,
+          linesRemoved: 4,
+          entries: [makeEntry({ pathAfter: "one.ts" })],
+        })}
+      />,
+    );
+    const out = lastFrame() ?? "";
+    expect(out).toContain("+12");
+    expect(out).toContain("-4");
+  });
+
+  it("hides the aggregate stat when both counts are zero (never +0 -0)", () => {
+    const { lastFrame } = render(
+      <FileChangeProgressBar
+        progress={makeProgress({
+          filesChanged: 1,
+          linesAdded: 0,
+          linesRemoved: 0,
+          entries: [makeEntry({ pathAfter: "one.ts" })],
+        })}
+      />,
+    );
+    // No "+" anywhere means no stat rendered; the count copy carries none.
+    expect(lastFrame() ?? "").not.toContain("+");
+  });
+});
+
+// --- FileChangeProgressBar: expansion -------------------------------------
+
+describe("FileChangeProgressBar — expansion", () => {
+  const progress = makeProgress({
+    filesChanged: 2,
+    linesAdded: 8,
+    linesRemoved: 1,
+    entries: [
+      makeEntry({ pathAfter: "src/app.ts", linesAdded: 5, linesRemoved: 1 }),
+      makeEntry({ pathAfter: "src/util.ts", linesAdded: 3, linesRemoved: 0 }),
+    ],
+  });
+
+  it("hides the per-file list when collapsed (default)", () => {
+    const { lastFrame } = render(<FileChangeProgressBar progress={progress} />);
+    const out = lastFrame() ?? "";
+    expect(out).toContain("2 files changing");
+    expect(out).not.toContain("src/app.ts");
+    expect(out).not.toContain("src/util.ts");
+  });
+
+  it("shows the per-file list with kind letter, path, and stats when expanded", () => {
+    const { lastFrame } = render(
+      <FileChangeProgressBar progress={progress} expanded />,
+    );
+    const out = lastFrame() ?? "";
+    expect(out).toContain("src/app.ts");
+    expect(out).toContain("src/util.ts");
+    expect(out).toContain("M"); // MODIFY kind letter
+    expect(out).toContain("+5");
+    expect(out).toContain("+3");
+  });
+
+  it("shows '… and K more' when the entry list is capped below the true total", () => {
+    const capped = makeProgress({
+      filesChanged: 5,
+      entries: [
+        makeEntry({ pathAfter: "a.ts" }),
+        makeEntry({ pathAfter: "b.ts" }),
+      ],
+    });
+    const { lastFrame } = render(
+      <FileChangeProgressBar progress={capped} expanded />,
+    );
+    expect(lastFrame() ?? "").toContain("and 3 more");
+  });
+
+  it("renders a rename entry as 'before → after'", () => {
+    const renamed = makeProgress({
+      filesChanged: 1,
+      entries: [
+        makeEntry({
+          pathBefore: "old/name.ts",
+          pathAfter: "new/name.ts",
+          kind: FileChangeKind.RENAME,
+        }),
+      ],
+    });
+    const { lastFrame } = render(
+      <FileChangeProgressBar progress={renamed} expanded />,
+    );
+    expect(lastFrame() ?? "").toContain("old/name.ts → new/name.ts");
+  });
+
+  it("hides per-file stats for a withheld entry (zero counts)", () => {
+    const secretish = makeProgress({
+      filesChanged: 1,
+      entries: [makeEntry({ pathAfter: ".env", linesAdded: 0, linesRemoved: 0 })],
+    });
+    const { lastFrame } = render(
+      <FileChangeProgressBar progress={secretish} expanded />,
+    );
+    const out = lastFrame() ?? "";
+    expect(out).toContain(".env");
+    expect(out).not.toContain("+");
+  });
+});
+
+// --- path helpers (direct unit coverage) ----------------------------------
+
+interface ChangeOpts {
+  readonly pathBefore?: string;
+  readonly pathAfter?: string;
+  readonly kind: FileChangeKind;
+}
+
+function makeChange(opts: ChangeOpts) {
+  return create(CapturedFileChangeSchema, {
+    id: "c-1",
+    pathBefore: opts.pathBefore ?? "",
+    pathAfter: opts.pathAfter ?? "",
+    kind: opts.kind,
+  });
+}
+
+describe("changeDisplayPath", () => {
+  it("shows the after-path for an add", () => {
+    expect(
+      changeDisplayPath(makeChange({ pathAfter: "new.ts", kind: FileChangeKind.ADD })),
+    ).toBe("new.ts");
+  });
+
+  it("shows the after-path for a modify", () => {
+    expect(
+      changeDisplayPath(
+        makeChange({ pathAfter: "app.ts", kind: FileChangeKind.MODIFY }),
+      ),
+    ).toBe("app.ts");
+  });
+
+  it("falls back to the before-path for a delete", () => {
+    expect(
+      changeDisplayPath(
+        makeChange({ pathBefore: "gone.ts", kind: FileChangeKind.DELETE }),
+      ),
+    ).toBe("gone.ts");
+  });
+
+  it("shows 'before → after' for a rename", () => {
+    expect(
+      changeDisplayPath(
+        makeChange({
+          pathBefore: "old.ts",
+          pathAfter: "new.ts",
+          kind: FileChangeKind.RENAME,
+        }),
+      ),
+    ).toBe("old.ts → new.ts");
+  });
+});
+
+describe("progressEntryDisplayPath", () => {
+  it("shows the after-path for an add", () => {
+    expect(
+      progressEntryDisplayPath(makeEntry({ pathAfter: "new.ts", kind: FileChangeKind.ADD })),
+    ).toBe("new.ts");
+  });
+
+  it("shows the after-path for a modify", () => {
+    expect(
+      progressEntryDisplayPath(makeEntry({ pathAfter: "app.ts" })),
+    ).toBe("app.ts");
+  });
+
+  it("falls back to the before-path for a delete", () => {
+    expect(
+      progressEntryDisplayPath(
+        makeEntry({ pathBefore: "gone.ts", kind: FileChangeKind.DELETE }),
+      ),
+    ).toBe("gone.ts");
+  });
+
+  it("shows 'before → after' for a rename — identical to changeDisplayPath", () => {
+    expect(
+      progressEntryDisplayPath(
+        makeEntry({
+          pathBefore: "old.ts",
+          pathAfter: "new.ts",
+          kind: FileChangeKind.RENAME,
+        }),
+      ),
+    ).toBe("old.ts → new.ts");
+  });
+});

package/src/__tests__/file-review.test.tsx

@@ -6,8 +6,10 @@ import { FileReviewContext } from "@stigmer/react";
 import {
   ToolCallSchema,
   FileContentSchema,
+  ToolCallOutputRefSchema,
   AgentMessageSchema,
 } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import type { FileContent } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
 import type { ToolCall } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
 import {
   FileChangeSetSchema,
@@ -30,7 +32,11 @@ import { ToolCallItem } from "../components/ToolCallItem.js";
 import { ToolCallGroup } from "../components/ToolCallGroup.js";
 import { FileReviewPrompt } from "../components/FileReviewPrompt.js";
 import { FileReviewRecord } from "../components/FileReviewRecord.js";
+import { FileDiffBody } from "../components/FileDiffBody.js";
 import { MessageThread } from "../components/MessageThread.js";
+import { FileLineStats } from "../components/FileReviewAtoms.js";
+import { changeSetLineStats } from "../file-review.js";
+import { fakeClient, renderWithClient } from "./test-support.js";
 
 // --- fixtures -------------------------------------------------------------
 
@@ -41,6 +47,8 @@ interface ChangeOpts {
   readonly diffComplete?: boolean;
   readonly binary?: boolean;
   readonly blockedReason?: FileReviewBlockReason;
+  readonly linesAdded?: number;
+  readonly linesRemoved?: number;
 }
 
 function makeChange(opts: ChangeOpts) {
@@ -52,6 +60,8 @@ function makeChange(opts: ChangeOpts) {
     diffComplete: opts.diffComplete ?? true,
     fileDigest: `fd-${opts.id}`,
     blockedReason: opts.blockedReason ?? FileReviewBlockReason.UNSPECIFIED,
+    linesAdded: opts.linesAdded ?? 0,
+    linesRemoved: opts.linesRemoved ?? 0,
     before: opts.binary ? create(FileContentSchema, { isBinary: true }) : undefined,
     after: opts.binary ? create(FileContentSchema, { isBinary: true }) : undefined,
   });
@@ -215,7 +225,9 @@ describe("FileReviewPrompt — per-file", () => {
 
   it("enters per-file mode and keeps a reviewable file with its file digest", async () => {
     const onSubmit = vi.fn();
-    const { stdin, lastFrame } = render(
+    // Per-file mode mounts FileDiffBody, whose useFileChangeContent reads the
+    // Stigmer client — so these tests render under a provider.
+    const { stdin, lastFrame } = renderWithClient(
       <FileReviewPrompt changeSet={blockedSet} onSubmit={onSubmit} />,
     );
     stdin.write("f");
@@ -235,7 +247,7 @@ describe("FileReviewPrompt — per-file", () => {
 
   it("refuses to keep an unavailable file but allows discard", async () => {
     const onSubmit = vi.fn();
-    const { stdin } = render(
+    const { stdin } = renderWithClient(
       <FileReviewPrompt changeSet={blockedSet} onSubmit={onSubmit} />,
     );
     stdin.write("f");
@@ -262,7 +274,7 @@ describe("FileReviewPrompt — per-file", () => {
       ],
     });
     const onSubmit = vi.fn();
-    const { stdin } = render(
+    const { stdin } = renderWithClient(
       <FileReviewPrompt changeSet={binarySet} onSubmit={onSubmit} />,
     );
     stdin.write("f");
@@ -494,3 +506,306 @@ describe("MessageThread — file-review integration", () => {
     expect(out).not.toContain("File review —"); // but no settled record
   });
 });
+
+// --- FileLineStats (shared atom) -----------------------------------------
+
+describe("FileLineStats", () => {
+  it("renders nothing when both counts are zero (never +0 -0)", () => {
+    const { lastFrame } = render(<FileLineStats linesAdded={0} linesRemoved={0} />);
+    expect((lastFrame() ?? "").trim()).toBe("");
+  });
+
+  it("renders +N -M when counts exist", () => {
+    const { lastFrame } = render(<FileLineStats linesAdded={7} linesRemoved={3} />);
+    const out = lastFrame() ?? "";
+    expect(out).toContain("+7");
+    expect(out).toContain("-3");
+  });
+
+  it("renders a one-sided stat (added only) without hiding it", () => {
+    const { lastFrame } = render(<FileLineStats linesAdded={5} linesRemoved={0} />);
+    const out = lastFrame() ?? "";
+    expect(out).toContain("+5");
+    expect(out).toContain("-0"); // both sides always shown once any count exists
+  });
+});
+
+// --- changeSetLineStats (pure helper) ------------------------------------
+
+describe("changeSetLineStats", () => {
+  it("sums per-file counts across the set", () => {
+    const set = makeSet({
+      status: FileChangeSetStatus.RECONCILED,
+      changes: [
+        makeChange({ id: "a", path: "one.ts", linesAdded: 10, linesRemoved: 2 }),
+        makeChange({ id: "b", path: "two.ts", linesAdded: 5, linesRemoved: 3 }),
+      ],
+    });
+    expect(changeSetLineStats(set)).toEqual({ linesAdded: 15, linesRemoved: 5 });
+  });
+
+  it("treats an uncountable (binary/withheld) file as a zero contributor — honest understatement", () => {
+    const set = makeSet({
+      status: FileChangeSetStatus.AWAITING_REVIEW,
+      changes: [
+        makeChange({ id: "txt", path: "app.ts", linesAdded: 8, linesRemoved: 1 }),
+        makeChange({ id: "img", path: "logo.png", kind: FileChangeKind.BINARY_CHANGE, binary: true }),
+      ],
+    });
+    expect(changeSetLineStats(set)).toEqual({ linesAdded: 8, linesRemoved: 1 });
+  });
+
+  it("is zero for a set whose files carry no counts (stat then hidden by the atom)", () => {
+    const set = makeSet({
+      status: FileChangeSetStatus.RECONCILED,
+      changes: [makeChange({ id: "a", path: "one.ts" })],
+    });
+    expect(changeSetLineStats(set)).toEqual({ linesAdded: 0, linesRemoved: 0 });
+  });
+});
+
+// --- Line stats on the review surfaces -----------------------------------
+
+describe("FileReviewPrompt — line stats", () => {
+  it("shows the set aggregate +N -M on the header", () => {
+    const set = makeSet({
+      status: FileChangeSetStatus.AWAITING_REVIEW,
+      changes: [
+        makeChange({ id: "a", path: "one.ts", linesAdded: 12, linesRemoved: 3 }),
+        makeChange({ id: "b", path: "two.ts", linesAdded: 4, linesRemoved: 1 }),
+      ],
+    });
+    const out = render(<FileReviewPrompt changeSet={set} onSubmit={() => {}} />).lastFrame() ?? "";
+    expect(out).toContain("2 files awaiting review");
+    expect(out).toContain("+16");
+    expect(out).toContain("-4");
+  });
+
+  it("hides the header aggregate when no file has counts (never +0 -0)", () => {
+    const set = makeSet({
+      status: FileChangeSetStatus.AWAITING_REVIEW,
+      changes: [makeChange({ id: "a", path: "one.ts" })],
+    });
+    const out = render(<FileReviewPrompt changeSet={set} onSubmit={() => {}} />).lastFrame() ?? "";
+    expect(out).not.toContain("+");
+  });
+
+  it("shows per-file +N -M in per-file mode", async () => {
+    const set = makeSet({
+      status: FileChangeSetStatus.AWAITING_REVIEW,
+      changes: [
+        makeChange({ id: "a", path: "one.ts", linesAdded: 10, linesRemoved: 2 }),
+        makeChange({ id: "b", path: "two.ts", linesAdded: 4, linesRemoved: 0 }),
+      ],
+    });
+    const { stdin, lastFrame } = renderWithClient(
+      <FileReviewPrompt changeSet={set} onSubmit={() => {}} />,
+    );
+    stdin.write("f");
+    await tick();
+    const out = lastFrame() ?? "";
+    expect(out).toContain("+10");
+    expect(out).toContain("+4");
+  });
+});
+
+describe("FileReviewRecord — line stats", () => {
+  it("shows the set aggregate and per-file +N -M", () => {
+    const set = makeSet({
+      status: FileChangeSetStatus.RECONCILED,
+      changes: [
+        makeChange({ id: "a", path: "one.ts", linesAdded: 9, linesRemoved: 2 }),
+        makeChange({ id: "b", path: "two.ts", linesAdded: 3, linesRemoved: 1 }),
+      ],
+      decisions: [
+        { scope: FileDecisionScope.CHANGE_SET, action: FileDecisionAction.APPROVE },
+      ],
+    });
+    const out = render(<FileReviewRecord fileChangeSet={set} />).lastFrame() ?? "";
+    expect(out).toContain("+12"); // aggregate 9+3
+    expect(out).toContain("+9"); // per-file
+    expect(out).toContain("+3"); // per-file
+  });
+
+  it("renders no stat when the set carries no counts", () => {
+    const set = makeSet({
+      status: FileChangeSetStatus.RECONCILED,
+      changes: [makeChange({ id: "a", path: "one.ts" })],
+    });
+    expect(render(<FileReviewRecord fileChangeSet={set} />).lastFrame() ?? "").not.toContain("+");
+  });
+});
+
+// --- FileDiffBody ---------------------------------------------------------
+
+/**
+ * Polls the rendered frame until it contains `needle`, then returns. Replaces a
+ * fixed sleep: an artifact fetch resolves on its own microtask schedule (and a
+ * truncated side chains a second download-url fetch), so any single delay raced
+ * green locally but timed out under CI load. Polling waits exactly as long as
+ * the render needs and no longer, and fails with the actual frame on timeout.
+ */
+async function waitForFrame(
+  lastFrame: () => string | undefined,
+  needle: string,
+  timeoutMs = 2000,
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    if ((lastFrame() ?? "").includes(needle)) return;
+    if (Date.now() >= deadline) {
+      throw new Error(
+        `waitForFrame timed out after ${timeoutMs}ms waiting for ${JSON.stringify(
+          needle,
+        )}; last frame was ${JSON.stringify(lastFrame() ?? "")}`,
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+}
+
+function inlineSide(text: string): FileContent {
+  return create(FileContentSchema, { body: { case: "inline", value: text } });
+}
+
+function offloadedSide(storageKey: string, contentHash = "h"): FileContent {
+  return create(FileContentSchema, {
+    body: {
+      case: "ref",
+      value: create(ToolCallOutputRefSchema, { storageKey, contentHash }),
+    },
+  });
+}
+
+function changeWith(opts: {
+  id: string;
+  kind?: FileChangeKind;
+  before?: FileContent;
+  after?: FileContent;
+}) {
+  return create(CapturedFileChangeSchema, {
+    id: opts.id,
+    pathAfter: "file.ts",
+    pathBefore: "file.ts",
+    kind: opts.kind ?? FileChangeKind.MODIFY,
+    fileDigest: `fd-${opts.id}`,
+    before: opts.before,
+    after: opts.after,
+  });
+}
+
+describe("FileDiffBody", () => {
+  it("renders +/- lines for an inline whole-file diff (computeDiff parity)", () => {
+    const change = changeWith({
+      id: "m",
+      before: inlineSide("keep\nold\ntail\n"),
+      after: inlineSide("keep\nnew\ntail\n"),
+    });
+    const out = renderWithClient(<FileDiffBody change={change} />).lastFrame() ?? "";
+    expect(out).toContain("-old"); // removed, red
+    expect(out).toContain("+new"); // added, green
+    expect(out).toContain("keep"); // context retained
+  });
+
+  it("shows 'Binary file changed.' for a binary side", () => {
+    const change = create(CapturedFileChangeSchema, {
+      id: "bin",
+      pathAfter: "logo.png",
+      pathBefore: "logo.png",
+      kind: FileChangeKind.BINARY_CHANGE,
+      before: create(FileContentSchema, { isBinary: true }),
+      after: create(FileContentSchema, { isBinary: true }),
+    });
+    const out = renderWithClient(<FileDiffBody change={change} />).lastFrame() ?? "";
+    expect(out).toContain("Binary file changed.");
+  });
+
+  it("labels a genuinely empty new file (CREATE with no content)", () => {
+    const change = changeWith({ id: "new", kind: FileChangeKind.ADD, after: inlineSide("") });
+    const out = renderWithClient(<FileDiffBody change={change} />).lastFrame() ?? "";
+    expect(out).toContain("Empty new file.");
+  });
+
+  it("falls back to 'No preview available.' for a MODIFY with no renderable diff", () => {
+    const change = changeWith({ id: "np" }); // no before/after content
+    const out = renderWithClient(<FileDiffBody change={change} />).lastFrame() ?? "";
+    expect(out).toContain("No preview available.");
+  });
+
+  it("shows a loading notice while an offloaded side is in flight", () => {
+    const change = changeWith({ id: "load", after: offloadedSide("artifacts/aex-1/after") });
+    const client = fakeClient({
+      agentExecution: { getArtifactContent: () => new Promise(() => {}) },
+    });
+    const out = renderWithClient(<FileDiffBody change={change} />, client).lastFrame() ?? "";
+    expect(out).toContain("Loading diff");
+  });
+
+  it("reports a server-truncated offloaded side as un-diffable inline", async () => {
+    const change = changeWith({ id: "trunc", after: offloadedSide("artifacts/aex-1/after") });
+    const client = fakeClient({
+      agentExecution: {
+        getArtifactContent: async () => ({
+          content: new TextEncoder().encode("way too big"),
+          contentType: "text/plain",
+          truncated: true,
+        }),
+        // A truncated side activates useArtifactDownloadUrl (the notice offers a
+        // full-file download). Stub it so the fetch resolves instead of throwing
+        // on an undefined method — an unstubbed throw unmounts the ink tree and
+        // blanks the frame, which raced green locally but failed under CI load.
+        getArtifactDownloadUrl: async () => ({ downloadUrl: "https://example.test/full" }),
+      },
+    });
+    const { lastFrame } = renderWithClient(<FileDiffBody change={change} />, client);
+    await waitForFrame(lastFrame, "too large to diff inline");
+    expect(lastFrame() ?? "").toContain("too large to diff inline");
+  });
+
+  it("surfaces a fetch failure as an honest error notice", async () => {
+    const change = changeWith({ id: "err", after: offloadedSide("artifacts/aex-1/after") });
+    const client = fakeClient({
+      agentExecution: {
+        getArtifactContent: async () => {
+          throw new Error("boom");
+        },
+      },
+    });
+    const { lastFrame } = renderWithClient(<FileDiffBody change={change} />, client);
+    await waitForFrame(lastFrame, "Could not load this file's contents.");
+    expect(lastFrame() ?? "").toContain("Could not load this file's contents.");
+  });
+
+  it("caps an oversized diff and reports the overflow", () => {
+    const many = Array.from({ length: 250 }, (_, i) => `line ${i}`).join("\n");
+    const change = changeWith({ id: "big", before: inlineSide(""), after: inlineSide(`${many}\n`) });
+    const out = renderWithClient(<FileDiffBody change={change} />).lastFrame() ?? "";
+    expect(out).toMatch(/… \d+ more lines/);
+  });
+});
+
+describe("FileReviewPrompt — inline diff (master-detail)", () => {
+  it("shows only the selected file's diff and follows the selection", async () => {
+    const set = makeSet({
+      status: FileChangeSetStatus.AWAITING_REVIEW,
+      changes: [
+        changeWith({ id: "a", before: inlineSide("alpha\n"), after: inlineSide("ALPHA\n") }),
+        changeWith({ id: "b", before: inlineSide("bravo\n"), after: inlineSide("BRAVO\n") }),
+      ],
+    });
+    const { stdin, lastFrame } = renderWithClient(
+      <FileReviewPrompt changeSet={set} onSubmit={() => {}} />,
+    );
+    stdin.write("f");
+    await tick();
+    const first = lastFrame() ?? "";
+    expect(first).toContain("+ALPHA"); // selected file's diff
+    expect(first).not.toContain("+BRAVO"); // the other file's diff is not mounted
+
+    stdin.write("\u001B[B"); // down → select the second file
+    await tick();
+    const second = lastFrame() ?? "";
+    expect(second).toContain("+BRAVO");
+    expect(second).not.toContain("+ALPHA");
+  });
+});

package/src/__tests__/test-support.tsx

@@ -0,0 +1,25 @@
+import React, { type ReactElement } from "react";
+import { render } from "ink-testing-library";
+import type { Stigmer } from "@stigmer/sdk";
+import { InkStigmerProvider } from "../provider.js";
+
+/**
+ * Builds a minimal Stigmer stub exposing only the methods a test's hooks call.
+ * Anything not overridden is absent, so a test that touches an unstubbed method
+ * fails loudly rather than silently no-op'ing.
+ */
+export function fakeClient(overrides: Record<string, unknown> = {}): Stigmer {
+  return overrides as unknown as Stigmer;
+}
+
+/**
+ * Renders a tree under an {@link InkStigmerProvider} so hooks that read the
+ * Stigmer client (e.g. `useFileChangeContent` → `useStigmer`, which throws
+ * without a provider) work. Returns the `ink-testing-library` handle.
+ */
+export function renderWithClient(
+  node: ReactElement,
+  client: Stigmer = fakeClient(),
+) {
+  return render(<InkStigmerProvider client={client}>{node}</InkStigmerProvider>);
+}