@stigmer/react 3.1.2 → 3.1.3

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/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,6 +233,9 @@ 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";
 

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

package/src/execution/useArtifactCopy.ts

@@ -0,0 +1,109 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { create } from "@bufbuild/protobuf";
+import { GetArtifactContentRequestSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
+import { useStigmer } from "../hooks.js";
+import { toError } from "../internal/toError.js";
+
+/** How long the transient `copied` flag stays true after a successful copy. */
+const COPIED_FEEDBACK_MS = 2000;
+
+/** Return value of {@link useArtifactCopy}. */
+export interface UseArtifactCopyReturn {
+  /**
+   * Fetch the artifact's text at click time and write it to the clipboard.
+   * No-op when the execution id is unknown or a copy is already in flight.
+   * Resolves once the copy has been attempted.
+   *
+   * @param storageKey - Storage key of the artifact to copy.
+   */
+  readonly copy: (storageKey: string) => Promise<void>;
+
+  /** `true` while the content is being fetched / written to the clipboard. */
+  readonly isCopying: boolean;
+
+  /**
+   * `true` for a brief window after a successful copy (drives "Copied"
+   * affordance feedback), then resets automatically.
+   */
+  readonly copied: boolean;
+
+  /** Error from the last failed copy attempt, or `null` when healthy. */
+  readonly error: Error | null;
+}
+
+/**
+ * Behavior hook that copies an execution artifact's text to the clipboard on
+ * demand.
+ *
+ * The imperative sibling of {@link useArtifactDownload}: it fetches content at
+ * click time via `getArtifactContent` (CORS-safe, through the Stigmer API)
+ * rather than requiring the caller to have loaded it. This suits content-free
+ * surfaces — a plan card that detects the artifact by convention and never
+ * fetches until the user acts — where a mount-time {@link useArtifactContent}
+ * would be wasteful.
+ *
+ * Returns an imperative `copy(storageKey)` action plus a transient `copied`
+ * flag for feedback, mirroring the modal's copy affordance so every surface
+ * shares one implementation.
+ *
+ * @param executionId - Execution that produced the artifacts, or `null` to
+ *   disable (the action becomes a no-op).
+ *
+ * @example
+ * ```tsx
+ * const { copy, isCopying, copied } = useArtifactCopy(executionId);
+ * <button onClick={() => copy(artifact.storageKey)} disabled={isCopying}>
+ *   {copied ? "Copied" : "Copy"}
+ * </button>
+ * ```
+ *
+ * @see useArtifactDownload — imperative save-to-disk counterpart
+ * @see useArtifactContent — declarative content reader (preview rendering)
+ */
+export function useArtifactCopy(
+  executionId: string | null,
+): UseArtifactCopyReturn {
+  const stigmer = useStigmer();
+  const [isCopying, setIsCopying] = useState(false);
+  const [copied, setCopied] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  // Clear the pending "copied" timer on unmount so a resolved copy never sets
+  // state on an unmounted component.
+  const copiedTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+  useEffect(() => {
+    return () => {
+      if (copiedTimer.current !== null) clearTimeout(copiedTimer.current);
+    };
+  }, []);
+
+  const copy = useCallback(
+    async (storageKey: string) => {
+      if (!executionId || !storageKey || isCopying) return;
+      setIsCopying(true);
+      setError(null);
+      try {
+        const result = await stigmer.agentExecution.getArtifactContent(
+          create(GetArtifactContentRequestSchema, { executionId, storageKey }),
+        );
+        const text = new TextDecoder().decode(result.content);
+        await navigator.clipboard.writeText(text);
+        setCopied(true);
+        if (copiedTimer.current !== null) clearTimeout(copiedTimer.current);
+        copiedTimer.current = setTimeout(() => setCopied(false), COPIED_FEEDBACK_MS);
+      } catch (err) {
+        setError(toError(err));
+      } finally {
+        setIsCopying(false);
+      }
+    },
+    [executionId, stigmer, isCopying],
+  );
+
+  return useMemo(
+    () => ({ copy, isCopying, copied, error }),
+    [copy, isCopying, copied, error],
+  );
+}

package/src/execution/useArtifactDownload.ts

@@ -65,7 +65,16 @@ export function useArtifactDownload(
       setError(null);
       try {
         const result = await stigmer.agentExecution.getArtifactDownloadUrl(
-          create(GetArtifactDownloadUrlRequestSchema, { executionId, storageKey }),
+          create(GetArtifactDownloadUrlRequestSchema, {
+            executionId,
+            storageKey,
+            // This is a save-to-disk action, so mint a URL that forces a
+            // browser download (Content-Disposition: attachment). Browsers
+            // ignore the anchor's `download` attribute cross-origin, so the
+            // disposition must ride on the URL itself. Contrast
+            // useArtifactDownloadUrl, which stays inline for `<img src>`.
+            asAttachment: true,
+          }),
         );
         if (result.downloadUrl) {
           triggerBrowserDownload(result.downloadUrl, fileName);
@@ -86,10 +95,13 @@ export function useArtifactDownload(
 }
 
 /**
- * Trigger a browser download for a URL via a transient anchor click. The
- * `download` hint is best-effort: browsers ignore it for cross-origin URLs
- * (e.g. R2), in which case the navigation still serves the file. Falls back to
- * a new tab in non-DOM environments.
+ * Trigger a browser download for a URL via a transient anchor click.
+ *
+ * The URL minted for this flow carries `Content-Disposition: attachment`
+ * (requested via `asAttachment`), so the browser saves the file even
+ * cross-origin — where it would ignore the anchor's `download` attribute. The
+ * `download` hint is still set as a same-origin nicety. Falls back to a new tab
+ * in non-DOM environments.
  */
 function triggerBrowserDownload(url: string, fileName?: string): void {
   if (typeof document === "undefined") {

package/src/execution/useCreateAgentExecution.ts

@@ -55,11 +55,13 @@ export interface CreateAgentExecutionInput {
    */
   readonly interactionMode?: "agent" | "plan";
   /**
-   * Marks this execution as a "Build from plan" turn: the user approved a
+   * Marks this execution as a Build-from-plan turn: the user approved a
    * plan from a prior Plan-mode execution and asked the agent to implement
    * it. The runner injects the implement-plan directive (pointing at the
-   * attached approved plan when present); the thread renders the turn as a
-   * compact chip instead of the raw message text.
+   * attached approved plan when present); the thread hides the turn's
+   * machine-written message entirely — the plan card above it is the
+   * visible cause. Surfaces without that treatment (the CLI, history)
+   * show the message text as-is.
    *
    * Maps to `ExecutionConfig.build_from_plan` in the proto.
    */

package/src/index.ts

@@ -283,6 +283,7 @@ export {
   ApprovalCardBody,
   FileReviewCard,
   FileReviewDock,
+  FileChangeProgressBar,
   ApprovalContext,
   useApproval,
   FileReviewContext,
@@ -307,6 +308,7 @@ export {
   useArtifactContent,
   useArtifactDownloadUrl,
   useArtifactDownload,
+  useArtifactCopy,
   useToolOutputContent,
   useFileChangeContent,
   execIdFromStorageKey,
@@ -375,6 +377,7 @@ export type {
   ApprovalCardBodyProps,
   FileReviewCardProps,
   FileReviewDockProps,
+  FileChangeProgressBarProps,
   ApprovalContextValue,
   UseApprovalResult,
   FileReviewContextValue,
@@ -397,6 +400,7 @@ export type {
   UseArtifactDownloadUrlReturn,
   UseArtifactDownloadUrlOptions,
   UseArtifactDownloadReturn,
+  UseArtifactCopyReturn,
   UseToolOutputContentReturn,
   ToolOutputRefLike,
   UseFileChangeContentReturn,
@@ -980,10 +984,12 @@ export {
   detectSkillPackage,
   useDetectSkillPackage,
   isPlanArtifact,
+  isPlanArtifactName,
   findPlanArtifact,
   findLatestSessionPlan,
   findStreamingPlan,
   PLAN_ARTIFACT_NAME,
+  PLAN_ARTIFACT_SUFFIX,
   parseResourceYaml,
   serializeAgentYaml,
   serializeMcpServerYaml,

package/src/internal/file-tree/FileTreeNode.tsx

@@ -102,7 +102,15 @@ export function FileTreeNode({
   );
 
   return (
-    <li role="treeitem" aria-expanded={isFolder ? expanded : undefined}>
+    <li
+      role="treeitem"
+      // Depth conveys tree nesting to assistive tech (indentation is visual
+      // only). aria-level is 1-based; `depth` is 0-based. aria-expanded stays on
+      // the treeitem (the <li>) — its child group is nested here, so this is the
+      // element a tree-aware screen reader reads expandability from.
+      aria-level={depth + 1}
+      aria-expanded={isFolder ? expanded : undefined}
+    >
       <button
         type="button"
         onClick={handleClick}
@@ -123,7 +131,10 @@ export function FileTreeNode({
         aria-current={isSelected ? "true" : undefined}
       >
         {isFolder && (
-          <span className="text-[10px] text-muted-foreground-subtle">
+          <span
+            aria-hidden="true"
+            className="text-[10px] text-muted-foreground-subtle"
+          >
             {expanded ? "▼" : "▶"}
           </span>
         )}

package/src/library/__tests__/detect-plan-artifact.test.ts

@@ -9,6 +9,7 @@ import { ExecutionArtifactKind } from "@stigmer/protos/ai/stigmer/agentic/agente
 import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
 import {
   isPlanArtifact,
+  isPlanArtifactName,
   findPlanArtifact,
   findLatestSessionPlan,
   PLAN_ARTIFACT_NAME,
@@ -35,11 +36,31 @@ function executionWithId(id: string, ...artifacts: ReturnType<typeof artifact>[]
   });
 }
 
+describe("isPlanArtifactName", () => {
+  it("accepts the legacy exact name and any *.plan.md", () => {
+    expect(isPlanArtifactName(PLAN_ARTIFACT_NAME)).toBe(true);
+    expect(isPlanArtifactName("feature_x.plan.md")).toBe(true);
+    // The runner's current shape: hyphenated slug + content-hash discriminator.
+    expect(isPlanArtifactName("fix-the-download-ux_a1b2c3d4.plan.md")).toBe(true);
+    expect(isPlanArtifactName("a1b2c3d4.plan.md")).toBe(true);
+  });
+
+  it("rejects non-plan filenames", () => {
+    expect(isPlanArtifactName("report.md")).toBe(false);
+    expect(isPlanArtifactName("plan.txt")).toBe(false);
+    expect(isPlanArtifactName("myplan.md")).toBe(false);
+  });
+});
+
 describe("isPlanArtifact", () => {
   it("is true for a FILE artifact named plan.md", () => {
     expect(isPlanArtifact(artifact({ name: PLAN_ARTIFACT_NAME }))).toBe(true);
   });
 
+  it("is true for a FILE artifact named <slug>_<id>.plan.md", () => {
+    expect(isPlanArtifact(artifact({ name: "plan-card-ux-cleanup_a1b2c3d4.plan.md" }))).toBe(true);
+  });
+
   it("is false for a directory named plan.md", () => {
     expect(
       isPlanArtifact(artifact({ name: "plan.md", kind: ExecutionArtifactKind.DIRECTORY })),

package/src/library/detect-plan-artifact.ts

@@ -3,26 +3,48 @@ import type { ExecutionArtifact } from "@stigmer/protos/ai/stigmer/agentic/agent
 import { ExecutionArtifactKind } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 
 /**
- * The session's current plan: the published `plan.md` artifact of the most
- * recent execution that produced one, plus the execution it belongs to
- * (artifact content RPCs are execution-scoped).
+ * The session's current plan: the published plan artifact (a `*.plan.md` FILE)
+ * of the most recent execution that produced one, plus the execution it belongs
+ * to (artifact content RPCs are execution-scoped).
  */
 export interface SessionPlan {
   /** ID of the execution that published the plan. */
   readonly executionId: string;
-  /** The published `plan.md` artifact. */
+  /** The published plan artifact (`*.plan.md`). */
   readonly artifact: ExecutionArtifact;
 }
 
 /**
- * Canonical filename a Plan-mode execution publishes its plan under. Kept in
- * sync with the runner's `publishPlanArtifact` (shared/plan-artifact.ts).
+ * Legacy plan filename. Detection-only: {@link isPlanArtifactName} still
+ * accepts this exact name so plans published before named artifacts existed
+ * keep working. The runner never freshly emits it (a titleless plan falls back
+ * to a bare `<id>.plan.md`). Kept in sync with the runner's
+ * `PLAN_ARTIFACT_NAME` (shared/plan-artifact.ts).
  */
 export const PLAN_ARTIFACT_NAME = "plan.md";
 
 /**
- * Returns `true` when an artifact is the published plan: a FILE artifact named
- * `plan.md`.
+ * Suffix every named plan artifact carries (`<slug>_<id>.plan.md`, or a bare
+ * `<id>.plan.md` when untitled). The runner derives the slug from the plan's
+ * title and the `<id>` from its content hash; detection keys on this suffix.
+ * Kept in sync with the runner's `PLAN_ARTIFACT_SUFFIX` (shared/plan-artifact.ts)
+ * — the runner and browser SDK have disjoint module graphs, so the constant is
+ * duplicated by design, mirroring {@link PLAN_ARTIFACT_NAME}.
+ */
+export const PLAN_ARTIFACT_SUFFIX = ".plan.md";
+
+/**
+ * Returns `true` when a filename is a plan's: the legacy exact `plan.md`, or
+ * any `*.plan.md`. Accepting the legacy name keeps plans published before named
+ * artifacts existed detectable.
+ */
+export function isPlanArtifactName(name: string): boolean {
+  return name === PLAN_ARTIFACT_NAME || name.endsWith(PLAN_ARTIFACT_SUFFIX);
+}
+
+/**
+ * Returns `true` when an artifact is the published plan: a FILE artifact whose
+ * name satisfies {@link isPlanArtifactName}.
  *
  * Detection is by convention — the same lightweight, content-free approach used
  * for skill packages ({@link isSkillPackage}) — so the UI never needs an extra
@@ -32,7 +54,7 @@ export const PLAN_ARTIFACT_NAME = "plan.md";
 export function isPlanArtifact(artifact: ExecutionArtifact): boolean {
   return (
     artifact.kind === ExecutionArtifactKind.FILE &&
-    artifact.name === PLAN_ARTIFACT_NAME
+    isPlanArtifactName(artifact.name)
   );
 }
 
@@ -56,7 +78,7 @@ export function findPlanArtifact(
 
 /**
  * Finds the session's LATEST plan across all executions — the plan the panel's
- * plan document tab edits and "Build from plan" implements. Executions are
+ * plan document tab edits and the "Build" action implements. Executions are
  * scanned newest-first (the array is chronological), mirroring the thread's
  * latest-plan-owns-the-build-action rule so every surface agrees on which
  * plan is current.

package/src/library/index.ts

@@ -26,9 +26,11 @@ export type { SkillPackageDetection } from "./detect-skill-package.js";
 
 export {
   isPlanArtifact,
+  isPlanArtifactName,
   findPlanArtifact,
   findLatestSessionPlan,
   PLAN_ARTIFACT_NAME,
+  PLAN_ARTIFACT_SUFFIX,
 } from "./detect-plan-artifact.js";
 export type { SessionPlan } from "./detect-plan-artifact.js";
 

package/src/session/PlanEditor.tsx

@@ -203,7 +203,7 @@ export function PlanEditor({
               >
                 <ImplementIcon />
                 <span className="truncate">
-                  {buildDisabled ? "Starting build…" : "Build from plan"}
+                  {buildDisabled ? "Starting build…" : "Build"}
                 </span>
               </button>
             )

package/src/session/SessionViewer.tsx

@@ -25,13 +25,17 @@ import { useWorkspaceEditors, isVirtualEntryId } from "../internal/store/index.j
 import { ThreadSelectionContext } from "../execution/ThreadSelectionContext.js";
 import { useSelectedThreadItem } from "../execution/useThreadSelection.js";
 import { MessageThread } from "../execution/MessageThread.js";
+import { FileChangeProgressBar } from "../execution/FileChangeProgressBar.js";
 import { FileReviewDock } from "../execution/FileReviewDock.js";
+import {
+  FilePathContext,
+  type FilePathContextValue,
+} from "../execution/FilePathContext.js";
 import { ThreadSkeleton } from "../execution/ThreadSkeleton.js";
 import { SessionComposer } from "../composer/index.js";
 import { SecretFlowErrorGuide, isSecretFlowError } from "../error/index.js";
 import { useStigmer } from "../hooks.js";
 import {
-  PLAN_ARTIFACT_NAME,
   findLatestSessionPlan,
   findPlanArtifact,
   type SessionPlan,
@@ -57,18 +61,22 @@ import type { SessionAudience } from "./audience.js";
  * Where the approved plan mounts in the implement execution's workspace —
  * the harnesses' standard attachment inputs directory, where the runner's
  * implement-plan directive points the agent (shared/implement-plan-prompt.ts).
- * Attaching at this exact path is what makes the build implement the document
- * the user approved (including in-place edits), not a paraphrase from memory.
+ * Attaching under the plan's own filename (e.g. `feature-x_a1b2c3d4.plan.md`) is what
+ * makes the build implement the document the user approved (including in-place
+ * edits), not a paraphrase from memory; the runner detects it by the plan
+ * filename convention (`isPlanArtifactName`), so the exact name is free to vary.
  */
-const APPROVED_PLAN_MOUNT_PATH = `.stigmer/inputs/${PLAN_ARTIFACT_NAME}`;
+function approvedPlanMountPath(planFileName: string): string {
+  return `.stigmer/inputs/${planFileName}`;
+}
 
 /**
  * The build turn's user message — a short human-readable label, NOT the
  * implement instruction. The agent-facing instruction is runner-injected
- * (keyed off `executionConfig.buildFromPlan`), so this text exists for
- * humans: the thread renders the turn as a compact chip from the same flag,
- * and surfaces without the chip treatment (the CLI, older clients) show
- * this label as-is.
+ * (keyed off `executionConfig.buildFromPlan`). The thread hides the turn
+ * entirely from the same flag (the plan card above it is the visible cause);
+ * this label exists for surfaces without that treatment (the CLI, execution
+ * history, older clients), which show it as-is.
  */
 const BUILD_FROM_PLAN_MESSAGE = "Build from plan";
 
@@ -377,7 +385,7 @@ export function SessionViewer({
     setPlanAttachFailed(false);
 
     // `buildFromPlan` (not message text) is what tells the runner to inject
-    // the implement directive and the thread to render the compact chip —
+    // the implement directive and the thread to hide the turn's message —
     // with or without the attachment (the runner picks the directive variant).
     const submitImplementTurn = (attachments?: AttachmentInput[]) => {
       composerRef.current?.submit(BUILD_FROM_PLAN_MESSAGE, {
@@ -398,22 +406,25 @@ export function SessionViewer({
     // execution. The published artifact itself stays immutable; the approved
     // copy is a new input on the build turn (edit-as-input provenance).
     setIsBuildingFromPlan(true);
+    // The approved copy keeps the published plan's filename, so the mounted
+    // input, the download, and the plan card all agree on one name.
+    const planFileName = sessionPlan.artifact.name;
     void (async () => {
       try {
         const approvedText =
           planDraft.readDraft() ?? (await fetchPlanText(stigmer, sessionPlan));
         const response = await stigmer.agentExecution.uploadAttachment(
           create(UploadAttachmentRequestSchema, {
-            filename: PLAN_ARTIFACT_NAME,
+            filename: planFileName,
             content: new TextEncoder().encode(approvedText),
             contentType: "text/markdown",
           }),
         );
         submitImplementTurn([
           {
-            filename: PLAN_ARTIFACT_NAME,
+            filename: planFileName,
             storageKey: response.storageKey,
-            mountPath: APPROVED_PLAN_MOUNT_PATH,
+            mountPath: approvedPlanMountPath(planFileName),
             contentType: "text/markdown",
           },
         ]);
@@ -655,6 +666,20 @@ const ConversationColumn = memo(function ConversationColumn({
     [conv.stop, composerRef],
   );
 
+  // The composer-docked FileReviewDock sits OUTSIDE MessageThread, so the
+  // thread's own FilePathContext provider does not reach it. This provider
+  // gives the dock's file list the same path resolution and click routing
+  // (open in the panel's viewer; GitHub/copy fallback) as the transcript —
+  // one click behavior for a path everywhere in the session. Memoized so the
+  // dock's memoized cards are not invalidated by unrelated renders (DD-010).
+  const dockFilePathCtx = useMemo<FilePathContextValue>(
+    () => ({
+      workspaceEntries: conv.workspaceEntries ?? [],
+      onFilePathClick,
+    }),
+    [conv.workspaceEntries, onFilePathClick],
+  );
+
   return (
     <div className="flex h-full min-w-0 flex-col">
       <MessageThread
@@ -703,12 +728,19 @@ const ConversationColumn = memo(function ConversationColumn({
             decision the agent is blocked on can never scroll out of view. The
             thread renders only observational rows (badges) and read-only
             settled records; this is the one decision surface. */}
-        <FileReviewDock
-          changeSets={conv.fileChangeSets}
-          onSubmit={conv.submitFileDecision}
-          submittingDecisionKeys={conv.submittingFileDecisionKeys}
-          decisionErrors={conv.fileDecisionErrors}
-        />
+        <FilePathContext.Provider value={dockFilePathCtx}>
+          {/* Mid-run live capture (DD-32): the "N files changed so far" strip for
+              a still-running turn. Mutually exclusive with the dock below —
+              progress shows while CAPTURING, the dock once AWAITING_REVIEW — so it
+              hands off cleanly when review opens. Non-interactive. */}
+          <FileChangeProgressBar progress={conv.fileChangeProgress} />
+          <FileReviewDock
+            changeSets={conv.fileChangeSets}
+            onSubmit={conv.submitFileDecision}
+            submittingDecisionKeys={conv.submittingFileDecisionKeys}
+            decisionErrors={conv.fileDecisionErrors}
+          />
+        </FilePathContext.Provider>
         <SessionComposer
           ref={composerRef}
           onSubmit={flow.handleSubmit}