@stigmer/react 3.1.0 → 3.1.2

package/src/execution/ToolCallItem.tsx

@@ -8,19 +8,19 @@ import {
   ToolCallStatus,
 } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { cn } from "@stigmer/theme";
-import { useRenderTracer } from "../internal/dev";
-import { useAutoDisclosure } from "../internal/useAutoDisclosure";
-import { useIsTextTruncated } from "../internal/useIsTextTruncated";
-import { ToolCallDetail, formatDuration } from "./ToolCallDetail";
-import { SubAgentSection } from "./SubAgentSection";
-import { ApprovalCardBody } from "./ApprovalCard";
-import { useApproval } from "./ApprovalContext";
-import { useFileReviewRowState } from "./FileReviewContext";
-import type { FileReviewRowState } from "./file-review-status";
-import { FilePathLink } from "./FilePathLink";
-import { isFileCategory, type ToolCategory } from "./tool-categories";
-import { useToolPresentation } from "./tool-presenter";
-import { useThreadSelection } from "./useThreadSelection";
+import { useRenderTracer } from "../internal/dev/index.js";
+import { useAutoDisclosure } from "../internal/useAutoDisclosure.js";
+import { useIsTextTruncated } from "../internal/useIsTextTruncated.js";
+import { ToolCallDetail, formatDuration } from "./ToolCallDetail.js";
+import { SubAgentSection } from "./SubAgentSection.js";
+import { ApprovalCardBody } from "./ApprovalCard.js";
+import { useApproval } from "./ApprovalContext.js";
+import { useFileReviewRowState } from "./FileReviewContext.js";
+import type { FileReviewRowState } from "./file-review-status.js";
+import { FilePathLink } from "./FilePathLink.js";
+import { isFileCategory, type ToolCategory } from "./tool-categories.js";
+import { useToolPresentation } from "./tool-presenter.js";
+import { useThreadSelection } from "./useThreadSelection.js";
 
 /** Props for {@link ToolCallItem}. */
 export interface ToolCallItemProps {

package/src/execution/ToolRunGroup.tsx

@@ -7,11 +7,11 @@ import {
   ToolCallStatus,
 } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { cn } from "@stigmer/theme";
-import { useRenderTracer } from "../internal/dev";
-import { useAutoDisclosure } from "../internal/useAutoDisclosure";
-import { ApprovalContext } from "./ApprovalContext";
-import { ToolCallItem, CATEGORY_ICON } from "./ToolCallItem";
-import type { ToolCategory } from "./tool-categories";
+import { useRenderTracer } from "../internal/dev/index.js";
+import { useAutoDisclosure } from "../internal/useAutoDisclosure.js";
+import { ApprovalContext } from "./ApprovalContext.js";
+import { ToolCallItem, CATEGORY_ICON } from "./ToolCallItem.js";
+import type { ToolCategory } from "./tool-categories.js";
 
 /** Props for {@link ToolRunGroup}. */
 export interface ToolRunGroupProps {

package/src/execution/UsageWidget.tsx

@@ -5,7 +5,7 @@ import { cn } from "@stigmer/theme";
 import {
   useSessionUsage,
   type ModelCostEntry,
-} from "../session/useSessionUsage";
+} from "../session/useSessionUsage.js";
 
 /** Props for {@link UsageWidget}. */
 export interface UsageWidgetProps {

package/src/execution/WriteBacksWidget.tsx

@@ -2,8 +2,8 @@
 
 import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import { cn } from "@stigmer/theme";
-import { useSessionWriteBacks } from "../session/useSessionWriteBacks";
-import { WriteBackCard } from "./WriteBackCard";
+import { useSessionWriteBacks } from "../session/useSessionWriteBacks.js";
+import { WriteBackCard } from "./WriteBackCard.js";
 
 /** Props for {@link WriteBacksWidget}. */
 export interface WriteBacksWidgetProps {

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

@@ -1,4 +1,4 @@
-import { describe, it, expect, afterEach } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { render, screen, fireEvent, cleanup } from "@testing-library/react";
 import { ArtifactContentRenderer } from "../ArtifactContentRenderer";
 
@@ -60,3 +60,82 @@ describe("ArtifactContentRenderer — markdown", () => {
     ).toBeGreaterThan(0);
   });
 });
+
+describe("ArtifactContentRenderer — reveal (jump-to-line)", () => {
+  let scrollIntoView: ReturnType<typeof vi.fn>;
+  beforeEach(() => {
+    // happy-dom lacks a real scrollIntoView; the hook calls it optionally.
+    scrollIntoView = vi.fn();
+    Element.prototype.scrollIntoView =
+      scrollIntoView as unknown as typeof Element.prototype.scrollIntoView;
+  });
+
+  it("renders addressable lines and highlights the target row for plain text", () => {
+    const { container } = render(
+      <ArtifactContentRenderer
+        content={"one\ntwo\nthree"}
+        fileName="notes.txt"
+        reveal={{ line: 2, nonce: 1 }}
+      />,
+    );
+
+    // Every line is addressable; exactly the target row carries the highlight.
+    expect(container.querySelectorAll("[data-line]").length).toBe(3);
+    const target = container.querySelector('[data-line="2"]');
+    expect(target?.className).toContain("bg-primary-subtle");
+    expect(container.querySelectorAll(".bg-primary-subtle").length).toBe(1);
+  });
+
+  it("does not highlight anything when the target line is out of range", () => {
+    const { container } = render(
+      <ArtifactContentRenderer
+        content={"one\ntwo"}
+        fileName="notes.txt"
+        reveal={{ line: 99, nonce: 1 }}
+      />,
+    );
+    expect(container.querySelectorAll(".bg-primary-subtle").length).toBe(0);
+  });
+
+  it("forces Markdown to its Source (line-faithful) view when revealing", () => {
+    const { container } = render(
+      <ArtifactContentRenderer
+        content={"# Heading\n\ntext"}
+        fileName="doc.md"
+        reveal={{ line: 1, nonce: 1 }}
+      />,
+    );
+    // Source is line-numbered <pre>, not the rendered <h1>.
+    expect(container.querySelector("h1")).toBeNull();
+    expect(container.querySelector("pre")).not.toBeNull();
+    expect(container.querySelector('[data-line="1"]')).not.toBeNull();
+    // The Rendered/Source toggle is still offered.
+    expect(screen.getByRole("tab", { name: "Source" })).toBeTruthy();
+  });
+
+  it("renders JSON raw (not reformatted) when revealing, so line numbers hold", () => {
+    // Minified single-line JSON: pretty-printing would expand it to many lines
+    // and shift line 1. Raw rendering keeps it one addressable row.
+    const { container } = render(
+      <ArtifactContentRenderer
+        content={'{"a":1,"b":2}'}
+        fileName="data.json"
+        reveal={{ line: 1, nonce: 1 }}
+      />,
+    );
+    const rows = container.querySelectorAll("[data-line]");
+    expect(rows.length).toBe(1);
+    expect(rows[0].textContent).toContain('{"a":1,"b":2}');
+  });
+
+  it("scrolls the target line into view", () => {
+    render(
+      <ArtifactContentRenderer
+        content={"one\ntwo\nthree"}
+        fileName="notes.txt"
+        reveal={{ line: 3, nonce: 1 }}
+      />,
+    );
+    expect(scrollIntoView).toHaveBeenCalled();
+  });
+});

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

@@ -5,6 +5,7 @@ import {
   WorkspaceEntrySchema,
   WorkspaceSourceSchema,
   LocalPathSourceSchema,
+  GitRepoSourceSchema,
 } from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
 import type { WorkspaceEntry } from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
 import { FilePathLink } from "../FilePathLink";
@@ -89,4 +90,90 @@ describe("FilePathLink interaction", () => {
     expect(onFilePathClick.mock.calls[0][0]).toBe("src/main.go");
     expect(onFilePathClick.mock.calls[0][1].action).toBe("copy");
   });
+
+  it("falls back to copy when a copy-action handler declines (returns false)", async () => {
+    const writeText = vi.fn().mockResolvedValue(undefined);
+    vi.stubGlobal("navigator", { clipboard: { writeText } });
+    const onFilePathClick = vi.fn().mockReturnValue(false);
+    render(
+      <FilePathContext.Provider value={{ workspaceEntries: [], onFilePathClick }}>
+        <FilePathLink path="src/main.go" />
+      </FilePathContext.Provider>,
+    );
+    fireEvent.click(screen.getByRole("button"));
+    expect(onFilePathClick).toHaveBeenCalledTimes(1);
+    expect(writeText).toHaveBeenCalledWith("src/main.go");
+    vi.unstubAllGlobals();
+  });
+
+  it("suppresses the copy default when a copy-action handler returns void", () => {
+    const writeText = vi.fn().mockResolvedValue(undefined);
+    vi.stubGlobal("navigator", { clipboard: { writeText } });
+    const onFilePathClick = vi.fn(); // returns undefined -> handled
+    render(
+      <FilePathContext.Provider value={{ workspaceEntries: [], onFilePathClick }}>
+        <FilePathLink path="src/main.go" />
+      </FilePathContext.Provider>,
+    );
+    fireEvent.click(screen.getByRole("button"));
+    expect(onFilePathClick).toHaveBeenCalledTimes(1);
+    expect(writeText).not.toHaveBeenCalled();
+    vi.unstubAllGlobals();
+  });
+});
+
+describe("FilePathLink link-action with an injected handler", () => {
+  const gitEntries = [
+    create(WorkspaceEntrySchema, {
+      name: "acme/app",
+      source: create(WorkspaceSourceSchema, {
+        source: {
+          case: "gitRepo",
+          value: create(GitRepoSourceSchema, {
+            url: "https://github.com/acme/app.git",
+            branch: "main",
+          }),
+        },
+      }),
+    }),
+  ];
+
+  it("renders a real <a href> even when a handler is present (native link semantics)", () => {
+    const onFilePathClick = vi.fn().mockReturnValue(true);
+    render(
+      <FilePathContext.Provider value={{ workspaceEntries: gitEntries, onFilePathClick }}>
+        <FilePathLink path="src/main.go" />
+      </FilePathContext.Provider>,
+    );
+    const anchor = screen.getByRole("link");
+    expect(anchor.getAttribute("href")).toBe(
+      "https://github.com/acme/app/blob/main/src/main.go",
+    );
+  });
+
+  it("prevents native navigation when the handler opens it in-app (returns true)", () => {
+    const onFilePathClick = vi.fn().mockReturnValue(true);
+    render(
+      <FilePathContext.Provider value={{ workspaceEntries: gitEntries, onFilePathClick }}>
+        <FilePathLink path="src/main.go" />
+      </FilePathContext.Provider>,
+    );
+    const evt = new MouseEvent("click", { bubbles: true, cancelable: true });
+    screen.getByRole("link").dispatchEvent(evt);
+    expect(onFilePathClick).toHaveBeenCalledTimes(1);
+    expect(evt.defaultPrevented).toBe(true);
+  });
+
+  it("leaves native navigation intact when the handler declines (returns false)", () => {
+    const onFilePathClick = vi.fn().mockReturnValue(false);
+    render(
+      <FilePathContext.Provider value={{ workspaceEntries: gitEntries, onFilePathClick }}>
+        <FilePathLink path="src/main.go" />
+      </FilePathContext.Provider>,
+    );
+    const evt = new MouseEvent("click", { bubbles: true, cancelable: true });
+    screen.getByRole("link").dispatchEvent(evt);
+    expect(onFilePathClick).toHaveBeenCalledTimes(1);
+    expect(evt.defaultPrevented).toBe(false);
+  });
 });

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

@@ -784,6 +784,50 @@ describe("MessageThread", () => {
     });
   });
 
+  describe("live plan collapse (streaming Plan turn)", () => {
+    function streamingPlanExecution() {
+      return makeExecution({
+        id: "exec-live",
+        phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+        interactionMode: InteractionMode.PLAN,
+        aiContent: "# Rollout Plan\n\n1. First step",
+      });
+    }
+
+    it("collapses the streaming plan behind a live card when onOpenPlan is wired", () => {
+      const onOpenPlan = vi.fn();
+      render(
+        <MessageThread
+          executions={[]}
+          activeStreamExecution={streamingPlanExecution()}
+          onOpenPlan={onOpenPlan}
+        />,
+      );
+
+      const card = screen.getByRole("region", { name: "Plan being written" });
+      expect(card.textContent).toContain("Rollout Plan");
+      // The plan body lives in the panel's plan tab, not the thread.
+      expect(screen.queryByText(/First step/)).toBeNull();
+
+      fireEvent.click(screen.getByText("Open plan"));
+      expect(onOpenPlan).toHaveBeenCalledWith("exec-live");
+    });
+
+    it("keeps the plan streaming inline for hosts without a plan surface (DD-011)", () => {
+      render(
+        <MessageThread
+          executions={[]}
+          activeStreamExecution={streamingPlanExecution()}
+        />,
+      );
+
+      expect(
+        screen.queryByRole("region", { name: "Plan being written" }),
+      ).toBeNull();
+      expect(screen.getByText(/First step/)).toBeTruthy();
+    });
+  });
+
   it("renders plan-completion card when last execution is completed Plan mode", () => {
     const exec = makeExecution({
       id: "exec-plan",
@@ -806,4 +850,61 @@ describe("MessageThread", () => {
     fireEvent.click(buildBtn);
     expect(onBuildFromPlan).toHaveBeenCalledOnce();
   });
+
+  describe("plan-turn identity", () => {
+    it("marks a Plan turn's prompt bubble with the Plan badge", () => {
+      const exec = makeExecution({
+        id: "exec-plan",
+        phase: ExecutionPhase.EXECUTION_COMPLETED,
+        interactionMode: InteractionMode.PLAN,
+      });
+
+      render(<MessageThread executions={[exec]} />);
+
+      expect(screen.getByRole("status", { name: "Plan mode" })).toBeTruthy();
+    });
+
+    it("shows no mode badge on Agent turns", () => {
+      const exec = makeExecution({
+        id: "exec-agent",
+        phase: ExecutionPhase.EXECUTION_COMPLETED,
+        interactionMode: InteractionMode.AGENT,
+      });
+
+      render(<MessageThread executions={[exec]} />);
+
+      expect(screen.queryByRole("status", { name: "Plan mode" })).toBeNull();
+    });
+
+    it("renders a completed Plan turn's plan as a document", () => {
+      const exec = makeExecution({
+        id: "exec-plan",
+        phase: ExecutionPhase.EXECUTION_COMPLETED,
+        interactionMode: InteractionMode.PLAN,
+        aiContent: "# Rollout Plan\n\n1. First step",
+      });
+
+      render(<MessageThread executions={[exec]} />);
+
+      const doc = screen.getByRole("article", { name: "Plan document" });
+      expect(doc.textContent).toContain("Rollout Plan");
+      expect(doc.textContent).toContain("First step");
+    });
+
+    it("renders a streaming Plan turn's text as an ordinary chat message", () => {
+      const exec = makeExecution({
+        id: "exec-live",
+        phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+        interactionMode: InteractionMode.PLAN,
+        aiContent: "Draft so far",
+      });
+
+      render(<MessageThread executions={[]} activeStreamExecution={exec} />);
+
+      expect(
+        screen.queryByRole("article", { name: "Plan document" }),
+      ).toBeNull();
+      expect(screen.getByRole("article", { name: "AI response" })).toBeTruthy();
+    });
+  });
 });

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

@@ -47,18 +47,32 @@ function renderCard(ui: ReactNode) {
 
 afterEach(cleanup);
 
-describe("PlanArtifactCard — action surface", () => {
-  it("is an accessible region labelled as the plan's actions, with name + size", () => {
+describe("PlanArtifactCard — compact document card", () => {
+  it("is an accessible region with the plan's title, filename, and size", () => {
     renderCard(
-      <PlanArtifactCard executionId="aex_1" artifact={planArtifact} org="acme" />,
+      <PlanArtifactCard
+        executionId="aex_1"
+        artifact={planArtifact}
+        title="Refactor the auth flow"
+        org="acme"
+      />,
     );
 
-    const region = screen.getByRole("region", { name: "Plan actions" });
-    expect(region.textContent).toContain("Plan");
+    const region = screen.getByRole("region", { name: "Plan" });
+    expect(region.textContent).toContain("Refactor the auth flow");
+    expect(region.textContent).toContain("plan.md");
     expect(region.textContent).toContain("KB");
   });
 
-  it("does NOT render the plan content (the message above is the document)", () => {
+  it("falls back to 'Plan' when the plan has no title", () => {
+    renderCard(
+      <PlanArtifactCard executionId="aex_1" artifact={planArtifact} org="acme" />,
+    );
+    const region = screen.getByRole("region", { name: "Plan" });
+    expect(region.textContent).toContain("Plan");
+  });
+
+  it("does NOT render the plan content (the document lives in the plan tab)", () => {
     const { stigmer, getArtifactContent } = createStigmerMock();
     render(
       withStigmer(
@@ -66,8 +80,8 @@ describe("PlanArtifactCard — action surface", () => {
         stigmer,
       ),
     );
-    // The card is a pure action surface — it must not fetch the plan body until
-    // the user explicitly opens the full preview.
+    // The card is the plan's compact stand-in — it must not fetch the plan
+    // body; that belongs to the plan tab (or the explicit preview modal).
     expect(getArtifactContent).not.toHaveBeenCalled();
   });
 
@@ -93,6 +107,25 @@ describe("PlanArtifactCard — action surface", () => {
     expect(screen.queryByText("Build from plan")).toBeNull();
   });
 
+  it("shows the pending label while the approved plan uploads (buildPending)", () => {
+    renderCard(
+      <PlanArtifactCard
+        executionId="aex_1"
+        artifact={planArtifact}
+        org="acme"
+        onImplement={vi.fn()}
+        disabled
+        buildPending
+      />,
+    );
+
+    // 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();
+    const button = screen.getByText("Starting build…").closest("button")!;
+    expect(button.disabled).toBe(true);
+  });
+
   it("disables 'Build from plan' when disabled", () => {
     const onImplement = vi.fn();
     renderCard(
@@ -141,7 +174,7 @@ describe("PlanArtifactCard — Cmd/Ctrl+Enter accelerator (card-scoped)", () =>
       />,
     );
 
-    const region = screen.getByRole("region", { name: "Plan actions" });
+    const region = screen.getByRole("region", { name: "Plan" });
     fireEvent.keyDown(region, { key: "Enter", metaKey: true });
     expect(onImplement).toHaveBeenCalledTimes(1);
   });
@@ -157,7 +190,7 @@ describe("PlanArtifactCard — Cmd/Ctrl+Enter accelerator (card-scoped)", () =>
       />,
     );
 
-    const region = screen.getByRole("region", { name: "Plan actions" });
+    const region = screen.getByRole("region", { name: "Plan" });
     fireEvent.keyDown(region, { key: "Enter", ctrlKey: true });
     expect(onImplement).toHaveBeenCalledTimes(1);
   });
@@ -173,7 +206,7 @@ describe("PlanArtifactCard — Cmd/Ctrl+Enter accelerator (card-scoped)", () =>
       />,
     );
 
-    const region = screen.getByRole("region", { name: "Plan actions" });
+    const region = screen.getByRole("region", { name: "Plan" });
     fireEvent.keyDown(region, { key: "Enter" });
     expect(onImplement).not.toHaveBeenCalled();
   });
@@ -190,7 +223,7 @@ describe("PlanArtifactCard — Cmd/Ctrl+Enter accelerator (card-scoped)", () =>
       />,
     );
 
-    const region = screen.getByRole("region", { name: "Plan actions" });
+    const region = screen.getByRole("region", { name: "Plan" });
     fireEvent.keyDown(region, { key: "Enter", metaKey: true });
     expect(onImplement).not.toHaveBeenCalled();
   });
@@ -230,3 +263,24 @@ describe("PlanArtifactCard — Open full (org-gated preview)", () => {
     expect(screen.queryByText("Download")).not.toBeNull();
   });
 });
+
+describe("PlanArtifactCard — Open plan (panel-first review)", () => {
+  it("replaces the modal secondary with 'Open plan' when onOpenPlan is provided", () => {
+    const onOpenPlan = vi.fn();
+    renderCard(
+      <PlanArtifactCard
+        executionId="aex_1"
+        artifact={planArtifact}
+        org="acme"
+        onOpenPlan={onOpenPlan}
+      />,
+    );
+
+    // One review affordance, not two: the facet supersedes the modal.
+    expect(screen.queryByText("Open full")).toBeNull();
+
+    fireEvent.click(screen.getByText("Open plan"));
+    expect(onOpenPlan).toHaveBeenCalledTimes(1);
+    expect(document.querySelector("dialog")).toBeNull();
+  });
+});

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

@@ -0,0 +1,55 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+import { PlanDocumentMessage } from "../PlanDocumentMessage";
+
+afterEach(cleanup);
+
+describe("PlanDocumentMessage", () => {
+  it("lifts the leading H1 into the header and renders the body as markdown", () => {
+    render(
+      <PlanDocumentMessage
+        content={"# Migration Plan\n\n## Phase 1\n\n- step one"}
+      />,
+    );
+
+    const doc = screen.getByRole("article", { name: "Plan document" });
+    expect(doc).toBeTruthy();
+    expect(doc.querySelector("header")!.textContent).toContain(
+      "Migration Plan",
+    );
+    // The lifted title does not repeat inside the prose body.
+    expect(doc.querySelectorAll("h1")).toHaveLength(0);
+  });
+
+  it("falls back to a 'Plan' header when the document has no leading H1", () => {
+    render(<PlanDocumentMessage content="Just prose, no heading." />);
+
+    const doc = screen.getByRole("article", { name: "Plan document" });
+    expect(doc.querySelector("header")!.textContent).toContain("Plan");
+    expect(doc.textContent).toContain("Just prose, no heading.");
+  });
+
+  it("unwraps a whole-body BARE fence (plan-scoped fence handling)", () => {
+    render(
+      <PlanDocumentMessage content={"```\n# Fenced Plan\n\nBody text\n```"} />,
+    );
+
+    const doc = screen.getByRole("article", { name: "Plan document" });
+    // Unwrapped: the H1 became the header title, the body is prose (not a
+    // flat code block).
+    expect(doc.querySelector("header")!.textContent).toContain("Fenced Plan");
+    expect(doc.querySelector("pre")).toBeNull();
+    expect(doc.textContent).toContain("Body text");
+  });
+
+  it("keeps an inner code fence as a code block", () => {
+    render(
+      <PlanDocumentMessage
+        content={"# Plan\n\n```ts\nconst x = 1;\n```"}
+      />,
+    );
+
+    const doc = screen.getByRole("article", { name: "Plan document" });
+    expect(doc.querySelector("pre")).not.toBeNull();
+  });
+});

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

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+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", () => {
+    render(
+      <PlanStreamingCard
+        title="Refactor the auth flow"
+        sizeBytes={2048}
+        onOpenPlan={vi.fn()}
+      />,
+    );
+
+    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("falls back to 'Writing plan…' until the title has streamed in", () => {
+    render(<PlanStreamingCard sizeBytes={12} onOpenPlan={vi.fn()} />);
+    expect(screen.getByText("Writing plan…")).toBeTruthy();
+  });
+
+  it("routes 'Open plan' to onOpenPlan", () => {
+    const onOpenPlan = vi.fn();
+    render(<PlanStreamingCard sizeBytes={64} onOpenPlan={onOpenPlan} />);
+
+    fireEvent.click(screen.getByText("Open plan"));
+    expect(onOpenPlan).toHaveBeenCalledTimes(1);
+  });
+
+  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();
+  });
+
+  it("renders without an action when onOpenPlan is absent", () => {
+    render(<PlanStreamingCard sizeBytes={64} />);
+    expect(screen.queryByText("Open plan")).toBeNull();
+    expect(screen.queryByRole("button")).toBeNull();
+  });
+});