@stigmer/react 3.1.2 → 3.1.4

package/src/session/SessionViewer.tsx

@@ -17,7 +17,7 @@ import {
   WorkspaceSurface,
   type SurfaceVirtualDocument,
 } from "../workspace/WorkspaceSurface.js";
-import type { InteractionModeOption, SessionComposerHandle } from "../composer/index.js";
+import type { InteractionModeOption, SessionComposerHandle, SessionComposerSubmitContext } from "../composer/index.js";
 import type { ApplyResourceResult } from "../library/useApplyResource.js";
 import { ResizableSplit } from "../internal/ResizableSplit.js";
 import { SelectionStore } from "../internal/store/selection-store.js";
@@ -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,
@@ -43,11 +47,17 @@ import { usePlanDraft, planDraftKey, type PlanDraftController } from "./usePlanD
 import { PlanEditor } from "./PlanEditor.js";
 import { PlanStreamingDocument } from "./PlanStreamingDocument.js";
 import { PLAN_DOCUMENT_ENTRY_ID, PLAN_DOCUMENT_PATH } from "./plan-document.js";
+import { ARTIFACT_DOCUMENT_ENTRY_ID } from "./artifact-document.js";
+import { ArtifactDocument } from "../execution/ArtifactDocument.js";
 import { useSessionRailViews } from "./useSessionRailViews.js";
 import { useSessionPanel, type SessionPanelController } from "./useSessionPanel.js";
 import { SessionPanelChip } from "./SessionPanelChip.js";
 import { useSessionWriteBacks } from "./useSessionWriteBacks.js";
-import { useSessionArtifacts } from "./useSessionArtifacts.js";
+import {
+  useSessionArtifacts,
+  artifactKey,
+  type SessionArtifactEntry,
+} from "./useSessionArtifacts.js";
 import type { SetupTabProps } from "./facets/SetupTab.js";
 import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import type { RuntimeEnvProvider } from "./runtime-env.js";
@@ -57,18 +67,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 +391,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 +412,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",
           },
         ]);
@@ -444,6 +461,28 @@ export function SessionViewer({
     [sessionPlan, panel.openPlanDocument],
   );
 
+  // "Open artifact" (an Artifacts-facet row) → an editor-pane document tab.
+  // Writing the editors store re-renders only the panel subtree (which
+  // subscribes), never this streaming column. Plan artifacts are routed to the
+  // plan tab upstream (in ArtifactsTab), so they never reach here.
+  const handleOpenArtifact = useCallback(
+    (entry: SessionArtifactEntry) => {
+      panel.openArtifact(entry.artifact);
+    },
+    [panel.openArtifact],
+  );
+
+  // Double-click an artifact row → pin its tab (the leading single click already
+  // opened the preview via `handleOpenArtifact`). Mirrors the file tree's
+  // preview/pin split; plan artifacts are routed to the plan tab upstream (in
+  // ArtifactsTab) and never reach here.
+  const handleActivateArtifact = useCallback(
+    (entry: SessionArtifactEntry) => {
+      panel.pinArtifact(entry.artifact);
+    },
+    [panel.pinArtifact],
+  );
+
   // Open a transcript tool-call file path in the panel's read-only editor.
   // Resolves the (possibly absolute / subdir-prefixed) path to a
   // repo/root-relative selection the editor can fetch; on a definite hit it
@@ -550,6 +589,8 @@ export function SessionViewer({
                 planDraft={planDraft}
                 openPlanExecutionId={openPlanExecutionId}
                 onOpenPlan={handleOpenPlan}
+                onOpenArtifact={handleOpenArtifact}
+                onActivateArtifact={handleActivateArtifact}
                 enableLocal={enableLocal}
                 onBrowseLocalFolder={onBrowseLocalFolder}
                 workspaceFileLister={workspaceFileLister}
@@ -641,18 +682,69 @@ const ConversationColumn = memo(function ConversationColumn({
     void conv.stop();
   }, [conv.stop]);
 
-  // Edit-and-resubmit: stop the in-flight turn and pre-fill the composer with
-  // the original text. The append-only execution log can't be rewritten, so
-  // the user reviews the prefilled message and resubmits it as a NEW execution
-  // through the normal Send pipeline. The cancelled turn stays in history with
-  // its phase badge — an honest record rather than a silent edit.
+  // Edit-and-resubmit: stop the in-flight turn, pre-fill the composer with
+  // the original text, and remember which execution is being edited. The
+  // append-only execution log is never rewritten — submitting while editing
+  // creates a NEW execution that carries `supersedesExecutionId`, and the
+  // conversation read model hides the superseded turn so the edited message
+  // replaces the original in place (Cursor-style, stigmer/stigmer#181).
+  //
+  // The editing state is explicit (banner + cancel in the composer) so the
+  // supersede link only attaches when the user actually resubmits the edit.
+  // Cancelling drops the link — a subsequent unrelated message appends
+  // normally without hiding any history.
+  const [editingExecutionId, setEditingExecutionId] = useState<string | null>(
+    null,
+  );
+  const activeExecutionId = conv.activeStreamExecution?.metadata?.id ?? null;
+
   const handleEditMessage = useCallback(
     (text: string) => {
       void conv.stop();
+      setEditingExecutionId(activeExecutionId);
       composerRef.current?.setMessage(text);
       composerRef.current?.focus();
     },
-    [conv.stop, composerRef],
+    [conv.stop, activeExecutionId, composerRef],
+  );
+
+  const handleCancelEdit = useCallback(() => {
+    setEditingExecutionId(null);
+    composerRef.current?.setMessage("");
+  }, [composerRef]);
+
+  // Submit wrapper that attaches the supersede link while editing, then
+  // exits editing mode. Ordinary (non-editing) submits pass through as-is.
+  const handleComposerSubmit = useCallback(
+    (
+      message: string,
+      modelName?: string,
+      context?: SessionComposerSubmitContext,
+    ) => {
+      void flow.handleSubmit(
+        message,
+        modelName,
+        editingExecutionId
+          ? { ...context, supersedesExecutionId: editingExecutionId }
+          : context,
+      );
+      setEditingExecutionId(null);
+    },
+    [flow.handleSubmit, editingExecutionId],
+  );
+
+  // 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 (
@@ -703,19 +795,28 @@ 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}
+          onSubmit={handleComposerSubmit}
           isSubmitting={conv.isSending}
           disabled={!conv.canSendFollowUp}
           onStop={conv.isStoppable ? handleStop : undefined}
           isStopping={conv.isStopping}
+          isEditing={editingExecutionId != null}
+          onCancelEdit={handleCancelEdit}
           org={org}
           harness={flow.harness}
           defaultModelId={modelId}
@@ -783,6 +884,10 @@ interface SessionPanelRegionProps {
   readonly openPlanExecutionId: string | null;
   /** Opens a plan in the plan tab (routed to the Artifacts facet's plan.md). */
   readonly onOpenPlan: (executionId: string) => void;
+  /** Opens an artifact as an editor-pane document (routed to the Artifacts facet). */
+  readonly onOpenArtifact: (entry: SessionArtifactEntry) => void;
+  /** Pins an artifact's document tab — the double-click half of the open/pin split. */
+  readonly onActivateArtifact: (entry: SessionArtifactEntry) => void;
   readonly enableLocal: boolean;
   readonly onBrowseLocalFolder?: () => Promise<string | null>;
   readonly workspaceFileLister?: WorkspaceFileLister;
@@ -804,6 +909,8 @@ function SessionPanelRegion({
   planDraft,
   openPlanExecutionId,
   onOpenPlan,
+  onOpenArtifact,
+  onActivateArtifact,
   enableLocal,
   onBrowseLocalFolder,
   workspaceFileLister,
@@ -815,6 +922,9 @@ function SessionPanelRegion({
   const { editors, activeKey, activeFile, reveal } = useWorkspaceEditors(
     panel.editorsStore,
   );
+  // Session artifacts, deduped by identity — the source both the Artifacts
+  // rail-view badge and the open artifact document tabs resolve against.
+  const { artifacts: sessionArtifacts } = useSessionArtifacts(flow.allExecutions);
 
   // Honor a pending jump-to-line reveal only while it targets the active editor
   // (an EditorReveal is structurally a RevealTarget). Switching tabs changes
@@ -870,30 +980,28 @@ function SessionPanelRegion({
   // tab and its turn then ended without publishing, with no earlier plan to
   // fall back to.
   const openPlanIsLatest = openPlan?.executionId === sessionPlan?.executionId;
-  const virtualDocuments = useMemo<readonly SurfaceVirtualDocument[]>(() => {
-    return [
-      {
-        entryId: PLAN_DOCUMENT_ENTRY_ID,
-        path: PLAN_DOCUMENT_PATH,
-        content: streamingPlan ? (
-          <PlanStreamingDocument
-            key={`streaming-${streamingPlan.executionId}`}
-            displayText={streamingPlan.displayText}
-          />
-        ) : openPlan ? (
-          <PlanEditor
-            key={planDraftKey(openPlan)}
-            plan={openPlan}
-            draft={openPlanIsLatest ? planDraft : undefined}
-            onBuildFromPlan={openPlanIsLatest ? onImplementPlan : undefined}
-            buildDisabled={implementPlanDisabled}
-            readOnly={!openPlanIsLatest}
-          />
-        ) : (
-          <PlanUnavailableNotice />
-        ),
-      },
-    ];
+  const planVirtualDocument = useMemo<SurfaceVirtualDocument>(() => {
+    return {
+      entryId: PLAN_DOCUMENT_ENTRY_ID,
+      path: PLAN_DOCUMENT_PATH,
+      content: streamingPlan ? (
+        <PlanStreamingDocument
+          key={`streaming-${streamingPlan.executionId}`}
+          displayText={streamingPlan.displayText}
+        />
+      ) : openPlan ? (
+        <PlanEditor
+          key={planDraftKey(openPlan)}
+          plan={openPlan}
+          draft={openPlanIsLatest ? planDraft : undefined}
+          onBuildFromPlan={openPlanIsLatest ? onImplementPlan : undefined}
+          buildDisabled={implementPlanDisabled}
+          readOnly={!openPlanIsLatest}
+        />
+      ) : (
+        <PlanUnavailableNotice />
+      ),
+    };
   }, [
     streamingPlan,
     openPlan,
@@ -903,6 +1011,50 @@ function SessionPanelRegion({
     implementPlanDisabled,
   ]);
 
+  // The open artifact document tabs (the artifact virtual-document FAMILY).
+  // Built in a SEPARATE memo from the plan doc so artifact-tab churn never
+  // recreates the plan doc (and vice versa). Bounded to what is actually open:
+  // one document per editor whose entry id is the artifact family's, resolved
+  // back to its `SessionArtifactEntry` by the same `artifactKey` used to open
+  // it (single source of truth for artifact identity). Only the ACTIVE doc's
+  // `content` is mounted by the surface, so building these elements is cheap;
+  // keying on `contentHash` remounts a tab whose artifact was overwritten by a
+  // later execution. A tab whose artifact no longer exists degrades to an
+  // honest notice rather than vanishing.
+  const artifactByKey = useMemo(
+    () =>
+      new Map(sessionArtifacts.map((entry) => [artifactKey(entry.artifact), entry])),
+    [sessionArtifacts],
+  );
+  const artifactVirtualDocuments = useMemo<readonly SurfaceVirtualDocument[]>(() => {
+    return editors
+      .filter((editor) => editor.entryId === ARTIFACT_DOCUMENT_ENTRY_ID)
+      .map((editor) => {
+        const entry = artifactByKey.get(editor.path);
+        return {
+          entryId: ARTIFACT_DOCUMENT_ENTRY_ID,
+          path: editor.path,
+          content: entry ? (
+            <ArtifactDocument
+              key={entry.artifact.contentHash || editor.path}
+              artifact={entry.artifact}
+              executionId={entry.executionId}
+              org={org}
+              isTerminal={entry.isTerminal}
+              onApplied={onApplied}
+            />
+          ) : (
+            <ArtifactUnavailableNotice />
+          ),
+        };
+      });
+  }, [editors, artifactByKey, org, onApplied]);
+
+  const virtualDocuments = useMemo<readonly SurfaceVirtualDocument[]>(
+    () => [planVirtualDocument, ...artifactVirtualDocuments],
+    [planVirtualDocument, artifactVirtualDocuments],
+  );
+
   const handleRemoveAgent = useCallback(() => {
     flow.setAgentRef(null);
     flow.setResolution(null);
@@ -969,6 +1121,8 @@ function SessionPanelRegion({
     onApplied,
     onImplementPlan,
     onOpenPlan,
+    onOpenArtifact,
+    onActivateArtifact,
   });
 
   // Explorer-footer folder attach (desktop only — needs the native picker).
@@ -1093,6 +1247,28 @@ function PlanUnavailableNotice() {
   );
 }
 
+/**
+ * Shown in an artifact document tab whose artifact is no longer among the
+ * session's outputs (an edge only reachable if the executions backing the tab
+ * changed underneath it). The tab stays closable; the content is honest rather
+ * than blank.
+ */
+function ArtifactUnavailableNotice() {
+  return (
+    <div
+      role="status"
+      className="mx-auto flex w-full max-w-3xl flex-col items-center gap-1 px-4 py-8 text-center"
+    >
+      <p className="text-xs font-medium text-foreground">
+        This artifact is no longer available.
+      </p>
+      <p className="text-xs text-muted-foreground">
+        It may have been replaced by a newer version of this session.
+      </p>
+    </div>
+  );
+}
+
 /**
  * Non-blocking notice for a build that fell back to message-only implement
  * (the approved plan.md could not be uploaded/attached). The build itself

package/src/session/__tests__/PlanEditor.test.tsx

@@ -81,9 +81,9 @@ describe("PlanEditor", () => {
     renderEditor({ onBuildFromPlan });
 
     await waitFor(() =>
-      expect(screen.getByText("Build from plan")).toBeTruthy(),
+      expect(screen.getByText("Build")).toBeTruthy(),
     );
-    fireEvent.click(screen.getByText("Build from plan"));
+    fireEvent.click(screen.getByText("Build"));
     expect(onBuildFromPlan).toHaveBeenCalledTimes(1);
   });
 
@@ -99,7 +99,7 @@ describe("PlanEditor", () => {
     );
     expect(screen.getByText("Rollout Plan").className).toContain("truncate");
 
-    const buildLabel = screen.getByText("Build from plan");
+    const buildLabel = screen.getByText("Build");
     expect(buildLabel.className).toContain("truncate");
     const toolbar = screen.getByRole("tablist", { name: "Plan view" })
       .parentElement!;
@@ -188,7 +188,7 @@ describe("PlanEditor — read-only (superseded plan)", () => {
     );
     expect(screen.getByText("Superseded by a newer plan")).toBeTruthy();
     expect(screen.queryByText("Edit")).toBeNull();
-    expect(screen.queryByText("Build from plan")).toBeNull();
+    expect(screen.queryByText("Build")).toBeNull();
   });
 
   it("never applies the current plan's draft to a superseded plan", async () => {

package/src/session/__tests__/PlanStreamingDocument.test.tsx

@@ -44,7 +44,7 @@ describe("PlanStreamingDocument — live plan tab view", () => {
     render(<PlanStreamingDocument displayText={"# Live Plan\n\nBody"} />);
 
     expect(screen.queryByText("Edit")).toBeNull();
-    expect(screen.queryByText("Build from plan")).toBeNull();
+    expect(screen.queryByText("Build")).toBeNull();
     expect(screen.queryByRole("tablist")).toBeNull();
   });
 });