@stigmer/react 3.12.0 → 3.12.2

package/src/workflow/__tests__/WorkflowExecutionViewer.reconciliation.test.tsx

@@ -571,7 +571,9 @@ describe("WorkflowExecutionViewer (terminal-phase refetch, T04)", () => {
 
   // Re-mocks ONLY the stream stage (the execution mock — and its refetch
   // spy — must stay stable across the flip; the assertions count its calls).
-  function mockStreamStage(stage: "streaming" | "reconnecting" | "complete") {
+  function mockStreamStage(
+    stage: "connecting" | "streaming" | "reconnecting" | "complete",
+  ) {
     mockedUseEventStream.mockReturnValue({
       events: [],
       taskStates: new Map([
@@ -630,4 +632,49 @@ describe("WorkflowExecutionViewer (terminal-phase refetch, T04)", () => {
 
     expect(refetch).not.toHaveBeenCalled();
   });
+
+  // The other stale direction (oss#571's live-run finding): a page that
+  // lands BEFORE the run starts fetches a PENDING snapshot, and nothing
+  // refetched it when the run began — the phase badge and the phase-gated
+  // Pause/Cancel froze at "Pending" for the entire run. The store flips
+  // connecting → streaming exactly when the FIRST event is delivered, so
+  // that transition IS the "run started" signal.
+  it("the stream's first delivery refetches a pending-landing snapshot — the phase badge and Pause/Cancel catch up to the started run", () => {
+    const { refetch } = arrange(ExecutionPhase.EXECUTION_PENDING);
+    mockStreamStage("connecting");
+    const { rerender } = render(<WorkflowExecutionViewer executionId="wex_1" />);
+    expect(refetch).not.toHaveBeenCalled();
+
+    mockStreamStage("streaming");
+    rerender(
+      <WorkflowExecutionViewer executionId="wex_1" className="pass-2" />,
+    );
+    expect(refetch).toHaveBeenCalledTimes(1);
+
+    // Idempotent: staying in streaming never re-triggers.
+    rerender(
+      <WorkflowExecutionViewer executionId="wex_1" className="pass-3" />,
+    );
+    expect(refetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("a reconnect recovery (reconnecting → streaming) refetches — the snapshot may have moved during the outage", () => {
+    const { refetch } = arrange(ExecutionPhase.EXECUTION_IN_PROGRESS);
+    mockStreamStage("streaming");
+    const { rerender } = render(<WorkflowExecutionViewer executionId="wex_1" />);
+    // Mid-run mount: the snapshot was just fetched — no refetch.
+    expect(refetch).not.toHaveBeenCalled();
+
+    mockStreamStage("reconnecting");
+    rerender(
+      <WorkflowExecutionViewer executionId="wex_1" className="pass-2" />,
+    );
+    expect(refetch).not.toHaveBeenCalled();
+
+    mockStreamStage("streaming");
+    rerender(
+      <WorkflowExecutionViewer executionId="wex_1" className="pass-3" />,
+    );
+    expect(refetch).toHaveBeenCalledTimes(1);
+  });
 });

package/src/workflow/__tests__/WorkflowNode.test.tsx

@@ -0,0 +1,93 @@
+import { describe, test, expect, vi, afterEach } from "vitest";
+import { render, cleanup } from "@testing-library/react";
+import type { NodeProps } from "@xyflow/react";
+import { WorkflowTaskKind } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/enum_pb";
+import { WorkflowNode } from "../WorkflowNode";
+import { START_NODE_ID, END_NODE_ID } from "../workflow-graph-model";
+import type { CanvasTaskNodeData } from "../workflow-graph-conversions";
+
+// NodeHandles and NodeActions render @xyflow/react primitives (Handle,
+// NodeToolbar) that throw outside a live React Flow canvas. Stub them so
+// WorkflowNode's own DOM contract can be asserted in isolation — the
+// established pattern for React Flow-adjacent component tests in this suite.
+vi.mock("../node-shell/NodeHandles.js", () => ({
+  NodeHandles: () => null,
+}));
+vi.mock("../node-shell/NodeActions.js", () => ({
+  NodeActions: () => null,
+}));
+
+function makeData(overrides: Partial<CanvasTaskNodeData>): CanvasTaskNodeData {
+  return {
+    taskName: "analyze",
+    kind: WorkflowTaskKind.agent_call,
+    kindString: "agent_call",
+    category: "ai",
+    visualClass: "task-card",
+    displayName: "Agent Call",
+    ariaShapeLabel: "card",
+    config: {},
+    isSentinel: false,
+    ...overrides,
+  };
+}
+
+function renderNode(id: string, data: CanvasTaskNodeData) {
+  const props = { id, data, selected: false } as unknown as NodeProps & {
+    data: CanvasTaskNodeData;
+  };
+  return render(<WorkflowNode {...props} />);
+}
+
+afterEach(cleanup);
+
+describe("WorkflowNode data-task-kind contract (oss#581)", () => {
+  test("task nodes expose their kind string as data-task-kind", () => {
+    const { container } = renderNode("analyze", makeData({}));
+    const node = container.querySelector('[role="button"]');
+    expect(node).not.toBeNull();
+    expect(node!.getAttribute("data-task-kind")).toBe("agent_call");
+  });
+
+  test("sentinel nodes carry no data-task-kind attribute", () => {
+    for (const [id, taskName] of [
+      [START_NODE_ID, "Start"],
+      [END_NODE_ID, "End"],
+    ] as const) {
+      const { container, unmount } = renderNode(
+        id,
+        makeData({
+          taskName,
+          kind: WorkflowTaskKind.workflow_task_kind_unspecified,
+          kindString: id,
+          category: id === START_NODE_ID ? "start" : "end",
+          visualClass: "terminal-pill",
+          displayName: taskName,
+          ariaShapeLabel: "pill",
+          isSentinel: true,
+        }),
+      );
+      const node = container.querySelector('[role="button"]');
+      expect(node).not.toBeNull();
+      expect(node!.hasAttribute("data-task-kind")).toBe(false);
+      unmount();
+    }
+  });
+
+  test("the internal unknown_* enum fallback never reaches the DOM", () => {
+    const { container } = renderNode(
+      START_NODE_ID,
+      makeData({
+        taskName: "Start",
+        kind: WorkflowTaskKind.workflow_task_kind_unspecified,
+        kindString: START_NODE_ID,
+        category: "start",
+        visualClass: "terminal-pill",
+        displayName: "Start",
+        ariaShapeLabel: "pill",
+        isSentinel: true,
+      }),
+    );
+    expect(container.querySelector('[data-task-kind^="unknown_"]')).toBeNull();
+  });
+});

package/src/workflow/__tests__/WorkflowRunDialog.test.tsx

@@ -0,0 +1,127 @@
+// Tests for WorkflowRunDialog's `initialInstanceId` preselection (issue
+// #582): a row-level "Run" must open the dialog with that instance already
+// selected, while reopening without one resets to the server-resolved
+// default. Selection is asserted through the rendered instance <select> —
+// the observable surface — with the real useRunWorkflowFlow underneath.
+
+import { describe, it, expect, vi, beforeAll, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+import type { ReactNode } from "react";
+import type { Stigmer } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { WorkflowRunDialog } from "../WorkflowRunDialog";
+
+beforeAll(() => {
+  // happy-dom does not implement the native <dialog> modal API.
+  HTMLDialogElement.prototype.showModal = function showModal() {
+    this.open = true;
+  };
+  HTMLDialogElement.prototype.close = function close() {
+    this.open = false;
+  };
+});
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+function makeWorkflow() {
+  return {
+    metadata: { id: "wf_1", name: "my-workflow", slug: "my-workflow" },
+    spec: { env: {} },
+  } as never;
+}
+
+function makeInstance(id: string, name: string) {
+  return {
+    metadata: { id, name, slug: name },
+    spec: { environmentRefs: [] },
+  } as never;
+}
+
+// Two user instances so the picker always renders (it needs >= 1 user
+// instance when defaultInstanceId is provided).
+const DEFAULT_INSTANCE_ID = "wfi_default";
+const INSTANCES = [
+  makeInstance("wfi_a", "instance-a"),
+  makeInstance("wfi_b", "instance-b"),
+];
+
+const mockClient = {
+  workflowExecution: { create: vi.fn() },
+  environment: { getByReference: vi.fn() },
+} as unknown as Stigmer;
+
+function renderDialog(props?: {
+  open?: boolean;
+  initialInstanceId?: string | null;
+}) {
+  const ui = (dialogProps?: {
+    open?: boolean;
+    initialInstanceId?: string | null;
+  }) => (
+    <StigmerContext.Provider value={mockClient}>
+      <WorkflowRunDialog
+        open={dialogProps?.open ?? true}
+        onOpenChange={vi.fn()}
+        org="acme"
+        workflow={makeWorkflow()}
+        instances={INSTANCES}
+        defaultInstanceId={DEFAULT_INSTANCE_ID}
+        initialInstanceId={dialogProps?.initialInstanceId}
+        onSuccess={vi.fn()}
+        onError={vi.fn()}
+      />
+    </StigmerContext.Provider>
+  );
+  const result = render(ui(props));
+  return {
+    ...result,
+    rerenderDialog: (nextProps?: {
+      open?: boolean;
+      initialInstanceId?: string | null;
+    }) => result.rerender(ui(nextProps)),
+  };
+}
+
+function instanceSelect(): HTMLSelectElement {
+  return screen.getByLabelText("Instance") as HTMLSelectElement;
+}
+
+describe("WorkflowRunDialog initialInstanceId", () => {
+  it("preselects the requested instance when the dialog opens", () => {
+    renderDialog({ initialInstanceId: "wfi_b" });
+
+    expect(instanceSelect().value).toBe("wfi_b");
+  });
+
+  it("defaults to the server-resolved option when omitted", () => {
+    renderDialog();
+
+    // "" is the "Default (no specific configuration)" option.
+    expect(instanceSelect().value).toBe("");
+  });
+
+  it("falls back to the default option when the id is stale", () => {
+    renderDialog({ initialInstanceId: "wfi_deleted" });
+
+    expect(instanceSelect().value).toBe("");
+  });
+
+  it("applies the fresh preselection on each open transition", () => {
+    const { rerenderDialog } = renderDialog({ initialInstanceId: "wfi_a" });
+    expect(instanceSelect().value).toBe("wfi_a");
+
+    // Close, then reopen targeting a different instance (a second row's
+    // Run click) — the reset-then-preselect path must apply the new id.
+    rerenderDialog({ open: false, initialInstanceId: "wfi_a" });
+    rerenderDialog({ open: true, initialInstanceId: "wfi_b" });
+    expect(instanceSelect().value).toBe("wfi_b");
+
+    // Reopen with none (the header Run button) — back to the default.
+    rerenderDialog({ open: false, initialInstanceId: "wfi_b" });
+    rerenderDialog({ open: true, initialInstanceId: null });
+    expect(instanceSelect().value).toBe("");
+  });
+});

package/src/workflow/__tests__/graph-history.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect } from "vitest";
+import { GraphHistory, DeleteNodeCommand } from "../graph-commands";
+import { yamlToGraph } from "../workflow-graph-conversions";
+import { START_NODE_ID, END_NODE_ID } from "../workflow-graph-model";
+
+// Direct coverage for the GraphHistory command stack and the
+// DeleteNodeCommand round-trip. Before oss#588 nothing exercised
+// GraphHistory itself — the canvas-sync bug lived one layer up
+// (useGraphHistory/useWorkflowCanvas), but the stack's synchronous
+// return-the-model contract is what that fix builds on, so it is
+// pinned here.
+
+const FIXTURE_YAML = `apiVersion: agentic.stigmer.ai/v1
+kind: Workflow
+metadata:
+  name: undo-fixture
+spec:
+  document:
+    dsl: "1.0.0"
+    namespace: test
+    name: undo-fixture
+    version: "0.0.1"
+  tasks:
+    - name: step_1
+      kind: agent_call
+      task_config:
+        agent: "org/agent-slug"
+        message: "first"
+      flow:
+        then: step_2
+    - name: step_2
+      kind: agent_call
+      task_config:
+        agent: "org/agent-slug"
+        message: "second"
+      flow:
+        then: end
+`;
+
+function nodeIds(model: { nodes: readonly { id: string }[] }): string[] {
+  return model.nodes.map((n) => n.id);
+}
+
+describe("GraphHistory — delete/undo/redo round-trip", () => {
+  it("dispatch(DeleteNodeCommand) removes the node and its edges", () => {
+    const initial = yamlToGraph(FIXTURE_YAML);
+    const history = new GraphHistory(initial);
+
+    const next = history.dispatch(new DeleteNodeCommand("step_2", "step_2"));
+
+    expect(nodeIds(next)).not.toContain("step_2");
+    expect(next.edges.some((e) => e.source === "step_2" || e.target === "step_2")).toBe(false);
+    expect(history.canUndo).toBe(true);
+    expect(history.canRedo).toBe(false);
+  });
+
+  it("undo() synchronously returns the model with the node and edges restored", () => {
+    const initial = yamlToGraph(FIXTURE_YAML);
+    const history = new GraphHistory(initial);
+    const deleted = history.dispatch(new DeleteNodeCommand("step_2", "step_2"));
+    const removedEdgeCount = initial.edges.length - deleted.edges.length;
+    expect(removedEdgeCount).toBeGreaterThan(0);
+
+    const restored = history.undo();
+
+    expect(nodeIds(restored)).toContain("step_2");
+    expect(restored.edges).toHaveLength(initial.edges.length);
+    expect(history.current).toBe(restored);
+    expect(history.canUndo).toBe(false);
+    expect(history.canRedo).toBe(true);
+  });
+
+  it("redo() synchronously returns the model with the node removed again", () => {
+    const initial = yamlToGraph(FIXTURE_YAML);
+    const history = new GraphHistory(initial);
+    history.dispatch(new DeleteNodeCommand("step_2", "step_2"));
+    history.undo();
+
+    const redone = history.redo();
+
+    expect(nodeIds(redone)).not.toContain("step_2");
+    expect(history.canUndo).toBe(true);
+    expect(history.canRedo).toBe(false);
+  });
+
+  it("undo()/redo() on an empty stack return the current model unchanged", () => {
+    const initial = yamlToGraph(FIXTURE_YAML);
+    const history = new GraphHistory(initial);
+
+    expect(history.undo()).toBe(initial);
+    expect(history.redo()).toBe(initial);
+  });
+
+  it("sentinels survive the round-trip", () => {
+    const initial = yamlToGraph(FIXTURE_YAML);
+    const history = new GraphHistory(initial);
+    history.dispatch(new DeleteNodeCommand("step_1", "step_1"));
+    const restored = history.undo();
+
+    expect(nodeIds(restored)).toContain(START_NODE_ID);
+    expect(nodeIds(restored)).toContain(END_NODE_ID);
+  });
+});

package/src/workflow/__tests__/overview-graph.test.ts

@@ -51,6 +51,23 @@ describe("Overview graph pipeline", () => {
     expect((taskNode!.data as CanvasTaskNodeData).isSentinel).toBeFalsy();
   });
 
+  test("sentinel nodes carry the pseudo-kind as kindString, never the enum fallback (oss#581)", () => {
+    const laid = applyDagreLayout(threeNodeGraph);
+    const { nodes } = toReactFlowElements(laid);
+    const startData = nodes.find((n) => n.id === START_NODE_ID)!.data as CanvasTaskNodeData;
+    const endData = nodes.find((n) => n.id === END_NODE_ID)!.data as CanvasTaskNodeData;
+    expect(startData.kindString).toBe(START_NODE_ID);
+    expect(endData.kindString).toBe(END_NODE_ID);
+  });
+
+  test("no node's kindString is ever the internal unknown_* fallback", () => {
+    const laid = applyDagreLayout(threeNodeGraph);
+    const { nodes } = toReactFlowElements(laid);
+    for (const node of nodes) {
+      expect((node.data as CanvasTaskNodeData).kindString).not.toMatch(/^unknown_/);
+    }
+  });
+
   test("task nodes carry correct kindString and category", () => {
     const laid = applyDagreLayout(threeNodeGraph);
     const { nodes } = toReactFlowElements(laid);

package/src/workflow/__tests__/panelNegotiation.test.tsx

@@ -0,0 +1,230 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import { WorkflowExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/api_pb";
+import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/enum_pb";
+import type { DerivedCostSummary } from "../../internal/store/workflow-execution-event-store";
+import { useWorkflowExecution } from "../useWorkflowExecution";
+import { useWorkflowExecutionEventStream } from "../useWorkflowExecutionEventStream";
+import { useWorkflowExecutionArtifacts } from "../useWorkflowExecutionArtifacts";
+import { useWorkflowExecutionFileChanges } from "../useWorkflowExecutionFileChanges";
+import { useWorkflowExecutionActions } from "../useWorkflowExecutionActions";
+import { WorkflowExecutionViewer } from "../WorkflowExecutionViewer";
+
+// ---------------------------------------------------------------------------
+// Wiring-contract tests for the execution panel's host-negotiation surface
+// (issue #654): `panel="none"` omission, `defaultPanelOpen`, and the
+// controlled/observed `panelOpen` + `onPanelOpenChange` pair — the workflow
+// mirror of the session organisms' #651 contract (see the session
+// panelNegotiation suite). Workflow-specific beat: Diagnose gates on the
+// panel too, because its conversation renders inside the panel.
+//
+// Same probe/stub setup as the approvals suite: data hooks are stubbed to a
+// loaded, task-less execution; the graph and comparison picker are inert.
+// ---------------------------------------------------------------------------
+
+vi.mock("../useWorkflowExecution", () => ({
+  useWorkflowExecution: vi.fn(),
+}));
+vi.mock("../useWorkflowExecutionEventStream", () => ({
+  useWorkflowExecutionEventStream: vi.fn(),
+}));
+vi.mock("../useWorkflowExecutionArtifacts", () => ({
+  useWorkflowExecutionArtifacts: vi.fn(),
+}));
+vi.mock("../useWorkflowExecutionFileChanges", () => ({
+  useWorkflowExecutionFileChanges: vi.fn(),
+}));
+vi.mock("../useWorkflowExecutionActions", () => ({
+  useWorkflowExecutionActions: vi.fn(),
+}));
+vi.mock("../WorkflowExecutionGraph", () => ({
+  WorkflowExecutionGraph: () => <div data-testid="graph-stub" />,
+}));
+vi.mock("../execution-comparison/ExecutionComparisonPicker", () => ({
+  ExecutionComparisonPicker: () => null,
+}));
+
+const mockedUseWorkflowExecution = vi.mocked(useWorkflowExecution);
+const mockedUseEventStream = vi.mocked(useWorkflowExecutionEventStream);
+const mockedUseArtifacts = vi.mocked(useWorkflowExecutionArtifacts);
+const mockedUseFileChanges = vi.mocked(useWorkflowExecutionFileChanges);
+const mockedUseActions = vi.mocked(useWorkflowExecutionActions);
+
+const COST_SUMMARY: DerivedCostSummary = {
+  costConsumedMicros: 0n,
+  costRemainingMicros: -1n,
+  tokensConsumed: 0n,
+  tokensRemaining: -1n,
+  thresholdBreached: false,
+};
+
+function arrange(phase: ExecutionPhase = ExecutionPhase.EXECUTION_IN_PROGRESS) {
+  mockedUseWorkflowExecution.mockReturnValue({
+    execution: create(WorkflowExecutionSchema, {
+      metadata: { id: "wex_1", name: "nightly-report" },
+      spec: { workflowId: "wf_1" },
+      status: { phase, startedAt: "2026-07-15T00:00:00Z", tasks: [] },
+    }),
+    isLoading: false,
+    error: null,
+    refetch: vi.fn(),
+  } as unknown as ReturnType<typeof useWorkflowExecution>);
+  mockedUseEventStream.mockReturnValue({
+    events: [],
+    taskStates: new Map(),
+    costSummary: COST_SUMMARY,
+    streamState: { stage: "streaming" },
+    totalTasks: 0,
+    error: null,
+    reconnect: vi.fn(),
+  } as unknown as ReturnType<typeof useWorkflowExecutionEventStream>);
+  mockedUseArtifacts.mockReturnValue({
+    artifacts: [],
+  } as unknown as ReturnType<typeof useWorkflowExecutionArtifacts>);
+  mockedUseFileChanges.mockReturnValue({
+    fileChanges: [],
+    fileChangeCount: 0,
+    isLoading: false,
+    isRefetching: false,
+    error: null,
+    refetch: vi.fn(),
+  } as unknown as ReturnType<typeof useWorkflowExecutionFileChanges>);
+  mockedUseActions.mockReturnValue({
+    cancel: vi.fn(),
+    terminate: vi.fn(),
+    pause: vi.fn(),
+    resume: vi.fn(),
+    recover: vi.fn(),
+    submitApproval: vi.fn(),
+    submitTaskApproval: vi.fn(),
+    submitFileDecision: vi.fn(),
+    isSubmitting: false,
+    error: null,
+    clearError: vi.fn(),
+    approvalSubmittingToolCallIds: new Set<string>(),
+    approvalErrorsByToolCallId: new Map<string, Error>(),
+    taskApprovalSubmittingTaskNames: new Set<string>(),
+    taskApprovalErrorsByTaskName: new Map<string, Error>(),
+    fileDecisionSubmittingKeys: new Set<string>(),
+    fileDecisionErrorsByKey: new Map<string, Error>(),
+  } as unknown as ReturnType<typeof useWorkflowExecutionActions>);
+}
+
+function chipButton(): HTMLElement | null {
+  return (
+    screen.queryByRole("button", { name: "Show panel" }) ??
+    screen.queryByRole("button", { name: "Hide panel" })
+  );
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  localStorage.clear();
+});
+
+afterEach(cleanup);
+
+describe('WorkflowExecutionViewer — panel="none"', () => {
+  it("removes the chip and never renders the panel", () => {
+    arrange();
+    render(<WorkflowExecutionViewer executionId="wex_1" panel="none" />);
+    expect(chipButton()).toBeNull();
+  });
+
+  it("withholds Diagnose — its conversation renders inside the panel", () => {
+    arrange(ExecutionPhase.EXECUTION_FAILED);
+    render(
+      <WorkflowExecutionViewer executionId="wex_1" org="acme" panel="none" />,
+    );
+    expect(screen.queryByRole("button", { name: "Diagnose" })).toBeNull();
+    // The failed-state actions that live OUTSIDE the panel are untouched.
+    expect(screen.getByRole("button", { name: "Recover" })).toBeDefined();
+  });
+
+  it("keeps controlled props inert — panelOpen cannot force a surface that does not exist", () => {
+    arrange();
+    const onPanelOpenChange = vi.fn();
+    render(
+      <WorkflowExecutionViewer
+        executionId="wex_1"
+        panel="none"
+        panelOpen={true}
+        onPanelOpenChange={onPanelOpenChange}
+      />,
+    );
+    expect(chipButton()).toBeNull();
+    expect(onPanelOpenChange).not.toHaveBeenCalled();
+  });
+});
+
+describe("WorkflowExecutionViewer — Diagnose in the default panel mode", () => {
+  it("offers Diagnose on a failed execution (the contrast for the none-mode withholding)", () => {
+    arrange(ExecutionPhase.EXECUTION_FAILED);
+    render(<WorkflowExecutionViewer executionId="wex_1" org="acme" />);
+    expect(screen.getByRole("button", { name: "Diagnose" })).toBeDefined();
+  });
+});
+
+describe("WorkflowExecutionViewer — observed panel state (uncontrolled + onPanelOpenChange)", () => {
+  it("reports chip toggles without taking control", () => {
+    arrange();
+    const seen: boolean[] = [];
+    render(
+      <WorkflowExecutionViewer
+        executionId="wex_1"
+        onPanelOpenChange={(open) => seen.push(open)}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+    expect(seen).toEqual([true]);
+    fireEvent.click(screen.getByRole("button", { name: "Hide panel" }));
+    expect(seen).toEqual([true, false]);
+  });
+
+  it("starts open with defaultPanelOpen, without a spurious notification", () => {
+    arrange();
+    const onPanelOpenChange = vi.fn();
+    render(
+      <WorkflowExecutionViewer
+        executionId="wex_1"
+        defaultPanelOpen
+        onPanelOpenChange={onPanelOpenChange}
+      />,
+    );
+
+    expect(screen.getByRole("button", { name: "Hide panel" })).toBeDefined();
+    expect(onPanelOpenChange).not.toHaveBeenCalled();
+  });
+});
+
+describe("WorkflowExecutionViewer — controlled panel state", () => {
+  it("follows panelOpen and surfaces the chip's request without applying it", () => {
+    arrange();
+    const seen: boolean[] = [];
+    const onPanelOpenChange = (open: boolean) => seen.push(open);
+    const { rerender } = render(
+      <WorkflowExecutionViewer
+        executionId="wex_1"
+        panelOpen={false}
+        onPanelOpenChange={onPanelOpenChange}
+      />,
+    );
+
+    // The chip requests; the host owns the state — nothing moves yet.
+    fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+    expect(seen).toEqual([true]);
+    expect(screen.getByRole("button", { name: "Show panel" })).toBeDefined();
+
+    // The host grants the request: the panel opens and the chip flips.
+    rerender(
+      <WorkflowExecutionViewer
+        executionId="wex_1"
+        panelOpen={true}
+        onPanelOpenChange={onPanelOpenChange}
+      />,
+    );
+    expect(screen.getByRole("button", { name: "Hide panel" })).toBeDefined();
+  });
+});