@stigmer/react 3.1.2 → 3.1.3

package/src/execution/__tests__/FileChangeProgressBar.test.tsx

@@ -0,0 +1,125 @@
+/**
+ * FileChangeProgressBar — the live "N files changed so far" strip for a running
+ * turn (DD-32). These tests cover its own responsibilities: emptiness, the
+ * summary count + aggregate stat, the expandable per-file list with its cap
+ * overflow, zero-count hiding, and that only the count is an aria-live region.
+ */
+
+import { describe, it, expect, afterEach } from "vitest";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  FileChangeProgressSchema,
+  FileChangeProgressEntrySchema,
+  type FileChangeProgress,
+} 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 "../FileChangeProgressBar";
+
+function entry(path: string, kind: FileChangeKind, added: number, removed: number) {
+  return create(FileChangeProgressEntrySchema, {
+    pathBefore: kind === FileChangeKind.ADD ? "" : path,
+    pathAfter: kind === FileChangeKind.DELETE ? "" : path,
+    kind,
+    linesAdded: added,
+    linesRemoved: removed,
+  });
+}
+
+function progress(overrides: Partial<FileChangeProgress> = {}): FileChangeProgress {
+  return create(FileChangeProgressSchema, {
+    changeSetId: "exec:0",
+    filesChanged: 2,
+    linesAdded: 7,
+    linesRemoved: 3,
+    entries: [
+      entry("src/a.ts", FileChangeKind.ADD, 5, 0),
+      entry("src/b.ts", FileChangeKind.MODIFY, 2, 3),
+    ],
+    capturedAt: "2026-07-05T00:00:00Z",
+    ...overrides,
+  });
+}
+
+afterEach(() => cleanup());
+
+describe("FileChangeProgressBar", () => {
+  it("renders nothing when progress is undefined", () => {
+    const { container } = render(<FileChangeProgressBar progress={undefined} />);
+    expect(container.firstChild).toBeNull();
+  });
+
+  it("renders nothing when zero files have changed (revert-to-clean)", () => {
+    const { container } = render(
+      <FileChangeProgressBar
+        progress={progress({ filesChanged: 0, entries: [], linesAdded: 0, linesRemoved: 0 })}
+      />,
+    );
+    expect(container.firstChild).toBeNull();
+  });
+
+  it("shows the summary count and aggregate +N −M", () => {
+    render(<FileChangeProgressBar progress={progress()} />);
+    expect(screen.getByText(/2 files changing/)).toBeTruthy();
+    expect(screen.getByText("+7")).toBeTruthy();
+    expect(screen.getByText("-3")).toBeTruthy();
+  });
+
+  it("uses the singular noun for a single file", () => {
+    render(
+      <FileChangeProgressBar
+        progress={progress({ filesChanged: 1, entries: [entry("only.ts", FileChangeKind.ADD, 1, 0)] })}
+      />,
+    );
+    expect(screen.getByText(/1 file changing/)).toBeTruthy();
+  });
+
+  it("puts only the count in an aria-live region, not the per-file list", () => {
+    render(<FileChangeProgressBar progress={progress()} />);
+    const live = screen.getByText(/2 files changing/);
+    expect(live.getAttribute("aria-live")).toBe("polite");
+    // The expandable list is not part of any live region.
+    fireEvent.click(screen.getByRole("button", { name: /2 files changing/ }));
+    const link = screen.getByText("a.ts");
+    expect(link.closest("[aria-live]")).toBeNull();
+  });
+
+  it("expands to a per-file list on click and collapses again", () => {
+    render(<FileChangeProgressBar progress={progress()} />);
+    expect(screen.queryByText("a.ts")).toBeNull();
+
+    const toggle = screen.getByRole("button", { name: /2 files changing/ });
+    fireEvent.click(toggle);
+    expect(screen.getByText("a.ts")).toBeTruthy();
+    expect(screen.getByText("b.ts")).toBeTruthy();
+    expect(toggle.getAttribute("aria-expanded")).toBe("true");
+
+    fireEvent.click(toggle);
+    expect(screen.queryByText("a.ts")).toBeNull();
+  });
+
+  it("shows an honest overflow line when the entry list is capped", () => {
+    // 5 files changed but only 2 entries carried → "… and 3 more".
+    render(<FileChangeProgressBar progress={progress({ filesChanged: 5 })} />);
+    fireEvent.click(screen.getByRole("button", { name: /5 files changing/ }));
+    expect(screen.getByText(/and 3 more/)).toBeTruthy();
+  });
+
+  it("hides the per-file stat when both counts are zero (binary/secret)", () => {
+    render(
+      <FileChangeProgressBar
+        progress={progress({
+          filesChanged: 1,
+          linesAdded: 0,
+          linesRemoved: 0,
+          entries: [entry(".env", FileChangeKind.MODIFY, 0, 0)],
+        })}
+      />,
+    );
+    fireEvent.click(screen.getByRole("button", { name: /1 file changing/ }));
+    // The secret path is present…
+    expect(screen.getByText(".env")).toBeTruthy();
+    // …but no +0 −0 stat is rendered anywhere.
+    expect(screen.queryByText("+0")).toBeNull();
+  });
+});

package/src/execution/__tests__/FileReviewCard.test.tsx

@@ -248,6 +248,16 @@ describe("FileReviewCard", () => {
   });
 
   describe("multi-file set (per-file controls)", () => {
+    it("starts a complete multi-file set collapsed in diff mode — auto-expansion is list-mode only", () => {
+      // Diff mode's expanded body is every full diff with NO height cap (the
+      // workflow file-review list); auto-expanding a multi-file set there
+      // would dump every diff open on mount. Only the compact list mode
+      // (showDiffs=false, the dock) starts multi-file sets expanded.
+      render(<FileReviewCard fileChangeSet={multiChangeSet()} onSubmit={noop} />);
+      expect(document.querySelector('[data-cursor-target="file-diff"]')).toBeNull();
+      expect(screen.getByRole("button", { name: "Review" })).toBeTruthy();
+    });
+
     it("renders a Keep/Discard radio per file plus whole-set controls", () => {
       render(<FileReviewCard fileChangeSet={multiChangeSet()} onSubmit={noop} />);
       expandCard();
@@ -848,11 +858,12 @@ describe("FileReviewCard", () => {
   // cases mirror the decision cases above without the diff DOM. The default
   // (showDiffs unset) stays covered by every other suite in this file.
   describe("list mode (showDiffs=false)", () => {
+    /** Open a still-collapsed card's file inventory (single complete file). */
     function expandFiles() {
       fireEvent.click(screen.getByRole("button", { name: "Files" }));
     }
 
-    it("labels the expander 'Files' and renders inert list rows with no diff DOM", () => {
+    it("starts a multi-file set expanded — the per-file controls are the honest decision surface", () => {
       render(
         <FileReviewCard
           fileChangeSet={multiChangeSet()}
@@ -860,17 +871,65 @@ describe("FileReviewCard", () => {
           showDiffs={false}
         />,
       );
-      expandFiles();
+      // No expander click: the list rows and per-file controls are immediately
+      // visible, with no diff DOM (the transcript's stamped rows own the diffs).
       expect(document.querySelector('[data-cursor-target="file-diff"]')).toBeNull();
       expect(
         document.querySelectorAll('[data-cursor-target="file-review-list-row"]'),
       ).toHaveLength(2);
-      // Filename-first path text, full path available on hover — and no
-      // link/copy affordance (the list is an inventory, not navigation).
+      expect(screen.getByRole("button", { name: "Hide" })).toBeTruthy();
+      // Filename-first linked path (FilePathLink: copy fallback without a
+      // provider — an accessible button, never a bare span), full path on hover.
       expect(screen.getByText("a.ts")).toBeTruthy();
       expect(screen.getByText("b.ts")).toBeTruthy();
+      expect(screen.getByRole("button", { name: /Copy path: src\/a\.ts/ })).toBeTruthy();
       expect(screen.getByTitle("src/a.ts")).toBeTruthy();
-      expect(screen.queryByRole("link")).toBeNull();
+    });
+
+    it("keeps a single complete file collapsed behind the 'Files' expander", () => {
+      render(
+        <FileReviewCard fileChangeSet={changeSet()} onSubmit={noop} showDiffs={false} />,
+      );
+      expect(
+        document.querySelector('[data-cursor-target="file-review-list-row"]'),
+      ).toBeNull();
+      fireEvent.click(screen.getByRole("button", { name: "Files" }));
+      expect(
+        document.querySelector('[data-cursor-target="file-review-list-row"]'),
+      ).toBeTruthy();
+    });
+
+    it("shows per-file +N −M from the capture-time counts, hiding the stat when no count exists", () => {
+      const counted = create(CapturedFileChangeSchema, {
+        id: "fc1",
+        pathBefore: "src/a.ts",
+        pathAfter: "src/a.ts",
+        kind: FileChangeKind.MODIFY,
+        captureClass: FileCaptureClass.GIT_TRACKED,
+        before: inline("old\n"),
+        after: inline("new\n"),
+        fileDigest: "d-fc1",
+        diffComplete: true,
+        linesAdded: 37,
+        linesRemoved: 2,
+      });
+      render(
+        <FileReviewCard
+          fileChangeSet={multiChangeSet({ fc1: counted })}
+          onSubmit={noop}
+          showDiffs={false}
+        />,
+      );
+      const rows = document.querySelectorAll('[data-cursor-target="file-review-list-row"]');
+      // fc1 carries counts; fc2 (legacy fixture, zero counts) shows no stat —
+      // never a misleading "+0 -0". The bar also aggregates the set's counts,
+      // so exactly two stats render: the bar's and fc1's row.
+      const stats = document.querySelectorAll('[data-cursor-target="file-review-line-stats"]');
+      expect(rows).toHaveLength(2);
+      expect(stats).toHaveLength(2);
+      expect(stats[0].textContent).toBe("+37 -2");
+      expect(stats[1].textContent).toBe("+37 -2");
+      expect(screen.getAllByLabelText("37 added, 2 removed")).toHaveLength(2);
     });
 
     it("marks each file with its change-kind letter (A/M/D)", () => {
@@ -899,7 +958,7 @@ describe("FileReviewCard", () => {
           showDiffs={false}
         />,
       );
-      expandFiles();
+      // A multi-file list-mode set starts expanded — the letters are visible.
       expect(screen.getByLabelText("added").textContent).toBe("A");
       expect(screen.getByLabelText("deleted").textContent).toBe("D");
     });
@@ -937,7 +996,7 @@ describe("FileReviewCard", () => {
           showDiffs={false}
         />,
       );
-      expandFiles();
+      // Starts expanded (multi-file list mode) — the row control is live.
       fireEvent.click(screen.getByRole("radio", { name: "Keep src/a.ts" }));
       expect(onSubmit).toHaveBeenCalledWith(FileDecisionAction.APPROVE, {
         scope: FileDecisionScope.FILE,

package/src/execution/__tests__/MessageThread.test.tsx

@@ -844,7 +844,7 @@ describe("MessageThread", () => {
       />,
     );
 
-    const buildBtn = screen.getByRole("button", { name: /build from plan/i });
+    const buildBtn = screen.getByRole("button", { name: "Build" });
     expect(buildBtn).toBeTruthy();
 
     fireEvent.click(buildBtn);

package/src/execution/__tests__/PlanArtifactCard.test.tsx

@@ -85,7 +85,7 @@ describe("PlanArtifactCard — compact document card", () => {
     expect(getArtifactContent).not.toHaveBeenCalled();
   });
 
-  it("offers exactly one primary 'Build from plan' action that calls onImplement", () => {
+  it("offers exactly one primary 'Build' action that calls onImplement", () => {
     const onImplement = vi.fn();
     renderCard(
       <PlanArtifactCard
@@ -96,15 +96,15 @@ describe("PlanArtifactCard — compact document card", () => {
       />,
     );
 
-    fireEvent.click(screen.getByText("Build from plan"));
+    fireEvent.click(screen.getByRole("button", { name: "Build" }));
     expect(onImplement).toHaveBeenCalledTimes(1);
   });
 
-  it("hides 'Build from plan' when onImplement is not provided", () => {
+  it("hides 'Build' when onImplement is not provided", () => {
     renderCard(
       <PlanArtifactCard executionId="aex_1" artifact={planArtifact} org="acme" />,
     );
-    expect(screen.queryByText("Build from plan")).toBeNull();
+    expect(screen.queryByRole("button", { name: "Build" })).toBeNull();
   });
 
   it("shows the pending label while the approved plan uploads (buildPending)", () => {
@@ -121,12 +121,12 @@ describe("PlanArtifactCard — compact document card", () => {
 
     // The primary reads as in-progress and stays disabled — no double-submits
     // while the upload precedes the implement turn.
-    expect(screen.queryByText("Build from plan")).toBeNull();
+    expect(screen.queryByRole("button", { name: "Build" })).toBeNull();
     const button = screen.getByText("Starting build…").closest("button")!;
     expect(button.disabled).toBe(true);
   });
 
-  it("disables 'Build from plan' when disabled", () => {
+  it("disables 'Build' when disabled", () => {
     const onImplement = vi.fn();
     renderCard(
       <PlanArtifactCard
@@ -138,12 +138,44 @@ describe("PlanArtifactCard — compact document card", () => {
       />,
     );
 
-    const button = screen.getByText("Build from plan").closest("button")!;
+    const button = screen.getByRole("button", { name: "Build" }) as HTMLButtonElement;
     expect(button.disabled).toBe(true);
     fireEvent.click(button);
     expect(onImplement).not.toHaveBeenCalled();
   });
 
+  it("copies the plan text to the clipboard on demand", async () => {
+    const writeText = vi.fn().mockResolvedValue(undefined);
+    vi.stubGlobal("navigator", { clipboard: { writeText } });
+    const getArtifactContent = vi
+      .fn()
+      .mockResolvedValue({ content: new TextEncoder().encode("# Plan\n\nsteps") });
+    const getArtifactDownloadUrl = vi.fn();
+    const stigmer = {
+      agentExecution: { getArtifactContent, getArtifactDownloadUrl },
+    } as unknown as Stigmer;
+
+    render(
+      withStigmer(
+        <PlanArtifactCard executionId="aex_1" artifact={planArtifact} org="acme" />,
+        stigmer,
+      ),
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Copy plan" }));
+
+    // Content is fetched at click time from the stable storage key, then
+    // written to the clipboard — the card never pre-fetches on mount.
+    expect(getArtifactContent).toHaveBeenCalledTimes(1);
+    const req = getArtifactContent.mock.calls[0][0];
+    expect(req.executionId).toBe("aex_1");
+    expect(req.storageKey).toBe("artifacts/aex_1/plan.md");
+    await screen.findByRole("button", { name: "Copied" });
+    expect(writeText).toHaveBeenCalledWith("# Plan\n\nsteps");
+
+    vi.unstubAllGlobals();
+  });
+
   it("downloads the artifact on demand via a freshly minted URL", async () => {
     const { stigmer, getArtifactDownloadUrl } = createStigmerMock();
     render(
@@ -152,7 +184,7 @@ describe("PlanArtifactCard — compact document card", () => {
         stigmer,
       ),
     );
-    fireEvent.click(screen.getByText("Download"));
+    fireEvent.click(screen.getByRole("button", { name: "Download plan.md" }));
     // The URL is resolved at click time from the stable storage key — never a
     // baked, expirable URL.
     expect(getArtifactDownloadUrl).toHaveBeenCalledTimes(1);
@@ -229,8 +261,8 @@ describe("PlanArtifactCard — Cmd/Ctrl+Enter accelerator (card-scoped)", () =>
   });
 });
 
-describe("PlanArtifactCard — Open full (org-gated preview)", () => {
-  it("opens the shared preview modal when 'Open full' is clicked", () => {
+describe("PlanArtifactCard — Open plan modal fallback (org-gated preview)", () => {
+  it("opens the shared preview modal when the open icon is clicked (no onOpenPlan)", () => {
     const { stigmer } = createStigmerMock();
     render(
       withStigmer(
@@ -242,14 +274,14 @@ describe("PlanArtifactCard — Open full (org-gated preview)", () => {
     // No dialog before the user opens it.
     expect(document.querySelector("dialog")).toBeNull();
 
-    fireEvent.click(screen.getByText("Open full"));
+    fireEvent.click(screen.getByRole("button", { name: "Open plan" }));
 
     const dialog = document.querySelector("dialog");
     expect(dialog).toBeTruthy();
     expect(dialog!.getAttribute("aria-label")).toBe("Preview plan.md");
   });
 
-  it("hides 'Open full' when org is absent (modal needs org), keeping Build + Download", () => {
+  it("hides the open action when org is absent (modal needs org), keeping Build + Download", () => {
     const onImplement = vi.fn();
     renderCard(
       <PlanArtifactCard
@@ -258,14 +290,16 @@ describe("PlanArtifactCard — Open full (org-gated preview)", () => {
         onImplement={onImplement}
       />,
     );
-    expect(screen.queryByText("Open full")).toBeNull();
-    expect(screen.queryByText("Build from plan")).not.toBeNull();
-    expect(screen.queryByText("Download")).not.toBeNull();
+    expect(screen.queryByRole("button", { name: "Open plan" })).toBeNull();
+    expect(screen.queryByRole("button", { name: "Build" })).not.toBeNull();
+    expect(
+      screen.queryByRole("button", { name: "Download plan.md" }),
+    ).not.toBeNull();
   });
 });
 
 describe("PlanArtifactCard — Open plan (panel-first review)", () => {
-  it("replaces the modal secondary with 'Open plan' when onOpenPlan is provided", () => {
+  it("routes the open action to the panel when onOpenPlan is provided (no modal)", () => {
     const onOpenPlan = vi.fn();
     renderCard(
       <PlanArtifactCard
@@ -277,9 +311,9 @@ describe("PlanArtifactCard — Open plan (panel-first review)", () => {
     );
 
     // One review affordance, not two: the facet supersedes the modal.
-    expect(screen.queryByText("Open full")).toBeNull();
+    expect(screen.getAllByRole("button", { name: "Open plan" })).toHaveLength(1);
 
-    fireEvent.click(screen.getByText("Open plan"));
+    fireEvent.click(screen.getByRole("button", { name: "Open plan" }));
     expect(onOpenPlan).toHaveBeenCalledTimes(1);
     expect(document.querySelector("dialog")).toBeNull();
   });

package/src/execution/__tests__/PlanCompletionCard.test.tsx

@@ -3,7 +3,7 @@ import { render, fireEvent, cleanup } from "@testing-library/react";
 import { PlanCompletionCard } from "../PlanCompletionCard";
 
 describe("PlanCompletionCard", () => {
-  it("renders the card with status text and a 'Build from plan' button", () => {
+  it("renders the card with status text and a 'Build' button", () => {
     const { container } = render(<PlanCompletionCard onImplement={() => {}} />);
 
     const root = container.firstElementChild as HTMLElement;
@@ -13,7 +13,7 @@ describe("PlanCompletionCard", () => {
 
     const button = root.querySelector("button");
     expect(button).toBeTruthy();
-    expect(button!.textContent).toContain("Build from plan");
+    expect(button!.textContent).toContain("Build");
 
     expect(root.textContent).toContain("Plan complete");
     cleanup();

package/src/execution/__tests__/PlanStreamingCard.test.tsx

@@ -5,7 +5,7 @@ import { PlanStreamingCard } from "../PlanStreamingCard";
 afterEach(cleanup);
 
 describe("PlanStreamingCard — live plan stand-in", () => {
-  it("is a busy region with the streaming title, filename, and live size", () => {
+  it("is a busy region with the streaming title, status, and live size", () => {
     render(
       <PlanStreamingCard
         title="Refactor the auth flow"
@@ -17,11 +17,18 @@ describe("PlanStreamingCard — live plan stand-in", () => {
     const region = screen.getByRole("region", { name: "Plan being written" });
     expect(region.getAttribute("aria-busy")).toBe("true");
     expect(region.textContent).toContain("Refactor the auth flow");
-    expect(region.textContent).toContain("plan.md");
     expect(region.textContent).toContain("Writing…");
     expect(region.textContent).toContain("2.0 KB");
   });
 
+  it("shows no filename mid-stream (the final name is not known yet)", () => {
+    render(
+      <PlanStreamingCard title="Refactor the auth flow" sizeBytes={2048} onOpenPlan={vi.fn()} />,
+    );
+    const region = screen.getByRole("region", { name: "Plan being written" });
+    expect(region.textContent).not.toContain("plan.md");
+  });
+
   it("falls back to 'Writing plan…' until the title has streamed in", () => {
     render(<PlanStreamingCard sizeBytes={12} onOpenPlan={vi.fn()} />);
     expect(screen.getByText("Writing plan…")).toBeTruthy();
@@ -37,8 +44,8 @@ describe("PlanStreamingCard — live plan stand-in", () => {
 
   it("offers no Download or Build actions — nothing final exists yet", () => {
     render(<PlanStreamingCard sizeBytes={64} onOpenPlan={vi.fn()} />);
-    expect(screen.queryByText("Download")).toBeNull();
-    expect(screen.queryByText("Build from plan")).toBeNull();
+    expect(screen.queryByRole("button", { name: /download/i })).toBeNull();
+    expect(screen.queryByText("Build")).toBeNull();
   });
 
   it("renders without an action when onOpenPlan is absent", () => {

package/src/execution/__tests__/buildThreadItems-plan-completion.test.ts

@@ -638,7 +638,7 @@ describe("buildThreadItems plan-writing (live streaming collapse)", () => {
   });
 });
 
-describe("buildThreadItems build-from-plan prompt", () => {
+describe("buildThreadItems build-from-plan prompt suppression", () => {
   function promptItem(items: readonly ThreadItem[], execId: string) {
     return items.find(
       (i): i is Extract<ThreadItem, { kind: "message" }> =>
@@ -646,7 +646,7 @@ describe("buildThreadItems build-from-plan prompt", () => {
     );
   }
 
-  it("stamps isBuildFromPlan on the prompt of a build turn", () => {
+  it("synthesizes NO prompt item for a build turn (the label is machine-written, not user prose)", () => {
     const exec = makeExecution({
       id: "exec-build",
       specMessage: "Build from plan",
@@ -656,14 +656,17 @@ describe("buildThreadItems build-from-plan prompt", () => {
     });
 
     const items = buildThreadItems([exec], null, null, false, undefined);
-    const prompt = promptItem(items, "exec-build");
 
-    expect(prompt).toBeDefined();
-    expect(prompt!.isBuildFromPlan).toBe(true);
-    expect(prompt!.message.content).toBe("Build from plan");
+    expect(promptItem(items, "exec-build")).toBeUndefined();
+    // The turn's agent output still renders — only the fake prompt is gone.
+    expect(
+      items.some(
+        (i) => i.kind === "message" && i.message.content === "Implementing…",
+      ),
+    ).toBe(true);
   });
 
-  it("leaves the flag unset on an ordinary prompt (renders as a normal bubble)", () => {
+  it("still synthesizes the prompt for an ordinary turn", () => {
     const exec = makeExecution({
       id: "exec-normal",
       interactionMode: InteractionMode.AGENT,
@@ -674,6 +677,99 @@ describe("buildThreadItems build-from-plan prompt", () => {
     const prompt = promptItem(items, "exec-normal");
 
     expect(prompt).toBeDefined();
-    expect(prompt!.isBuildFromPlan).toBeUndefined();
+    expect(prompt!.message.content).toBe("test message");
+  });
+
+  it("offers no retryMessage on a failed build turn's error item (a plain resend would drop the flag)", () => {
+    const exec = makeExecution({
+      id: "exec-build-fail",
+      specMessage: "Build from plan",
+      phase: ExecutionPhase.EXECUTION_FAILED,
+      interactionMode: InteractionMode.AGENT,
+      buildFromPlan: true,
+    });
+    exec.status!.error = "runner crashed";
+
+    const items = buildThreadItems([exec], null, null, false, undefined);
+    const errorItem = items.find(
+      (i): i is Extract<ThreadItem, { kind: "execution-error" }> =>
+        i.kind === "execution-error",
+    );
+
+    expect(errorItem).toBeDefined();
+    expect(errorItem!.retryMessage).toBeUndefined();
+  });
+
+  it("keeps retryMessage on an ordinary failed turn", () => {
+    const exec = makeExecution({
+      id: "exec-fail",
+      specMessage: "do the thing",
+      phase: ExecutionPhase.EXECUTION_FAILED,
+      interactionMode: InteractionMode.AGENT,
+    });
+    exec.status!.error = "runner crashed";
+
+    const items = buildThreadItems([exec], null, null, false, undefined);
+    const errorItem = items.find(
+      (i): i is Extract<ThreadItem, { kind: "execution-error" }> =>
+        i.kind === "execution-error",
+    );
+
+    expect(errorItem!.retryMessage).toBe("do the thing");
+  });
+});
+
+describe("buildThreadItems pending-bubble tail guard", () => {
+  function pendingItem(items: readonly ThreadItem[]) {
+    return items.find(
+      (i): i is Extract<ThreadItem, { kind: "message" }> =>
+        i.kind === "message" && i.key === "pending-user-turn",
+    );
+  }
+
+  it("suppresses the pending bubble once the same turn has streamed in (succeeded send)", () => {
+    const exec = makeExecution({
+      id: "exec-1",
+      specMessage: "hello there",
+      interactionMode: InteractionMode.AGENT,
+    });
+
+    const items = buildThreadItems(
+      [exec],
+      null,
+      "hello there",
+      false,
+      undefined,
+    );
+
+    expect(pendingItem(items)).toBeUndefined();
+  });
+
+  it("renders a FAILED pending message even when an older execution carries identical text", () => {
+    // Two build attempts of the same plan share the message "Build from
+    // plan". A failed second send created no execution, so the first build
+    // turn must never swallow the failed bubble — the failure would
+    // otherwise render nothing at all (build turns synthesize no prompt).
+    const firstBuild = makeExecution({
+      id: "exec-build-1",
+      specMessage: "Build from plan",
+      interactionMode: InteractionMode.AGENT,
+      buildFromPlan: true,
+    });
+
+    const items = buildThreadItems(
+      [firstBuild],
+      null,
+      "Build from plan",
+      false,
+      undefined,
+      undefined,
+      true, // pendingMessageFailed
+    );
+
+    const failed = pendingItem(items);
+    expect(failed).toBeDefined();
+    expect(failed!.isFailed).toBe(true);
+    expect(failed!.message.content).toBe("Build from plan");
   });
 });

package/src/execution/__tests__/message-entry.test.tsx

@@ -195,51 +195,20 @@ describe("MessageEntry — Human messages", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Build-from-plan chip — the flagged human turn renders as a compact pill
+// Build-from-plan turns — no special human-message treatment
 // ---------------------------------------------------------------------------
 
-describe("MessageEntry — Build-from-plan chip", () => {
-  it("renders a compact chip instead of a prompt bubble when flagged", () => {
-    const msg = makeMessage(MessageType.MESSAGE_HUMAN, "Build from plan");
-    const { container } = render(
-      <MessageEntry message={msg} isBuildFromPlan />,
-    );
-
-    const chip = queryArticle(container, "Build from plan");
-    expect(chip).not.toBeNull();
-    expect(chip!.textContent).toContain("Build from plan");
-    // The ordinary prompt bubble must not render alongside the chip.
-    expect(queryArticle(container, "User message")).toBeNull();
-  });
-
-  it("keeps the ordinary bubble when the flag is absent", () => {
+describe("MessageEntry — Build-from-plan turns", () => {
+  it("renders any human message as the ordinary prompt bubble (the thread hides build turns before they reach MessageEntry)", () => {
+    // The retired chip treatment lived here; today buildThreadItems skips
+    // synthesizing the prompt item for a build turn entirely, so a human
+    // message that DOES reach MessageEntry is always ordinary prose.
     const msg = makeMessage(MessageType.MESSAGE_HUMAN, "Build from plan");
     const { container } = render(<MessageEntry message={msg} />);
 
     expect(queryArticle(container, "User message")).not.toBeNull();
     expect(queryArticle(container, "Build from plan")).toBeNull();
   });
-
-  it("never offers Edit on the chip (the label is not user prose)", () => {
-    const msg = makeMessage(MessageType.MESSAGE_HUMAN, "Build from plan");
-    const { container } = render(
-      <MessageEntry message={msg} isBuildFromPlan onEdit={() => {}} />,
-    );
-
-    expect(
-      container.querySelector('[aria-label="Edit message"]'),
-    ).toBeNull();
-  });
-
-  it("ignores the flag on non-human messages", () => {
-    const msg = makeMessage(MessageType.MESSAGE_AI, "Implementing…");
-    const { container } = render(
-      <MessageEntry message={msg} isBuildFromPlan />,
-    );
-
-    expect(queryArticle(container, "AI response")).not.toBeNull();
-    expect(queryArticle(container, "Build from plan")).toBeNull();
-  });
 });
 
 // ---------------------------------------------------------------------------