@stigmer/react 3.0.2 → 3.0.4

package/src/session/inspector/ArtifactsTab.tsx

@@ -8,12 +8,19 @@ import {
 } from "../useSessionArtifacts";
 import { ArtifactCard } from "../../execution/ArtifactCard";
 import { ArtifactPreviewModal } from "../../execution/ArtifactPreviewModal";
+import { isPlanArtifact } from "../../library/detect-plan-artifact";
 import type { ApplyResourceResult } from "../../library/useApplyResource";
 
 export interface ArtifactsTabProps {
   readonly executions: readonly AgentExecution[];
   readonly org: string;
   readonly onApplied?: (result: ApplyResourceResult) => void;
+  /**
+   * Implement a plan. When provided, the preview of a `plan.md` artifact
+   * shows an Implement action (turn the plan into an Agent run) — the same
+   * action as the message-thread plan card.
+   */
+  readonly onImplementPlan?: () => void;
 }
 
 /**
@@ -23,7 +30,7 @@ export interface ArtifactsTabProps {
  * `ArtifactPreviewModal` — the same content as `ArtifactsWidget`
  * without the section heading.
  */
-export function ArtifactsTab({ executions, org, onApplied }: ArtifactsTabProps) {
+export function ArtifactsTab({ executions, org, onApplied, onImplementPlan }: ArtifactsTabProps) {
   const { artifacts, hasArtifacts } = useSessionArtifacts(executions);
   const [previewEntry, setPreviewEntry] = useState<SessionArtifactEntry | null>(null);
 
@@ -70,6 +77,9 @@ export function ArtifactsTab({ executions, org, onApplied }: ArtifactsTabProps)
           open
           onClose={handleClosePreview}
           onApplied={onApplied}
+          onImplement={
+            isPlanArtifact(previewEntry.artifact) ? onImplementPlan : undefined
+          }
         />
       )}
     </>

package/src/session/inspector/SessionInspector.tsx

@@ -39,6 +39,11 @@ export interface SessionInspectorProps {
   readonly selectedItem: SelectedThreadItem | null;
   /** Called after a resource is applied from the Artifacts tab. */
   readonly onApplied?: (result: ApplyResourceResult) => void;
+  /**
+   * Implement a plan from the Artifacts tab. When provided, plan
+   * artifacts (`plan.md`) surface an Implement action in their preview.
+   */
+  readonly onImplementPlan?: () => void;
   /**
    * Session-level configuration for the Configure tab.
    * Includes core config fields and optional interactive
@@ -79,6 +84,7 @@ export const SessionInspector = memo(function SessionInspector({
   org,
   selectedItem,
   onApplied,
+  onImplementPlan,
   sessionConfig,
   workspaceConfig,
   className,
@@ -138,6 +144,7 @@ export const SessionInspector = memo(function SessionInspector({
               executions={allExecutions}
               org={org}
               onApplied={onApplied}
+              onImplementPlan={onImplementPlan}
             />
           )}
           {activeTab === "usage" && (

package/src/session/inspector/__tests__/ArtifactsTab.test.tsx

@@ -0,0 +1,90 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, fireEvent, cleanup, within } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import type { Stigmer } from "@stigmer/sdk";
+import { AgentExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { ExecutionArtifactSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/artifact_pb";
+import {
+  ExecutionArtifactKind,
+  ExecutionPhase,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { StigmerContext } from "../../../context";
+import { ArtifactsTab } from "../ArtifactsTab";
+
+function artifact(name: string) {
+  return create(ExecutionArtifactSchema, {
+    name,
+    kind: ExecutionArtifactKind.FILE,
+    sizeBytes: 1024n,
+    sandboxPath: `.stigmer/${name}`,
+    storageKey: `artifacts/aex_1/${name}`,
+    downloadUrl: `https://example.test/${name}`,
+  });
+}
+
+const execution = create(AgentExecutionSchema, {
+  metadata: { id: "aex_1" },
+  status: {
+    phase: ExecutionPhase.EXECUTION_COMPLETED,
+    artifacts: [artifact("plan.md"), artifact("notes.md")],
+  },
+});
+
+/** Modal content fetch — keep pending so nothing rejects during the test. */
+function createStigmerMock(): Stigmer {
+  return {
+    agentExecution: {
+      getArtifactContent: vi.fn().mockReturnValue(new Promise(() => {})),
+    },
+  } as unknown as Stigmer;
+}
+
+function renderTab(onImplementPlan?: () => void) {
+  return render(
+    <StigmerContext.Provider value={createStigmerMock()}>
+      <ArtifactsTab
+        executions={[execution]}
+        org="acme"
+        onImplementPlan={onImplementPlan}
+      />
+    </StigmerContext.Provider>,
+  );
+}
+
+function openPreviewFor(name: string) {
+  const row = screen.getByText(name).closest("[role='listitem']") as HTMLElement;
+  fireEvent.click(within(row).getByText("Preview"));
+}
+
+afterEach(cleanup);
+
+describe("ArtifactsTab — plan Implement wiring", () => {
+  it("shows Implement in the preview of a plan.md artifact", () => {
+    renderTab(vi.fn());
+
+    openPreviewFor("plan.md");
+
+    const dialog = document.querySelector("dialog")!;
+    expect(within(dialog).getByText("Implement")).toBeTruthy();
+  });
+
+  it("does not show Implement in the preview of a non-plan artifact", () => {
+    renderTab(vi.fn());
+
+    openPreviewFor("notes.md");
+
+    const dialog = document.querySelector("dialog")!;
+    expect(within(dialog).queryByText("Implement")).toBeNull();
+  });
+
+  it("invokes onImplementPlan when Implement is clicked for a plan", () => {
+    const onImplementPlan = vi.fn();
+    renderTab(onImplementPlan);
+
+    openPreviewFor("plan.md");
+    const dialog = document.querySelector("dialog")!;
+    fireEvent.click(within(dialog).getByText("Implement"));
+
+    expect(onImplementPlan).toHaveBeenCalledTimes(1);
+  });
+});

package/src/session/useSessionPageFlow.ts

@@ -8,7 +8,8 @@ import { useDefaultAgent } from "../agent";
 import { useStigmer } from "../hooks";
 import { useWorkspaceEntries, type UseWorkspaceEntriesReturn } from "../workspace";
 import { useSessionVariables, type UseSessionVariablesReturn } from "../execution/useSessionVariables";
-import type { SessionComposerSubmitContext } from "../composer";
+import type { SessionComposerSubmitContext, InteractionModeOption } from "../composer";
+import { fromProtoInteractionMode } from "../composer";
 import { fromProtoHarness, type HarnessOption } from "../models/harness";
 import { Harness, ExecutionTarget } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
 import { fromProtoExecutionTarget, type ExecutionTargetOption } from "./execution-target";
@@ -59,6 +60,18 @@ export interface UseSessionPageFlowReturn {
   /** Persisted model selection: `[modelId, setModelId]`. */
   readonly model: UsePersistedModelReturn;
 
+  /**
+   * Composer interaction mode: `[interactionMode, setInteractionMode]`.
+   *
+   * Derived like {@link model}: the user's explicit override wins, otherwise
+   * it reflects the latest execution's mode (so a completed Plan keeps the
+   * picker on "Plan" while it awaits review), falling back to `"agent"`.
+   */
+  readonly interactionMode: readonly [
+    InteractionModeOption,
+    (mode: InteractionModeOption) => void,
+  ];
+
   /** Currently selected agent reference (derived from session, or overridden by user). */
   readonly agentRef: ResourceRef | null;
   /** Update the agent reference for future follow-ups. */
@@ -206,6 +219,24 @@ export function useSessionPageFlow(
   const modelId = persistedModelId ?? lastExecModelId;
   const model: UsePersistedModelReturn = [modelId, setPersistedModelId] as const;
 
+  // Interaction mode mirrors the model derivation: an explicit user override
+  // wins; otherwise reflect the latest execution's mode so a completed Plan
+  // keeps the composer on "Plan" until the user implements or switches. This
+  // is derived state (always consistent), never an effect-synced copy.
+  const lastExecInteractionMode = useMemo(
+    () =>
+      fromProtoInteractionMode(
+        conv.completedExecutions.at(-1)?.spec?.executionConfig?.interactionMode,
+      ),
+    [conv.completedExecutions],
+  );
+  const [interactionModeOverride, setInteractionMode] =
+    useState<InteractionModeOption | null>(null);
+  const interactionMode: UseSessionPageFlowReturn["interactionMode"] = [
+    interactionModeOverride ?? lastExecInteractionMode ?? "agent",
+    setInteractionMode,
+  ] as const;
+
   const workspace = useWorkspaceEntries();
   const sessionVariables = useSessionVariables();
   const [mcpServerUsages, setMcpServerUsages] = useState<McpServerUsageInput[]>([]);
@@ -369,6 +400,7 @@ export function useSessionPageFlow(
     harness,
     executionTarget,
     model,
+    interactionMode,
     agentRef,
     setAgentRef,
     resolution,