@stigmer/react 2.0.1 → 3.0.1

package/src/index.ts

@@ -4,6 +4,9 @@ export { StigmerContext } from "./context";
 
 // Runner adapter
 export { type RunnerAdapter, useRunnerAdapter } from "./runner-adapter";
+// Construction helper lives in @stigmer/sdk (framework-agnostic); re-exported
+// here so React embedders import it alongside the adapter interface.
+export { type RunnerWorkerHost, createRunnerAdapter } from "@stigmer/sdk";
 
 // Fetch cache
 export { FetchCacheProvider } from "./internal/FetchCacheProvider";
@@ -193,6 +196,15 @@ export {
   formatTokenCount,
   ToolCallGroup,
   ToolCallDetail,
+  ResultView,
+  summarizeResultView,
+  useToolPresentation,
+  registerToolPresenter,
+  getToolPresenter,
+  resolveToolCategory,
+  resolveToolCategoryFromCall,
+  resolveToolCategoryFromKind,
+  toolKindToCategoryInfo,
   McpToolDetail,
   parseMcpResult,
   formatDuration,
@@ -252,6 +264,9 @@ export type {
   UseContextWindowReturn,
   ToolCallGroupProps,
   ToolCallDetailProps,
+  ResultViewProps,
+  ToolPresentation,
+  ToolPresenter,
   McpToolDetailProps,
   McpArgsViewProps,
   McpMetadataRowProps,
@@ -827,6 +842,8 @@ export {
   isSkillPackage,
   detectSkillPackage,
   useDetectSkillPackage,
+  isPlanArtifact,
+  findPlanArtifact,
   parseResourceYaml,
   serializeAgentYaml,
   serializeMcpServerYaml,
@@ -919,19 +936,33 @@ export type {
   DateRangePreset,
 } from "./usage";
 
-// Agent Instance — data hooks, list hook, personal convenience hook, and behavior hook
+// Agent Instance — data hooks, mutation hooks, management components, and behavior hook
 export {
   useAgentInstance,
   useAgentInstanceList,
+  useAgentInstances,
   usePersonalAgentInstance,
   useCreateAgentInstance,
+  useUpdateAgentInstance,
+  useDeleteAgentInstance,
+  AgentInstanceList,
+  AgentInstanceEmptyState,
+  CreateAgentInstanceDialog,
+  AgentInstanceDetailPanel,
 } from "./agent-instance";
 export type {
   UseAgentInstanceReturn,
   UseAgentInstanceListReturn,
+  UseAgentInstancesReturn,
   GetOrCreatePersonalInstanceInput,
   UsePersonalAgentInstanceReturn,
   UseCreateAgentInstanceReturn,
+  UseUpdateAgentInstanceReturn,
+  UseDeleteAgentInstanceReturn,
+  AgentInstanceListProps,
+  AgentInstanceEmptyStateProps,
+  CreateAgentInstanceDialogProps,
+  AgentInstanceDetailPanelProps,
 } from "./agent-instance";
 
 // Tabs — accessible tabbed panel primitive

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

@@ -0,0 +1,75 @@
+import { describe, it, expect } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import {
+  AgentExecutionSchema,
+  AgentExecutionStatusSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { ExecutionArtifactSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/artifact_pb";
+import { ExecutionArtifactKind } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import {
+  isPlanArtifact,
+  findPlanArtifact,
+  PLAN_ARTIFACT_NAME,
+} from "../detect-plan-artifact";
+
+function artifact(opts: { name: string; kind?: ExecutionArtifactKind; storageKey?: string }) {
+  return create(ExecutionArtifactSchema, {
+    name: opts.name,
+    kind: opts.kind ?? ExecutionArtifactKind.FILE,
+    storageKey: opts.storageKey ?? `artifacts/exec/${opts.name}`,
+  });
+}
+
+function executionWith(...artifacts: ReturnType<typeof artifact>[]) {
+  return create(AgentExecutionSchema, {
+    status: create(AgentExecutionStatusSchema, { artifacts }),
+  });
+}
+
+describe("isPlanArtifact", () => {
+  it("is true for a FILE artifact named plan.md", () => {
+    expect(isPlanArtifact(artifact({ name: PLAN_ARTIFACT_NAME }))).toBe(true);
+  });
+
+  it("is false for a directory named plan.md", () => {
+    expect(
+      isPlanArtifact(artifact({ name: "plan.md", kind: ExecutionArtifactKind.DIRECTORY })),
+    ).toBe(false);
+  });
+
+  it("is false for other file names", () => {
+    expect(isPlanArtifact(artifact({ name: "report.md" }))).toBe(false);
+    expect(isPlanArtifact(artifact({ name: "plan.txt" }))).toBe(false);
+  });
+});
+
+describe("findPlanArtifact", () => {
+  it("returns undefined for null/empty executions", () => {
+    expect(findPlanArtifact(null)).toBeUndefined();
+    expect(findPlanArtifact(undefined)).toBeUndefined();
+    expect(findPlanArtifact(executionWith())).toBeUndefined();
+  });
+
+  it("finds the plan.md among other artifacts", () => {
+    const exec = executionWith(
+      artifact({ name: "notes.txt" }),
+      artifact({ name: PLAN_ARTIFACT_NAME, storageKey: "artifacts/exec/plan.md" }),
+      artifact({ name: "data.json" }),
+    );
+    const plan = findPlanArtifact(exec);
+    expect(plan?.name).toBe(PLAN_ARTIFACT_NAME);
+    expect(plan?.storageKey).toBe("artifacts/exec/plan.md");
+  });
+
+  it("returns the latest plan.md when more than one is present", () => {
+    const exec = executionWith(
+      artifact({ name: PLAN_ARTIFACT_NAME, storageKey: "artifacts/exec/plan.md#old" }),
+      artifact({ name: PLAN_ARTIFACT_NAME, storageKey: "artifacts/exec/plan.md#new" }),
+    );
+    expect(findPlanArtifact(exec)?.storageKey).toBe("artifacts/exec/plan.md#new");
+  });
+
+  it("returns undefined when no plan artifact exists", () => {
+    expect(findPlanArtifact(executionWith(artifact({ name: "report.md" })))).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,43 @@
+import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import type { ExecutionArtifact } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/artifact_pb";
+import { ExecutionArtifactKind } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+/**
+ * Canonical filename a Plan-mode execution publishes its plan under. Kept in
+ * sync with the runner's `publishPlanArtifact` (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`.
+ *
+ * Detection is by convention — the same lightweight, content-free approach used
+ * for skill packages ({@link isSkillPackage}) — so the UI never needs an extra
+ * RPC to know a plan exists. The plan's text is fetched on demand via
+ * {@link useArtifactContent} only when the user expands the Plan card.
+ */
+export function isPlanArtifact(artifact: ExecutionArtifact): boolean {
+  return (
+    artifact.kind === ExecutionArtifactKind.FILE &&
+    artifact.name === PLAN_ARTIFACT_NAME
+  );
+}
+
+/**
+ * Finds the plan artifact on a completed execution, or `undefined` when none
+ * was published (older executions, or a plan that failed to upload).
+ *
+ * Returns the latest `plan.md` if more than one is present — the runner
+ * replaces rather than appends, so this is defensive.
+ */
+export function findPlanArtifact(
+  execution: AgentExecution | null | undefined,
+): ExecutionArtifact | undefined {
+  const artifacts = execution?.status?.artifacts;
+  if (!artifacts || artifacts.length === 0) return undefined;
+  for (let i = artifacts.length - 1; i >= 0; i--) {
+    if (isPlanArtifact(artifacts[i])) return artifacts[i];
+  }
+  return undefined;
+}

package/src/library/index.ts

@@ -24,6 +24,12 @@ export {
 } from "./detect-skill-package";
 export type { SkillPackageDetection } from "./detect-skill-package";
 
+export {
+  isPlanArtifact,
+  findPlanArtifact,
+  PLAN_ARTIFACT_NAME,
+} from "./detect-plan-artifact";
+
 export { useDetectSkillPackage } from "./useDetectSkillPackage";
 export type { UseDetectSkillPackageReturn } from "./useDetectSkillPackage";
 

package/src/provider.tsx

@@ -56,9 +56,11 @@ export interface StigmerProviderProps {
   /**
    * Runner adapter for local execution lifecycle management.
    *
-   * When `executionTarget` is `"local"`, SDK hooks automatically call
-   * the adapter after session/execution creation and on terminal phase
-   * detection. Cloud consumers omit this prop entirely.
+   * When `executionTarget` is `"local"`, SDK hooks automatically drive
+   * the adapter at the right lifecycle points: sessions on open/close
+   * (the session view attaches a worker while open and detaches on close)
+   * and workflow executions on create/terminal. Cloud consumers omit this
+   * prop entirely.
    *
    * Desktop apps provide a Tauri-based adapter; self-hosted customers
    * provide their own implementation of the {@link RunnerAdapter}

package/src/runner-adapter.ts

@@ -10,6 +10,13 @@ import { createContext, useContext } from "react";
  * the adapter at the appropriate lifecycle points. The consumer never
  * needs to know about runner management — it is handled transparently.
  *
+ * Sessions and workflow executions have different lifecycles. A session is
+ * a long-lived, multi-turn conversation with no terminal phase, so its
+ * worker is tied to whether the session is open (in use): `onSessionOpened`
+ * when the session viewer opens it, `onSessionClosed` when it closes. A
+ * workflow execution runs to a terminal phase, so its worker is tied to
+ * creation and completion.
+ *
  * Each environment provides its own implementation:
  * - Desktop app: wraps the embedded Tauri runner process
  * - CLI: wraps the daemon runner
@@ -17,10 +24,18 @@ import { createContext, useContext } from "react";
  * - Cloud: no adapter needed (server handles provisioning)
  */
 export interface RunnerAdapter {
-  /** Called by SDK hooks after a session is created with executionTarget=LOCAL. */
-  onSessionCreated(sessionId: string): Promise<void>;
-  /** Called by SDK hooks when a session reaches a terminal phase. */
-  onSessionTerminated(sessionId: string): Promise<void>;
+  /**
+   * Called by SDK hooks when a local session is opened (engaged). The
+   * adapter should ensure a runner worker is polling the session's task
+   * queue. Idempotent: may be called again for an already-open session
+   * (e.g. when the same session is re-opened).
+   */
+  onSessionOpened(sessionId: string): Promise<void>;
+  /**
+   * Called by SDK hooks when a local session is closed (no longer in use).
+   * The adapter should tear down the session's runner worker.
+   */
+  onSessionClosed(sessionId: string): Promise<void>;
   /** Called by SDK hooks after a workflow execution is created with executionTarget=LOCAL. */
   onWorkflowExecutionCreated(executionId: string): Promise<void>;
   /** Called by SDK hooks when a workflow execution reaches a terminal phase. */

package/src/session/NewSessionViewer.tsx

@@ -46,6 +46,15 @@ export interface NewSessionViewerProps {
 
   /** Agent to auto-select on mount (used for draft flows). */
   readonly initialAgentRef?: ResourceRef;
+  /**
+   * Pre-bind the new session to a specific `AgentInstance` on mount.
+   *
+   * Requires `initialAgentRef`. When both are set, the session is created
+   * against this exact configured deployment (the env-collection flow is
+   * skipped because the instance already binds its environment). Powers the
+   * "Start session" action on the Agent detail page's Instances tab.
+   */
+  readonly initialInstanceId?: string;
   /** Files to auto-attach on mount (used for edit flows). */
   readonly initialAttachments?: File[];
 
@@ -114,6 +123,7 @@ export function NewSessionViewer({
   onBrowseLocalFolder,
   workspaceFileLister,
   initialAgentRef,
+  initialInstanceId,
   initialAttachments,
   heading = "What would you like to work on?",
   placeholder = "Describe what you need help with\u2026",
@@ -219,6 +229,7 @@ export function NewSessionViewer({
           onAgentRefChange={flow.setAgentRef}
           onAgentResolutionChange={flow.setResolution}
           initialAgentRef={initialAgentRef}
+          initialInstanceId={initialInstanceId}
           initialAttachments={initialAttachments}
           mcpServerUsages={flow.mcpServerUsages}
           onMcpServerUsagesChange={flow.setMcpServerUsages}

package/src/session/SessionViewer.tsx

@@ -137,7 +137,12 @@ export function SessionViewer({
 
   const handleBuildFromPlan = useCallback(() => {
     setInteractionMode("agent");
-    composerRef.current?.setMessage("Implement the plan above");
+    // Reference the plan explicitly (it is also published as plan.md) and direct
+    // the agent to act on it, rather than a bare "implement" that relies on the
+    // model re-reading its own prior message.
+    composerRef.current?.setMessage(
+      "Implement the plan above (saved as plan.md). Follow it step by step and make the changes it describes.",
+    );
     composerRef.current?.focus();
   }, []);
 
@@ -251,7 +256,7 @@ function ConversationColumn({
         executions={conv.completedExecutions}
         activeStreamExecution={conv.activeStreamExecution}
         pendingUserMessage={conv.pendingUserMessage}
-        onApprovalSubmit={conv.submitApproval}
+        onApprovalSubmit={flow.submitApproval}
         submittingApprovalIds={conv.submittingApprovalIds}
         workspaceEntries={conv.workspaceEntries}
         sandboxWorkspaceRoot={flow.sandboxWorkspaceRoot}
@@ -269,6 +274,9 @@ function ConversationColumn({
         {(conv.sendError || conv.approvalError) && (
           <SendErrorBanner error={(conv.sendError ?? conv.approvalError)!} />
         )}
+        {flow.autoApproveAll && (
+          <AutoApproveIndicator onTurnOff={() => flow.setAutoApproveAll(false)} />
+        )}
         <SessionComposer
           ref={composerRef}
           onSubmit={flow.handleSubmit}
@@ -449,6 +457,33 @@ function SessionStarting() {
   );
 }
 
+/**
+ * Low-weight, always-visible indicator shown while the session-scoped
+ * auto-approve preference is active. The "Turn off" control reverts the
+ * preference in one click — the safety affordance for "Approve & don't ask
+ * again". Nothing about approvals appears until the user opts in at a gate.
+ */
+function AutoApproveIndicator({ onTurnOff }: { onTurnOff: () => void }) {
+  return (
+    <div
+      role="status"
+      className="flex items-center gap-2 border-t border-border-muted px-4 py-1.5 text-xs text-muted-foreground"
+    >
+      <ShieldCheckIcon />
+      <span className="min-w-0 flex-1 truncate">
+        Auto-approving tool calls for this session
+      </span>
+      <button
+        type="button"
+        onClick={onTurnOff}
+        className="shrink-0 rounded font-medium text-foreground underline-offset-2 hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+      >
+        Turn off
+      </button>
+    </div>
+  );
+}
+
 function SendErrorBanner({ error }: { error: Error }) {
   if (isSecretFlowError(error)) {
     return <SecretFlowErrorGuide error={error} className="mx-4 my-2" />;
@@ -504,3 +539,12 @@ function LoaderIcon() {
     </svg>
   );
 }
+
+function ShieldCheckIcon() {
+  return (
+    <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className="shrink-0 text-success" aria-hidden="true">
+      <path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z" />
+      <path d="m9 12 2 2 4-4" />
+    </svg>
+  );
+}

package/src/session/__tests__/group-sessions.test.ts

@@ -1,11 +1,9 @@
 import { describe, it, expect } from "vitest";
 import { create } from "@bufbuild/protobuf";
 import { timestampFromDate } from "@bufbuild/protobuf/wkt";
+import { SessionSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
 import {
-  SessionSchema,
-  SessionStatusSchema,
-} from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
-import {
+  ApiResourceAuditStatusSchema,
   ApiResourceAuditSchema,
   ApiResourceAuditInfoSchema,
 } from "@stigmer/protos/ai/stigmer/commons/apiresource/status_pb";
@@ -20,7 +18,7 @@ function makeSession(date: Date | null) {
     auditInfo.createdAt = timestampFromDate(date);
     const audit = create(ApiResourceAuditSchema);
     audit.specAudit = auditInfo;
-    const status = create(SessionStatusSchema);
+    const status = create(ApiResourceAuditStatusSchema);
     status.audit = audit;
     session.status = status;
   }

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

@@ -0,0 +1,194 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook } from "@testing-library/react";
+import type { ReactNode } from "react";
+import type { Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
+import { ExecutionTarget } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
+import { ExecutionTargetContext } from "../../execution-target-context";
+import { RunnerAdapterContext } from "../../runner-adapter";
+import type { RunnerAdapter } from "../../runner-adapter";
+import { useLocalSessionWorker } from "../useLocalSessionWorker";
+
+function createMockAdapter(): RunnerAdapter & {
+  onSessionOpened: ReturnType<typeof vi.fn>;
+  onSessionClosed: ReturnType<typeof vi.fn>;
+  onWorkflowExecutionCreated: ReturnType<typeof vi.fn>;
+  onWorkflowExecutionTerminated: ReturnType<typeof vi.fn>;
+} {
+  return {
+    onSessionOpened: vi.fn().mockResolvedValue(undefined),
+    onSessionClosed: vi.fn().mockResolvedValue(undefined),
+    onWorkflowExecutionCreated: vi.fn().mockResolvedValue(undefined),
+    onWorkflowExecutionTerminated: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+/** Build a minimal Session with a given execution target. */
+function makeSession(target: ExecutionTarget): Session {
+  return { spec: { executionTarget: target } } as Session;
+}
+
+function wrapper(
+  adapter: RunnerAdapter | null,
+  contextTarget?: "local" | "cloud",
+) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <ExecutionTargetContext.Provider value={contextTarget}>
+        <RunnerAdapterContext.Provider value={adapter}>
+          {children}
+        </RunnerAdapterContext.Provider>
+      </ExecutionTargetContext.Provider>
+    );
+  };
+}
+
+describe("useLocalSessionWorker", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("attaches the worker on mount for a loaded local session", () => {
+    const adapter = createMockAdapter();
+    renderHook(
+      () => useLocalSessionWorker("ses-1", makeSession(ExecutionTarget.LOCAL)),
+      { wrapper: wrapper(adapter, "local") },
+    );
+
+    expect(adapter.onSessionOpened).toHaveBeenCalledTimes(1);
+    expect(adapter.onSessionOpened).toHaveBeenCalledWith("ses-1");
+    expect(adapter.onSessionClosed).not.toHaveBeenCalled();
+  });
+
+  it("detaches the worker on unmount", () => {
+    const adapter = createMockAdapter();
+    const { unmount } = renderHook(
+      () => useLocalSessionWorker("ses-1", makeSession(ExecutionTarget.LOCAL)),
+      { wrapper: wrapper(adapter, "local") },
+    );
+
+    unmount();
+
+    expect(adapter.onSessionClosed).toHaveBeenCalledTimes(1);
+    expect(adapter.onSessionClosed).toHaveBeenCalledWith("ses-1");
+  });
+
+  it("is a no-op when no adapter is configured", () => {
+    // No adapter → nothing to assert beyond "does not throw".
+    expect(() =>
+      renderHook(
+        () => useLocalSessionWorker("ses-1", makeSession(ExecutionTarget.LOCAL)),
+        { wrapper: wrapper(null, "local") },
+      ),
+    ).not.toThrow();
+  });
+
+  it("does not attach for a cloud session", () => {
+    const adapter = createMockAdapter();
+    renderHook(
+      () => useLocalSessionWorker("ses-1", makeSession(ExecutionTarget.CLOUD)),
+      { wrapper: wrapper(adapter, "local") },
+    );
+
+    expect(adapter.onSessionOpened).not.toHaveBeenCalled();
+  });
+
+  it("does not attach until the session has loaded", () => {
+    const adapter = createMockAdapter();
+    const { rerender } = renderHook(
+      ({ session }: { session: Session | null }) =>
+        useLocalSessionWorker("ses-1", session),
+      {
+        wrapper: wrapper(adapter, "local"),
+        initialProps: { session: null } as { session: Session | null },
+      },
+    );
+
+    // Loading: target unknown → no attach yet.
+    expect(adapter.onSessionOpened).not.toHaveBeenCalled();
+
+    // Loaded as local → attaches now.
+    rerender({ session: makeSession(ExecutionTarget.LOCAL) });
+    expect(adapter.onSessionOpened).toHaveBeenCalledTimes(1);
+  });
+
+  it("falls back to the provider target when the session spec is unspecified", () => {
+    const adapter = createMockAdapter();
+    renderHook(
+      () =>
+        useLocalSessionWorker(
+          "ses-1",
+          makeSession(ExecutionTarget.UNSPECIFIED),
+        ),
+      { wrapper: wrapper(adapter, "local") },
+    );
+
+    expect(adapter.onSessionOpened).toHaveBeenCalledWith("ses-1");
+  });
+
+  it("does not attach when spec is unspecified and provider target is not local", () => {
+    const adapter = createMockAdapter();
+    renderHook(
+      () =>
+        useLocalSessionWorker(
+          "ses-1",
+          makeSession(ExecutionTarget.UNSPECIFIED),
+        ),
+      { wrapper: wrapper(adapter, "cloud") },
+    );
+
+    expect(adapter.onSessionOpened).not.toHaveBeenCalled();
+  });
+
+  it("detaches the old session and attaches the new one on sessionId change", () => {
+    const adapter = createMockAdapter();
+    const { rerender } = renderHook(
+      ({ sessionId }: { sessionId: string }) =>
+        useLocalSessionWorker(sessionId, makeSession(ExecutionTarget.LOCAL)),
+      { wrapper: wrapper(adapter, "local"), initialProps: { sessionId: "ses-1" } },
+    );
+
+    expect(adapter.onSessionOpened).toHaveBeenCalledWith("ses-1");
+
+    rerender({ sessionId: "ses-2" });
+
+    expect(adapter.onSessionClosed).toHaveBeenCalledWith("ses-1");
+    expect(adapter.onSessionOpened).toHaveBeenCalledWith("ses-2");
+  });
+
+  // DD-010 regression guard: useSessionConversation refetches the session
+  // constantly. A refetch that returns a new object with the same execution
+  // target must NOT thrash the runner (no extra open/close).
+  it("does not re-attach when a refetch returns a new session object with the same target", () => {
+    const adapter = createMockAdapter();
+    const { rerender } = renderHook(
+      ({ session }: { session: Session }) =>
+        useLocalSessionWorker("ses-1", session),
+      {
+        wrapper: wrapper(adapter, "local"),
+        initialProps: { session: makeSession(ExecutionTarget.LOCAL) },
+      },
+    );
+
+    expect(adapter.onSessionOpened).toHaveBeenCalledTimes(1);
+
+    // Simulate three refetches returning fresh objects with identical target.
+    rerender({ session: makeSession(ExecutionTarget.LOCAL) });
+    rerender({ session: makeSession(ExecutionTarget.LOCAL) });
+    rerender({ session: makeSession(ExecutionTarget.LOCAL) });
+
+    expect(adapter.onSessionOpened).toHaveBeenCalledTimes(1);
+    expect(adapter.onSessionClosed).not.toHaveBeenCalled();
+  });
+
+  it("swallows adapter errors so the session view never crashes", () => {
+    const adapter = createMockAdapter();
+    adapter.onSessionOpened.mockRejectedValue(new Error("runner down"));
+
+    expect(() =>
+      renderHook(
+        () => useLocalSessionWorker("ses-1", makeSession(ExecutionTarget.LOCAL)),
+        { wrapper: wrapper(adapter, "local") },
+      ),
+    ).not.toThrow();
+  });
+});