@stigmer/react 3.1.2 → 3.1.4

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

@@ -7,6 +7,7 @@ import {
   AgentExecutionStatusSchema,
   type AgentExecution,
 } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { AgentExecutionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
 import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { SessionSchema, type Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
 import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
@@ -25,7 +26,11 @@ function makeSession(id: string): Session {
   return session;
 }
 
-function makeExecution(id: string, phase: ExecutionPhase): AgentExecution {
+function makeExecution(
+  id: string,
+  phase: ExecutionPhase,
+  opts?: { supersedes?: string },
+): AgentExecution {
   const exec = create(AgentExecutionSchema);
   const metadata = create(ApiResourceMetadataSchema);
   metadata.id = id;
@@ -33,6 +38,11 @@ function makeExecution(id: string, phase: ExecutionPhase): AgentExecution {
   const status = create(AgentExecutionStatusSchema);
   status.phase = phase;
   exec.status = status;
+  if (opts?.supersedes) {
+    const spec = create(AgentExecutionSpecSchema);
+    spec.supersedesExecutionId = opts.supersedes;
+    exec.spec = spec;
+  }
   return exec;
 }
 
@@ -312,6 +322,50 @@ describe("useSessionConversation", () => {
     });
   });
 
+  it("sets NO optimistic pendingUserMessage for a buildFromPlan send (the thread hides the turn)", async () => {
+    methods.listBySession.mockResolvedValue({ entries: [] });
+    const newExec = makeExecution("new-exec", ExecutionPhase.EXECUTION_PENDING);
+    newExec.metadata!.id = "new-exec";
+    methods.executionCreate.mockResolvedValue(newExec);
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.sendFollowUp("Build from plan", {
+        buildFromPlan: true,
+      });
+    });
+
+    expect(result.current.pendingUserMessage).toBeNull();
+    expect(methods.executionCreate).toHaveBeenCalledWith(
+      expect.objectContaining({ message: "Build from plan" }),
+    );
+  });
+
+  it("sets pendingUserMessage when a buildFromPlan send FAILS (failure must be visible)", async () => {
+    methods.listBySession.mockResolvedValue({ entries: [] });
+    methods.executionCreate.mockRejectedValue(new Error("create boom"));
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.sendFollowUp("Build from plan", {
+        buildFromPlan: true,
+      });
+    });
+
+    expect(result.current.sendError?.message).toBe("create boom");
+    expect(result.current.pendingUserMessage).toBe("Build from plan");
+  });
+
   it("preserves the message and surfaces sendError when the send fails", async () => {
     methods.listBySession.mockResolvedValue({ entries: [] });
     methods.executionCreate.mockRejectedValue(new Error("create boom"));
@@ -505,6 +559,167 @@ describe("useSessionConversation", () => {
   });
 });
 
+describe("useSessionConversation — supersede filtering (edit-and-resubmit)", () => {
+  let methods: MockMethods;
+  let mockStigmer: Stigmer;
+  let stream: ReturnType<typeof createControllableStream<AgentExecution>>;
+
+  beforeEach(() => {
+    stream = createControllableStream<AgentExecution>();
+    methods = {
+      sessionGet: vi.fn().mockResolvedValue(makeSession("session-1")),
+      listBySession: vi.fn().mockResolvedValue({ entries: [] }),
+      executionCreate: vi.fn(),
+      subscribe: vi.fn().mockReturnValue(stream.generator),
+      submitApproval: vi.fn().mockResolvedValue({}),
+    };
+    mockStigmer = createMockStigmer(methods);
+  });
+
+  it("hides a superseded execution from completedExecutions", async () => {
+    const cancelled = makeExecution("e1", ExecutionPhase.EXECUTION_CANCELLED);
+    const successor = makeExecution("e2", ExecutionPhase.EXECUTION_COMPLETED, {
+      supersedes: "e1",
+    });
+    methods.listBySession.mockResolvedValue({
+      entries: [cancelled, successor],
+    });
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.completedExecutions).toHaveLength(1);
+    expect(result.current.completedExecutions[0]).toBe(successor);
+  });
+
+  it("hides every link of a chained supersede (A <- B <- C)", async () => {
+    const a = makeExecution("e1", ExecutionPhase.EXECUTION_CANCELLED);
+    const b = makeExecution("e2", ExecutionPhase.EXECUTION_CANCELLED, {
+      supersedes: "e1",
+    });
+    const c = makeExecution("e3", ExecutionPhase.EXECUTION_COMPLETED, {
+      supersedes: "e2",
+    });
+    methods.listBySession.mockResolvedValue({ entries: [a, b, c] });
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.completedExecutions).toHaveLength(1);
+    expect(result.current.completedExecutions[0]).toBe(c);
+  });
+
+  it("filters via the streaming successor's link before the list refetch delivers it", async () => {
+    // The stopped turn is still the only listed execution; its successor
+    // exists only as the live stream — the supersede link must be read off
+    // the stream copy for the old turn to disappear immediately.
+    const stopped = makeExecution("e1", ExecutionPhase.EXECUTION_IN_PROGRESS);
+    methods.listBySession.mockResolvedValue({ entries: [stopped] });
+
+    const successorStream = createControllableStream<AgentExecution>();
+    methods.subscribe.mockReturnValue(successorStream.generator);
+    methods.executionCreate.mockResolvedValue(
+      makeExecution("e2", ExecutionPhase.EXECUTION_PENDING),
+    );
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.sendFollowUp("corrected message", {
+        supersedesExecutionId: "e1",
+      });
+    });
+
+    act(() => {
+      successorStream.push(
+        makeExecution("e2", ExecutionPhase.EXECUTION_IN_PROGRESS, {
+          supersedes: "e1",
+        }),
+      );
+    });
+
+    await waitFor(() => {
+      expect(result.current.completedExecutions).toHaveLength(0);
+    });
+  });
+
+  it("treats a dangling supersede link as a no-op", async () => {
+    const completed = makeExecution("e1", ExecutionPhase.EXECUTION_COMPLETED);
+    const successor = makeExecution("e2", ExecutionPhase.EXECUTION_COMPLETED, {
+      supersedes: "does-not-exist",
+    });
+    methods.listBySession.mockResolvedValue({
+      entries: [completed, successor],
+    });
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.completedExecutions).toHaveLength(2);
+  });
+
+  it("sendFollowUp forwards supersedesExecutionId to execution creation", async () => {
+    methods.listBySession.mockResolvedValue({ entries: [] });
+    methods.executionCreate.mockResolvedValue(
+      makeExecution("e2", ExecutionPhase.EXECUTION_PENDING),
+    );
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.sendFollowUp("corrected message", {
+        supersedesExecutionId: "e1",
+      });
+    });
+
+    expect(methods.executionCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: "corrected message",
+        supersedesExecutionId: "e1",
+      }),
+    );
+  });
+
+  it("keeps active-id resolution on the raw list when the superseded turn is still winding down", async () => {
+    // e1 was cancelled but has not reached a terminal phase yet; e2 (its
+    // successor) is the active turn. The display filter hides e1, but the
+    // active execution must still resolve to e2 from the UNfiltered list.
+    const windingDown = makeExecution("e1", ExecutionPhase.EXECUTION_IN_PROGRESS);
+    const successor = makeExecution("e2", ExecutionPhase.EXECUTION_IN_PROGRESS, {
+      supersedes: "e1",
+    });
+    methods.listBySession.mockResolvedValue({
+      entries: [windingDown, successor],
+    });
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.activeStreamExecution?.metadata?.id).toBe("e2");
+    expect(result.current.completedExecutions).toHaveLength(0);
+  });
+});
+
 describe("useSessionConversation — local runner worker lifecycle", () => {
   let methods: MockMethods;
   let mockStigmer: Stigmer;

package/src/session/__tests__/useSessionPanel.test.ts

@@ -1,8 +1,15 @@
 import { describe, it, expect, afterEach } from "vitest";
 import { renderHook, act, cleanup } from "@testing-library/react";
-import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { create } from "@bufbuild/protobuf";
+import {
+  ExecutionArtifactKind,
+  ExecutionPhase,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { ExecutionArtifactSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/artifact_pb";
 import { useSessionPanel, type UseSessionPanelOptions } from "../useSessionPanel";
 import { PLAN_DOCUMENT_ENTRY_ID, PLAN_DOCUMENT_PATH } from "../plan-document";
+import { ARTIFACT_DOCUMENT_ENTRY_ID } from "../artifact-document";
+import { artifactKey } from "../useSessionArtifacts";
 import type { SelectedThreadItem } from "../../internal/store/selection-store";
 
 // ---------------------------------------------------------------------------
@@ -255,6 +262,68 @@ describe("useSessionPanel — plan document tab", () => {
   });
 });
 
+describe("useSessionPanel — artifact document tabs", () => {
+  function artifact(sandboxPath: string, name: string) {
+    return create(ExecutionArtifactSchema, {
+      name,
+      kind: ExecutionArtifactKind.FILE,
+      sandboxPath,
+      storageKey: `artifacts/aex_1/${name}`,
+    });
+  }
+
+  it("openArtifact opens the panel with a PREVIEW tab keyed by artifactKey", () => {
+    const { result } = renderPanel();
+    const a = artifact(".stigmer/notes.md", "notes.md");
+    act(() => result.current.openArtifact(a));
+
+    expect(result.current.isOpen).toBe(true);
+    expect(result.current.editorsStore.getSnapshot().editors).toEqual([
+      { entryId: ARTIFACT_DOCUMENT_ENTRY_ID, path: artifactKey(a), preview: true },
+    ]);
+  });
+
+  it("reuses the single preview slot as different artifacts are browsed", () => {
+    const { result } = renderPanel();
+    act(() => result.current.openArtifact(artifact(".stigmer/a.md", "a.md")));
+    act(() => result.current.openArtifact(artifact(".stigmer/b.md", "b.md")));
+
+    // VS Code preview semantics: single-click browsing reuses one tab.
+    expect(result.current.editorsStore.getSnapshot().editors).toEqual([
+      { entryId: ARTIFACT_DOCUMENT_ENTRY_ID, path: ".stigmer/b.md", preview: true },
+    ]);
+  });
+
+  it("does not evict a pinned plan tab when an artifact opens", () => {
+    const { result } = renderPanel();
+    act(() => result.current.openPlanDocument());
+    act(() => result.current.openArtifact(artifact(".stigmer/a.md", "a.md")));
+
+    expect(result.current.editorsStore.getSnapshot().editors).toEqual([
+      { entryId: PLAN_DOCUMENT_ENTRY_ID, path: PLAN_DOCUMENT_PATH, preview: false },
+      { entryId: ARTIFACT_DOCUMENT_ENTRY_ID, path: ".stigmer/a.md", preview: true },
+    ]);
+  });
+
+  it("pinArtifact promotes an open artifact preview to a persistent tab", () => {
+    const { result } = renderPanel();
+    const a = artifact(".stigmer/notes.md", "notes.md");
+    // The single-click open leaves a preview tab; the double-click pins it.
+    act(() => result.current.openArtifact(a));
+    act(() => result.current.pinArtifact(a));
+
+    expect(result.current.editorsStore.getSnapshot().editors).toEqual([
+      { entryId: ARTIFACT_DOCUMENT_ENTRY_ID, path: artifactKey(a), preview: false },
+    ]);
+  });
+
+  it("pinArtifact is a no-op when the artifact is not open (mirrors the store's generic pin)", () => {
+    const { result } = renderPanel();
+    act(() => result.current.pinArtifact(artifact(".stigmer/x.md", "x.md")));
+    expect(result.current.editorsStore.getSnapshot().editors).toEqual([]);
+  });
+});
+
 describe("useSessionPanel — defaultView (home view)", () => {
   it("seeds the view to the provided defaultView (launcher homes on Config)", () => {
     const { result } = renderPanel({ defaultView: "configure" });

package/src/session/artifact-document.ts

@@ -0,0 +1,23 @@
+// Identity of the session's artifact document tabs in the workspace surface's
+// editor group.
+//
+// Kept in its own module (not in ArtifactDocument.tsx) so behavior-only
+// consumers — useSessionPanel opens an artifact tab, SessionViewer routes to it
+// — depend on the identity without pulling the component (and its content
+// renderer) into their module graph (DD-003 headless-first). Mirrors
+// plan-document.ts.
+
+import { virtualEntryId } from "../internal/store/index.js";
+
+/**
+ * Virtual entry id of the artifact document FAMILY. Unlike the plan (one tab
+ * per session), artifacts are many: every opened artifact shares this one
+ * entry id and is distinguished by its {@link artifactKey}-derived `path`, so
+ * `editorKey(ARTIFACT_DOCUMENT_ENTRY_ID, path)` yields one tab per artifact —
+ * the VS Code "each file is a tab" model. The NUL-namespaced virtual id can
+ * never alias a real workspace entry, and its distinct `"artifact"` kind can
+ * never collide with the plan tab's `"plan"` kind.
+ *
+ * @see artifactKey — the `path` component (an artifact's stable identity)
+ */
+export const ARTIFACT_DOCUMENT_ENTRY_ID = virtualEntryId("artifact");

package/src/session/facets/ArtifactsTab.tsx

@@ -4,10 +4,11 @@ import { useCallback, useState } from "react";
 import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import {
   useSessionArtifacts,
+  artifactKey,
   type SessionArtifactEntry,
 } from "../useSessionArtifacts.js";
-import { ArtifactCard } from "../../execution/ArtifactCard.js";
 import { ArtifactPreviewModal } from "../../execution/ArtifactPreviewModal.js";
+import { ArtifactRow } from "../../execution/ArtifactRow.js";
 import { isPlanArtifact } from "../../library/detect-plan-artifact.js";
 import type { ApplyResourceResult } from "../../library/useApplyResource.js";
 
@@ -29,14 +30,39 @@ export interface ArtifactsTabProps {
    * every artifact.
    */
   readonly onOpenPlan?: (executionId: string) => void;
+  /**
+   * Open an artifact as an editor-pane document (the session panel's
+   * artifact-family virtual-document tab — the VS Code "each file is a tab"
+   * model). When provided, clicking a non-plan artifact routes here instead of
+   * the preview modal. When omitted (panel-less hosts) the modal remains the
+   * open mechanism. Plan artifacts always defer to {@link onOpenPlan} first.
+   */
+  readonly onOpenArtifact?: (entry: SessionArtifactEntry) => void;
+  /**
+   * Pin a non-plan artifact's document tab — the double-click half of the
+   * open/activate split (mirrors the file tree's `onOpenFile`/`onActivateFile`).
+   * When provided, each row binds a double-click that promotes the preview the
+   * single click opened. Omit in panel-less/modal hosts: with no handler the
+   * row binds no double-click, so a double-click is just two harmless single
+   * clicks. Plans always route to {@link onOpenPlan} (their tab is already
+   * pinned), so double-click == single-click for a plan.
+   */
+  readonly onActivateArtifact?: (entry: SessionArtifactEntry) => void;
 }
 
 /**
  * Artifacts facet for the session panel (a `useSessionRailViews` rail view).
  *
- * Wraps `useSessionArtifacts` → `ArtifactCard` list with
- * `ArtifactPreviewModal` — the same content as `ArtifactsWidget`
- * without the section heading.
+ * A VS Code-style dense file list of the session's outputs: one compact
+ * {@link ArtifactRow} per artifact (shared file-type icon + name + size, with a
+ * hover/focus Download). Clicking a row opens the artifact — a `plan.md` in the
+ * plan document tab ({@link onOpenPlan}), any other artifact in an editor-pane
+ * document ({@link onOpenArtifact}), or, for panel-less hosts that inject
+ * neither, the {@link ArtifactPreviewModal} popup fallback.
+ *
+ * Deliberately metadata-only: rows do NOT fetch content for resource detection
+ * (that would be one request per artifact on open) — detection and the
+ * Apply/Push action live in the opened document/modal instead.
  */
 export function ArtifactsTab({
   executions,
@@ -44,20 +70,41 @@ export function ArtifactsTab({
   onApplied,
   onImplementPlan,
   onOpenPlan,
+  onOpenArtifact,
+  onActivateArtifact,
 }: ArtifactsTabProps) {
   const { artifacts, hasArtifacts } = useSessionArtifacts(executions);
   const [previewEntry, setPreviewEntry] = useState<SessionArtifactEntry | null>(null);
 
-  const handlePreview = useCallback(
+  const handleOpen = useCallback(
     (entry: SessionArtifactEntry) => {
-      // The plan opens as a document (the panel's plan tab), never a popup.
+      // A plan is a first-class document — it opens in the dedicated plan tab,
+      // never as a generic artifact or a popup.
       if (onOpenPlan && isPlanArtifact(entry.artifact)) {
         onOpenPlan(entry.executionId);
         return;
       }
+      // Editor-pane document when the host injected it; otherwise the modal.
+      if (onOpenArtifact) {
+        onOpenArtifact(entry);
+        return;
+      }
       setPreviewEntry(entry);
     },
-    [onOpenPlan],
+    [onOpenPlan, onOpenArtifact],
+  );
+
+  const handleActivate = useCallback(
+    (entry: SessionArtifactEntry) => {
+      // A plan's tab is always pinned, so double-click matches single-click:
+      // route to the plan tab, never pin a generic artifact.
+      if (onOpenPlan && isPlanArtifact(entry.artifact)) {
+        onOpenPlan(entry.executionId);
+        return;
+      }
+      onActivateArtifact?.(entry);
+    },
+    [onOpenPlan, onActivateArtifact],
   );
 
   const handleClosePreview = useCallback(() => {
@@ -76,19 +123,20 @@ export function ArtifactsTab({
 
   return (
     <>
-      <div role="list" className="space-y-2">
+      <ul role="list" className="flex flex-col">
         {artifacts.map((entry) => (
-          <div key={entry.artifact.sandboxPath || entry.artifact.name} role="listitem">
-            <ArtifactCard
-              artifact={entry.artifact}
-              executionId={entry.executionId}
-              org={org}
-              hasNameCollision={entry.hasNameCollision}
-              onPreview={() => handlePreview(entry)}
-            />
-          </div>
+          <ArtifactRow
+            key={artifactKey(entry.artifact)}
+            artifact={entry.artifact}
+            executionId={entry.executionId}
+            hasNameCollision={entry.hasNameCollision}
+            onOpen={() => handleOpen(entry)}
+            onActivate={
+              onActivateArtifact ? () => handleActivate(entry) : undefined
+            }
+          />
         ))}
-      </div>
+      </ul>
 
       {previewEntry && (
         <ArtifactPreviewModal