@stigmer/react 3.1.2 → 3.1.4

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

@@ -1,9 +1,22 @@
-import { describe, it, expect, afterEach } from "vitest";
-import { render, cleanup } from "@testing-library/react";
+import { describe, it, expect, afterEach, vi } from "vitest";
+import { render, cleanup, waitFor } from "@testing-library/react";
 import { create } from "@bufbuild/protobuf";
 import { AgentMessageSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
 import { MessageType } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { MessageEntry } from "../MessageEntry";
+import type { MermaidModule } from "../../internal/mermaid-loader";
+
+// Stub only the library loader: the real MermaidDiagram + markdown overrides
+// run end-to-end through Streamdown, so these tests cover the full chat path
+// from fenced source to rendered diagram.
+vi.mock("../../internal/mermaid-loader", () => ({
+  loadMermaid: vi.fn().mockResolvedValue({
+    initialize: vi.fn(),
+    render: vi
+      .fn()
+      .mockResolvedValue({ svg: "<svg data-testid='mermaid-svg'></svg>" }),
+  } as unknown as MermaidModule),
+}));
 
 afterEach(cleanup);
 
@@ -169,6 +182,41 @@ describe("MessageEntry — AI messages (Streamdown)", () => {
       article!.querySelectorAll('span[class*="hljs-"]').length,
     ).toBeGreaterThan(0);
   });
+
+  it("renders a completed ```mermaid fence as a diagram, not a code block", async () => {
+    const msg = makeMessage(
+      MessageType.MESSAGE_AI,
+      "Here is the flow:\n\n```mermaid\nflowchart LR\n  A --> B\n```",
+    );
+    const { container } = render(<MessageEntry message={msg} />);
+
+    const article = queryArticle(container, "AI response");
+    await waitFor(() =>
+      expect(
+        article!.querySelector('[role="img"][aria-label="Mermaid diagram"]'),
+      ).not.toBeNull(),
+    );
+    expect(article!.querySelector("[data-testid='mermaid-svg']")).not.toBeNull();
+    // The fenced source is no longer shown as a code block.
+    expect(article!.querySelector("pre")).toBeNull();
+  });
+
+  it("keeps an unclosed ```mermaid fence as a code block while streaming", () => {
+    const msg = makeMessage(
+      MessageType.MESSAGE_AI,
+      "```mermaid\nflowchart LR\n  A --> B",
+      { isStreaming: true },
+    );
+    const { container } = render(<MessageEntry message={msg} />);
+
+    const article = queryArticle(container, "AI response");
+    // Mid-stream the source stays a plain code block — no diagram, and no
+    // half-parsed error flashing.
+    expect(
+      article!.querySelector('[role="img"][aria-label="Mermaid diagram"]'),
+    ).toBeNull();
+    expect(article!.textContent).toContain("flowchart LR");
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -195,51 +243,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();
-  });
 });
 
 // ---------------------------------------------------------------------------

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

@@ -0,0 +1,90 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, act, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import type { Stigmer } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { useArtifactCopy } from "../useArtifactCopy";
+
+function wrapperFor(stigmer: Stigmer) {
+  return ({ children }: { children: ReactNode }) => (
+    <StigmerContext.Provider value={stigmer}>{children}</StigmerContext.Provider>
+  );
+}
+
+function makeStigmer(getArtifactContent = vi.fn()) {
+  return { agentExecution: { getArtifactContent } } as unknown as Stigmer;
+}
+
+const writeText = vi.fn().mockResolvedValue(undefined);
+
+beforeEach(() => {
+  writeText.mockClear();
+  vi.stubGlobal("navigator", { clipboard: { writeText } });
+});
+
+describe("useArtifactCopy", () => {
+  it("fetches content at click time and writes decoded text to the clipboard", async () => {
+    const bytes = new TextEncoder().encode("# Plan\n\nsteps");
+    const fn = vi.fn().mockResolvedValue({ content: bytes });
+    const { result } = renderHook(() => useArtifactCopy("aex_1"), {
+      wrapper: wrapperFor(makeStigmer(fn)),
+    });
+
+    expect(result.current.copied).toBe(false);
+    await act(async () => {
+      await result.current.copy("artifacts/aex_1/plan.md");
+    });
+
+    expect(fn).toHaveBeenCalledTimes(1);
+    const req = fn.mock.calls[0][0];
+    expect(req.executionId).toBe("aex_1");
+    expect(req.storageKey).toBe("artifacts/aex_1/plan.md");
+    expect(writeText).toHaveBeenCalledWith("# Plan\n\nsteps");
+    expect(result.current.copied).toBe(true);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("resets the copied flag after the feedback window", async () => {
+    vi.useFakeTimers();
+    const bytes = new TextEncoder().encode("x");
+    const fn = vi.fn().mockResolvedValue({ content: bytes });
+    const { result } = renderHook(() => useArtifactCopy("aex_1"), {
+      wrapper: wrapperFor(makeStigmer(fn)),
+    });
+
+    await act(async () => {
+      await result.current.copy("artifacts/aex_1/plan.md");
+    });
+    expect(result.current.copied).toBe(true);
+
+    act(() => {
+      vi.advanceTimersByTime(2000);
+    });
+    expect(result.current.copied).toBe(false);
+    vi.useRealTimers();
+  });
+
+  it("is a no-op when the execution id is unknown", async () => {
+    const fn = vi.fn();
+    const { result } = renderHook(() => useArtifactCopy(null), {
+      wrapper: wrapperFor(makeStigmer(fn)),
+    });
+    await act(async () => {
+      await result.current.copy("artifacts/x/plan.md");
+    });
+    expect(fn).not.toHaveBeenCalled();
+    expect(writeText).not.toHaveBeenCalled();
+  });
+
+  it("surfaces an error when the content RPC fails", async () => {
+    const fn = vi.fn().mockRejectedValue(new Error("boom"));
+    const { result } = renderHook(() => useArtifactCopy("aex_1"), {
+      wrapper: wrapperFor(makeStigmer(fn)),
+    });
+    await act(async () => {
+      await result.current.copy("artifacts/aex_1/plan.md");
+    });
+    await waitFor(() => expect(result.current.error?.message).toBe("boom"));
+    expect(result.current.copied).toBe(false);
+  });
+});

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

@@ -38,6 +38,8 @@ describe("useArtifactDownload", () => {
     const req = fn.mock.calls[0][0];
     expect(req.executionId).toBe("aex_1");
     expect(req.storageKey).toBe("artifacts/aex_1/file.bin");
+    // Save-to-disk actions force an attachment disposition on the minted URL.
+    expect(req.asAttachment).toBe(true);
     expect(result.current.isDownloading).toBe(false);
     expect(result.current.error).toBeNull();
   });

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

@@ -0,0 +1,151 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, act, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { create } from "@bufbuild/protobuf";
+import type { Stigmer } from "@stigmer/sdk";
+import { ExecutionArtifactSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/artifact_pb";
+import { ExecutionArtifactKind } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { StigmerContext } from "../../context";
+import { useArtifactInspection } from "../useArtifactInspection";
+
+function fileArtifact(name: string) {
+  return create(ExecutionArtifactSchema, {
+    name,
+    kind: ExecutionArtifactKind.FILE,
+    sizeBytes: 64n,
+    sandboxPath: `.stigmer/${name}`,
+    storageKey: `artifacts/aex_1/${name}`,
+    contentHash: "hash-1",
+  });
+}
+
+function dirArtifact(name: string) {
+  return create(ExecutionArtifactSchema, {
+    name,
+    kind: ExecutionArtifactKind.DIRECTORY,
+    sizeBytes: 512n,
+    sandboxPath: `.stigmer/${name}`,
+    storageKey: `artifacts/aex_1/${name}`,
+    entries: ["SKILL.md", "run.sh"],
+  });
+}
+
+function contentResult(text: string) {
+  return {
+    content: new TextEncoder().encode(text),
+    contentType: "text/plain",
+    truncated: false,
+  };
+}
+
+function wrapperFor(stigmer: Stigmer) {
+  return ({ children }: { children: ReactNode }) => (
+    <StigmerContext.Provider value={stigmer}>{children}</StigmerContext.Provider>
+  );
+}
+
+const writeText = vi.fn().mockResolvedValue(undefined);
+
+beforeEach(() => {
+  writeText.mockClear();
+  vi.stubGlobal("navigator", { clipboard: { writeText } });
+});
+
+const AGENT_YAML = [
+  "apiVersion: agentic.stigmer.ai/v1",
+  "kind: Agent",
+  "metadata:",
+  "  name: my-agent",
+  "spec: {}",
+  "",
+].join("\n");
+
+describe("useArtifactInspection — content + copy", () => {
+  it("fetches text content and copies it to the clipboard on demand", async () => {
+    const getArtifactContent = vi.fn().mockResolvedValue(contentResult("hello world"));
+    const stigmer = { agentExecution: { getArtifactContent } } as unknown as Stigmer;
+
+    const { result } = renderHook(
+      () => useArtifactInspection(fileArtifact("notes.txt"), "aex_1", "acme"),
+      { wrapper: wrapperFor(stigmer) },
+    );
+
+    await waitFor(() => expect(result.current.content).toBe("hello world"));
+    expect(result.current.isDirectory).toBe(false);
+    expect(result.current.isDetected).toBe(false);
+    expect(result.current.ctaLabel).toBeNull();
+
+    act(() => {
+      result.current.copy();
+    });
+    expect(writeText).toHaveBeenCalledWith("hello world");
+    await waitFor(() => expect(result.current.copied).toBe(true));
+  });
+
+  it("does not fetch content for a directory artifact", () => {
+    const getArtifactContent = vi.fn().mockReturnValue(new Promise(() => {}));
+    const stigmer = { agentExecution: { getArtifactContent } } as unknown as Stigmer;
+
+    const { result } = renderHook(
+      () => useArtifactInspection(dirArtifact("skill-pack"), "aex_1", "acme"),
+      { wrapper: wrapperFor(stigmer) },
+    );
+
+    expect(result.current.isDirectory).toBe(true);
+    // Directory content is not fetched via the text-content RPC (skill
+    // detection uses its own entry-scoped fetch).
+    expect(
+      getArtifactContent.mock.calls.every(
+        (call) => call[0]?.entryPath !== undefined,
+      ),
+    ).toBe(true);
+  });
+});
+
+describe("useArtifactInspection — detection + apply", () => {
+  it("labels a detected Agent YAML and offers an Apply CTA", async () => {
+    const getArtifactContent = vi.fn().mockResolvedValue(contentResult(AGENT_YAML));
+    const stigmer = { agentExecution: { getArtifactContent } } as unknown as Stigmer;
+
+    const { result } = renderHook(
+      () => useArtifactInspection(fileArtifact("agent.yaml"), "aex_1", "acme"),
+      { wrapper: wrapperFor(stigmer) },
+    );
+
+    await waitFor(() => expect(result.current.isDetected).toBe(true));
+    expect(result.current.detectionLabel).toBe("Agent detected");
+    expect(result.current.ctaLabel).toBe("Apply to acme");
+  });
+
+  it("applies a detected Agent and fires onApplied with the result", async () => {
+    const getArtifactContent = vi.fn().mockResolvedValue(contentResult(AGENT_YAML));
+    const apply = vi.fn().mockResolvedValue({
+      metadata: { name: "my-agent", org: "acme", slug: "my-agent" },
+    });
+    const stigmer = {
+      agentExecution: { getArtifactContent },
+      agent: { apply },
+    } as unknown as Stigmer;
+    const onApplied = vi.fn();
+
+    const { result } = renderHook(
+      () =>
+        useArtifactInspection(fileArtifact("agent.yaml"), "aex_1", "acme", {
+          onApplied,
+        }),
+      { wrapper: wrapperFor(stigmer) },
+    );
+
+    await waitFor(() => expect(result.current.isDetected).toBe(true));
+
+    await act(async () => {
+      await result.current.apply();
+    });
+
+    expect(apply).toHaveBeenCalledTimes(1);
+    expect(apply.mock.calls[0][0].name).toBe("my-agent");
+    await waitFor(() => expect(result.current.applyResult?.kind).toBe("Agent"));
+    expect(onApplied).toHaveBeenCalledTimes(1);
+    expect(onApplied.mock.calls[0][0].name).toBe("my-agent");
+  });
+});

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

@@ -83,3 +83,38 @@ describe("useCreateAgentExecution — executionConfig mapping", () => {
     expect(mockCreate.mock.calls[0][0].executionConfig).toBeUndefined();
   });
 });
+
+describe("useCreateAgentExecution — supersede link (edit-and-resubmit)", () => {
+  it("maps supersedesExecutionId into the create call", async () => {
+    const { result } = renderHook(() => useCreateAgentExecution(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await result.current.create({
+        org: "acme",
+        sessionId: "ses-1",
+        message: "corrected message",
+        supersedesExecutionId: "aex-old",
+      });
+    });
+
+    expect(mockCreate.mock.calls[0][0].supersedesExecutionId).toBe("aex-old");
+  });
+
+  it("leaves supersedesExecutionId undefined for ordinary sends", async () => {
+    const { result } = renderHook(() => useCreateAgentExecution(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await result.current.create({
+        org: "acme",
+        sessionId: "ses-1",
+        message: "Hello",
+      });
+    });
+
+    expect(mockCreate.mock.calls[0][0].supersedesExecutionId).toBeUndefined();
+  });
+});

package/src/execution/index.ts

@@ -62,6 +62,9 @@ export type {
 export { useArtifactDownload } from "./useArtifactDownload.js";
 export type { UseArtifactDownloadReturn } from "./useArtifactDownload.js";
 
+export { useArtifactCopy } from "./useArtifactCopy.js";
+export type { UseArtifactCopyReturn } from "./useArtifactCopy.js";
+
 export { useToolOutputContent } from "./useToolOutputContent.js";
 export type {
   UseToolOutputContentReturn,
@@ -230,18 +233,33 @@ export type { FileReviewCardProps } from "./FileReviewCard.js";
 export { FileReviewDock } from "./FileReviewDock.js";
 export type { FileReviewDockProps } from "./FileReviewDock.js";
 
+export { FileChangeProgressBar } from "./FileChangeProgressBar.js";
+export type { FileChangeProgressBarProps } from "./FileChangeProgressBar.js";
+
 export { ApprovalContext, useApproval } from "./ApprovalContext.js";
 export type { ApprovalContextValue, UseApprovalResult } from "./ApprovalContext.js";
 
 export { FileReviewContext, useFileReviewRowState } from "./FileReviewContext.js";
 export type { FileReviewContextValue } from "./FileReviewContext.js";
 
-export { ArtifactCard } from "./ArtifactCard.js";
-export type { ArtifactCardProps } from "./ArtifactCard.js";
+export { ArtifactRow } from "./ArtifactRow.js";
+export type { ArtifactRowProps } from "./ArtifactRow.js";
 
 export { ArtifactContentRenderer } from "./ArtifactContentRenderer.js";
 export type { ArtifactContentRendererProps } from "./ArtifactContentRenderer.js";
 
+export { ArtifactContentBody } from "./ArtifactContentBody.js";
+export type { ArtifactContentBodyProps } from "./ArtifactContentBody.js";
+
+export { ArtifactDocument } from "./ArtifactDocument.js";
+export type { ArtifactDocumentProps } from "./ArtifactDocument.js";
+
+export { useArtifactInspection } from "./useArtifactInspection.js";
+export type {
+  ArtifactInspection,
+  UseArtifactInspectionOptions,
+} from "./useArtifactInspection.js";
+
 export { ArtifactPreviewContent, ArtifactPreviewModal } from "./ArtifactPreviewModal.js";
 export type { ArtifactPreviewContentProps, ArtifactPreviewModalProps } from "./ArtifactPreviewModal.js";
 

package/src/execution/use-build-from-plan-hotkey.ts

@@ -3,7 +3,7 @@
 import { useCallback, type KeyboardEvent } from "react";
 
 /**
- * Card-scoped `Cmd/Ctrl+Enter` accelerator for the "Build from plan" action.
+ * Card-scoped `Cmd/Ctrl+Enter` accelerator for a plan card's "Build" action.
  *
  * Returns an `onKeyDown` handler for a plan card's root element. Because it is
  * attached to the card (not `window`), it fires only when the keystroke