@stigmer/react 2.0.1 → 3.0.1

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

@@ -5,6 +5,8 @@ import { DEFAULT_MODEL_ID, DEFAULT_CURSOR_MODEL_ID, parseRegistryJson } from "..
 import { ModelRegistryContext } from "../../models/ModelRegistryContext";
 import type { ModelRegistryState } from "../../models/ModelRegistryContext";
 import { ExecutionTargetContext } from "../../execution-target-context";
+import { RunnerAdapterContext } from "../../runner-adapter";
+import type { RunnerAdapter } from "../../runner-adapter";
 import type { UseCreateSessionReturn } from "../useCreateSession";
 
 const mockCreateSession = vi.fn<UseCreateSessionReturn["create"]>();
@@ -72,19 +74,38 @@ const TEST_MODELS = parseRegistryJson({
   ],
 });
 
-function createWrapper(executionTarget?: "local" | "cloud") {
+function createWrapper(
+  executionTarget?: "local" | "cloud",
+  adapter: RunnerAdapter | null = null,
+) {
   const state: ModelRegistryState = { models: TEST_MODELS, isLoading: false, error: null, refetch: () => {} };
   return function Wrapper({ children }: { children: ReactNode }) {
     return (
       <ExecutionTargetContext.Provider value={executionTarget}>
-        <ModelRegistryContext.Provider value={state}>
-          {children}
-        </ModelRegistryContext.Provider>
+        <RunnerAdapterContext.Provider value={adapter}>
+          <ModelRegistryContext.Provider value={state}>
+            {children}
+          </ModelRegistryContext.Provider>
+        </RunnerAdapterContext.Provider>
       </ExecutionTargetContext.Provider>
     );
   };
 }
 
+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),
+  };
+}
+
 const STORAGE_KEY_HARNESS = "stigmer:session:harness";
 const STORAGE_KEY_MODEL_NATIVE = "stigmer:session:model";
 const STORAGE_KEY_MODEL_CURSOR = "stigmer:session:model:cursor";
@@ -392,6 +413,61 @@ describe("useNewSessionFlow", () => {
     });
   });
 
+  describe("submit — local runner worker (eager attach)", () => {
+    it("attaches the worker before creating the first execution", async () => {
+      const adapter = createMockAdapter();
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), {
+        wrapper: createWrapper("local", adapter),
+      });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(adapter.onSessionOpened).toHaveBeenCalledTimes(1);
+      expect(adapter.onSessionOpened).toHaveBeenCalledWith("sess-new");
+      expect(adapter.onSessionClosed).not.toHaveBeenCalled();
+
+      // The worker must be polling before the first execution exists.
+      const openedOrder = adapter.onSessionOpened.mock.invocationCallOrder[0];
+      const execOrder = mockCreateExecution.mock.invocationCallOrder[0];
+      expect(openedOrder).toBeLessThan(execOrder);
+    });
+
+    it("does not attach a worker when the target is cloud", async () => {
+      const adapter = createMockAdapter();
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), {
+        wrapper: createWrapper("cloud", adapter),
+      });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(adapter.onSessionOpened).not.toHaveBeenCalled();
+    });
+
+    it("detaches the worker when the first execution fails (no leak)", async () => {
+      const adapter = createMockAdapter();
+      mockCreateExecution.mockRejectedValueOnce(new Error("execution boom"));
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), {
+        wrapper: createWrapper("local", adapter),
+      });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(adapter.onSessionOpened).toHaveBeenCalledWith("sess-new");
+      expect(adapter.onSessionClosed).toHaveBeenCalledWith("sess-new");
+      expect(result.current.submitError).not.toBeNull();
+      expect(opts.onError).toHaveBeenCalled();
+    });
+  });
+
   describe("submit while default agent is loading", () => {
     it("awaits default agent and creates session when fetch resolves", async () => {
       const resolvedAgent = { status: { defaultInstanceId: "awaited-inst" } };

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

@@ -12,6 +12,9 @@ import { SessionSchema, type Session } from "@stigmer/protos/ai/stigmer/agentic/
 import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
 import type { Stigmer } from "@stigmer/sdk";
 import { StigmerContext } from "../../context";
+import { ExecutionTargetContext } from "../../execution-target-context";
+import { RunnerAdapterContext } from "../../runner-adapter";
+import type { RunnerAdapter } from "../../runner-adapter";
 import { useSessionConversation } from "../useSessionConversation";
 
 function makeSession(id: string): Session {
@@ -356,3 +359,89 @@ describe("useSessionConversation", () => {
     );
   });
 });
+
+describe("useSessionConversation — local runner worker lifecycle", () => {
+  let methods: MockMethods;
+  let mockStigmer: Stigmer;
+  let stream: ReturnType<typeof createControllableStream<AgentExecution>>;
+
+  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),
+    };
+  }
+
+  function localWrapper(client: Stigmer, adapter: RunnerAdapter) {
+    return function Wrapper({ children }: { children: ReactNode }) {
+      return (
+        <ExecutionTargetContext.Provider value="local">
+          <RunnerAdapterContext.Provider value={adapter}>
+            <StigmerContext.Provider value={client}>
+              {children}
+            </StigmerContext.Provider>
+          </RunnerAdapterContext.Provider>
+        </ExecutionTargetContext.Provider>
+      );
+    };
+  }
+
+  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("attaches the worker once when a local session opens and detaches on close", async () => {
+    const adapter = createMockAdapter();
+    const { unmount } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: localWrapper(mockStigmer, adapter) },
+    );
+
+    // The session loads asynchronously; the worker attaches once loaded.
+    await waitFor(() => {
+      expect(adapter.onSessionOpened).toHaveBeenCalledWith("session-1");
+    });
+    expect(adapter.onSessionOpened).toHaveBeenCalledTimes(1);
+    expect(adapter.onSessionClosed).not.toHaveBeenCalled();
+
+    unmount();
+
+    expect(adapter.onSessionClosed).toHaveBeenCalledTimes(1);
+    expect(adapter.onSessionClosed).toHaveBeenCalledWith("session-1");
+  });
+
+  it("does not attach when no adapter is configured", async () => {
+    // No adapter in the tree → no-op. Just verify the conversation still loads.
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      {
+        wrapper: function Wrapper({ children }: { children: ReactNode }) {
+          return (
+            <StigmerContext.Provider value={mockStigmer}>
+              {children}
+            </StigmerContext.Provider>
+          );
+        },
+      },
+    );
+
+    await waitFor(() => {
+      expect(result.current.session).not.toBeNull();
+    });
+  });
+});

package/src/session/__tests__/useSessionPageFlow.autoApprove.test.tsx

@@ -0,0 +1,149 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+// ---------------------------------------------------------------------------
+// Mocks — useSessionPageFlow composes many hooks; we stub them to isolate the
+// session-scoped auto-approve behavior (gate sets it, follow-ups carry it,
+// "Turn off" reverts it).
+// ---------------------------------------------------------------------------
+
+const mockSubmitApproval = vi.fn<(t: string, a: ApprovalAction, c?: string) => Promise<void>>();
+const mockSendFollowUp = vi.fn();
+
+const mockConv = {
+  session: { spec: {} },
+  isLoading: false,
+  completedExecutions: [] as unknown[],
+  activeStreamExecution: null,
+  workspaceEntries: [] as unknown[],
+  submitApproval: mockSubmitApproval,
+  sendFollowUp: mockSendFollowUp,
+};
+vi.mock("../useSessionConversation", () => ({
+  useSessionConversation: () => mockConv,
+}));
+
+vi.mock("../../hooks", () => ({
+  useStigmer: () => ({ agent: { getByReference: vi.fn() } }),
+}));
+
+vi.mock("../../agent", () => ({
+  useDefaultAgent: () => ({ agent: null, isLoading: false, error: null }),
+}));
+
+const mockWorkspace = {
+  entries: [],
+  hasEntries: false,
+  toInput: vi.fn().mockReturnValue([]),
+  addGitRepo: vi.fn(),
+  addLocalPath: vi.fn(),
+  removeEntry: vi.fn(),
+  clear: vi.fn(),
+};
+vi.mock("../../workspace", () => ({
+  useWorkspaceEntries: () => mockWorkspace,
+}));
+
+const mockSessionVariables = {
+  variables: [],
+  isEmpty: true,
+  clear: vi.fn(),
+};
+vi.mock("../../execution/useSessionVariables", () => ({
+  useSessionVariables: () => mockSessionVariables,
+}));
+
+vi.mock("../usePersistedModel", () => ({
+  usePersistedModel: () => ["model-x", vi.fn()] as const,
+}));
+
+vi.mock("../useAgentRefFromSession", () => ({
+  useAgentRefFromSession: () => ({ agentRef: null }),
+}));
+
+import { useSessionPageFlow } from "../useSessionPageFlow";
+
+const OPTS = { sessionId: "ses_1", org: "acme" };
+
+describe("useSessionPageFlow — gate-driven auto-approve", () => {
+  beforeEach(() => {
+    mockSubmitApproval.mockResolvedValue(undefined);
+  });
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("defaults autoApproveAll to false", () => {
+    const { result } = renderHook(() => useSessionPageFlow(OPTS));
+    expect(result.current.autoApproveAll).toBe(false);
+  });
+
+  it("flips autoApproveAll when the gate decision is APPROVE_ALL", async () => {
+    const { result } = renderHook(() => useSessionPageFlow(OPTS));
+
+    await act(async () => {
+      await result.current.submitApproval("tc1", ApprovalAction.APPROVE_ALL);
+    });
+
+    expect(result.current.autoApproveAll).toBe(true);
+    // Still delegates to the underlying conversation submit.
+    expect(mockSubmitApproval).toHaveBeenCalledWith("tc1", ApprovalAction.APPROVE_ALL, undefined);
+  });
+
+  it("does NOT flip autoApproveAll for a plain APPROVE", async () => {
+    const { result } = renderHook(() => useSessionPageFlow(OPTS));
+
+    await act(async () => {
+      await result.current.submitApproval("tc1", ApprovalAction.APPROVE);
+    });
+
+    expect(result.current.autoApproveAll).toBe(false);
+  });
+
+  it("carries autoApproveAll into follow-up submissions once enabled", async () => {
+    const { result } = renderHook(() => useSessionPageFlow(OPTS));
+
+    await act(async () => {
+      await result.current.submitApproval("tc1", ApprovalAction.APPROVE_ALL);
+    });
+    await act(async () => {
+      await result.current.handleSubmit("next message");
+    });
+
+    expect(mockSendFollowUp).toHaveBeenCalledTimes(1);
+    const followUpOpts = mockSendFollowUp.mock.calls[0][1];
+    expect(followUpOpts.autoApproveAll).toBe(true);
+  });
+
+  it("does not carry autoApproveAll before any APPROVE_ALL decision", async () => {
+    const { result } = renderHook(() => useSessionPageFlow(OPTS));
+
+    await act(async () => {
+      await result.current.handleSubmit("first message");
+    });
+
+    const followUpOpts = mockSendFollowUp.mock.calls[0][1];
+    expect(followUpOpts.autoApproveAll).toBeUndefined();
+  });
+
+  it("reverts via setAutoApproveAll(false) so follow-ups stop carrying it", async () => {
+    const { result } = renderHook(() => useSessionPageFlow(OPTS));
+
+    await act(async () => {
+      await result.current.submitApproval("tc1", ApprovalAction.APPROVE_ALL);
+    });
+    expect(result.current.autoApproveAll).toBe(true);
+
+    act(() => {
+      result.current.setAutoApproveAll(false);
+    });
+    expect(result.current.autoApproveAll).toBe(false);
+
+    await act(async () => {
+      await result.current.handleSubmit("after turn off");
+    });
+    const followUpOpts = mockSendFollowUp.mock.calls.at(-1)?.[1];
+    expect(followUpOpts.autoApproveAll).toBeUndefined();
+  });
+});

package/src/session/useCreateSession.ts

@@ -12,7 +12,6 @@ import { toError } from "../internal/toError";
 import { toProtoHarness, type HarnessOption } from "../models/harness";
 import { toProtoExecutionTarget, type ExecutionTargetOption } from "./execution-target";
 import { useExecutionTarget } from "../execution-target-context";
-import { useRunnerAdapter } from "../runner-adapter";
 
 /** Shared fields present in both variants of {@link CreateSessionInput}. */
 export interface SharedSessionFields {
@@ -130,7 +129,6 @@ export interface UseCreateSessionReturn {
 export function useCreateSession(): UseCreateSessionReturn {
   const stigmer = useStigmer();
   const contextTarget = useExecutionTarget();
-  const adapter = useRunnerAdapter();
   const [isCreating, setIsCreating] = useState(false);
   const [error, setError] = useState<Error | null>(null);
 
@@ -183,10 +181,9 @@ export function useCreateSession(): UseCreateSessionReturn {
 
         const sessionId = session.metadata!.id;
 
-        if (adapter && resolvedTarget === "local") {
-          await adapter.onSessionCreated(sessionId);
-        }
-
+        // Worker lifecycle is owned by the session view (useSessionConversation
+        // attaches on open / detaches on close). The new-session flow attaches
+        // eagerly for the first execution; creation alone needs no worker.
         return { sessionId };
       } catch (err) {
         setError(toError(err));
@@ -195,7 +192,7 @@ export function useCreateSession(): UseCreateSessionReturn {
         setIsCreating(false);
       }
     },
-    [stigmer, contextTarget, adapter],
+    [stigmer, contextTarget],
   );
 
   return { create, isCreating, error, clearError };

package/src/session/useLocalSessionWorker.ts

@@ -0,0 +1,73 @@
+"use client";
+
+import { useEffect, useMemo } 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 { useRunnerAdapter } from "../runner-adapter";
+import { useExecutionTarget } from "../execution-target-context";
+import { fromProtoExecutionTarget } from "./execution-target";
+
+/**
+ * Drives the local runner worker lifecycle for an open session.
+ *
+ * A `Session` is a long-lived, multi-turn conversation with **no terminal
+ * phase** — its runner worker must keep polling the session task queue for as
+ * long as the session is open, because `sendFollowUp` creates new executions
+ * without re-attaching a worker. The lifecycle is therefore
+ * **attach-on-open / detach-on-close**: attach when the session is opened
+ * (this hook mounts with a loaded, local session and an adapter present),
+ * detach when it is closed (unmount or `sessionId` change). This also closes
+ * the "re-opening an existing session leaves its task queue without a poller"
+ * gap that previously made follow-ups silently hang.
+ *
+ * Wired once from {@link useSessionConversation} so every consumer — web,
+ * desktop, Ink/terminal, and custom headless hosts — gets the behavior for
+ * free. It is a no-op unless a `runnerAdapter` is configured **and** the
+ * session resolves to local execution (cloud sessions are server-provisioned).
+ *
+ * The effect depends only on stable primitives (`adapter`, `sessionId`, and
+ * the derived `effectiveTarget` string) and **never on the `session` object**.
+ * `useSessionConversation` refetches the session frequently; keying the effect
+ * on the object would tear down and restart the worker on every refetch
+ * (DD-010 / reference-stability). `executionTarget` is immutable after the
+ * first execution, so the derived string stays stable across refetches.
+ *
+ * @param sessionId - The session being viewed, or `null` to skip.
+ * @param session - The loaded session, or `null` while loading. The worker is
+ *   not attached until the session loads, so the decision uses the session's
+ *   own (authoritative) execution target rather than the provider default.
+ */
+export function useLocalSessionWorker(
+  sessionId: string | null,
+  session: Session | null,
+): void {
+  const adapter = useRunnerAdapter();
+  const contextTarget = useExecutionTarget();
+
+  // Resolve the session's effective execution target as a stable primitive.
+  // `undefined` until the session loads — so we never attach a local worker
+  // before we know whether the session actually runs locally (which would
+  // spuriously start a worker for a cloud session opened in a local-default
+  // app). When the spec is UNSPECIFIED, fall back to the provider target.
+  const isLoaded = session != null;
+  const specTarget = session?.spec?.executionTarget;
+  const effectiveTarget = useMemo(() => {
+    if (!isLoaded) return undefined;
+    return (
+      fromProtoExecutionTarget(specTarget ?? ExecutionTarget.UNSPECIFIED) ??
+      contextTarget
+    );
+  }, [isLoaded, specTarget, contextTarget]);
+
+  useEffect(() => {
+    if (!adapter || !sessionId || effectiveTarget !== "local") return;
+
+    // Fire-and-forget: a runner-start failure must not crash the session view.
+    // The host adapter's add/remove are idempotent, so React's cleanup-driven
+    // detach-old/attach-new on `sessionId` change is safe.
+    adapter.onSessionOpened(sessionId).catch(() => {});
+    return () => {
+      adapter.onSessionClosed(sessionId).catch(() => {});
+    };
+  }, [adapter, sessionId, effectiveTarget]);
+}

package/src/session/useNewSessionFlow.ts

@@ -15,6 +15,7 @@ import { useCreateSession } from "./useCreateSession";
 import { useCreateAgentExecution } from "../execution/useCreateAgentExecution";
 import type { ExecutionTargetOption } from "./execution-target";
 import { useExecutionTarget } from "../execution-target-context";
+import { useRunnerAdapter } from "../runner-adapter";
 
 const DEFAULT_AGENT_TIMEOUT_MS = 10_000;
 
@@ -160,6 +161,7 @@ export function useNewSessionFlow(
   const { org, onSessionCreated, onError } = options;
   const contextTarget = useExecutionTarget();
   const executionTarget = options.executionTarget ?? contextTarget;
+  const adapter = useRunnerAdapter();
 
   const [harness, setHarnessRaw] = useState<HarnessOption>(() => {
     if (typeof window === "undefined") return DEFAULT_HARNESS;
@@ -306,7 +308,26 @@ export function useNewSessionFlow(
           }));
         }
 
-        await createExecution({ ...executionFields, sessionId });
+        // Local execution: attach the session's runner worker before creating
+        // the first execution. The session view (useSessionConversation) owns
+        // the steady-state lifecycle, but it is not mounted yet — navigation
+        // happens after onSessionCreated below — so without this eager attach
+        // the first execution would have no poller until the view mounts.
+        if (adapter && executionTarget === "local") {
+          await adapter.onSessionOpened(sessionId);
+        }
+
+        try {
+          await createExecution({ ...executionFields, sessionId });
+        } catch (err) {
+          // The first execution failed and the session view will not mount,
+          // so detach the worker we just attached to avoid leaking it.
+          if (adapter && executionTarget === "local") {
+            adapter.onSessionClosed(sessionId).catch(() => {});
+          }
+          throw err;
+        }
+
         sessionVariables.clear();
         onSessionCreated(sessionId);
       } catch (err) {
@@ -322,6 +343,7 @@ export function useNewSessionFlow(
       org,
       harness,
       executionTarget,
+      adapter,
       validModelId,
       workspace,
       mcpServerUsages,

package/src/session/useSessionConversation.ts

@@ -24,6 +24,7 @@ import { useSubmitApproval } from "../execution/useSubmitApproval";
 import { useSession } from "./useSession";
 import { useSessionExecutions } from "./useSessionExecutions";
 import { useUpdateSession } from "./useUpdateSession";
+import { useLocalSessionWorker } from "./useLocalSessionWorker";
 import {
   specWorkspaceToInput,
   specMcpUsagesToInput,
@@ -83,6 +84,12 @@ export interface SendFollowUpOptions {
    * - `"plan"`: read-only analysis, no file mutations.
    */
   readonly interactionMode?: "agent" | "plan";
+  /**
+   * Auto-approve every tool call for this execution (bypass the HITL gate).
+   *
+   * @see {@link CreateAgentExecutionInput.autoApproveAll}
+   */
+  readonly autoApproveAll?: boolean;
   /**
    * Workspace-relative file paths the user wants the agent to focus on.
    *
@@ -191,6 +198,12 @@ export interface UseSessionConversationReturn {
  * Platform builders get the complete conversation loop without
  * reimplementing orchestration logic.
  *
+ * For local execution, this hook also owns the session's runner worker
+ * lifecycle: while the session is open it keeps a worker polling the
+ * session task queue, and it tears the worker down on close. This is a
+ * no-op unless a `runnerAdapter` is configured and the session runs
+ * locally, so it is safe in every environment.
+ *
  * @param sessionId - Session to display and converse in. Pass `null` to skip.
  * @param org - Organization slug for creating follow-up executions.
  *
@@ -251,6 +264,10 @@ export function useSessionConversation(
     clearError: clearApprovalError,
   } = useSubmitApproval();
 
+  // Local execution: attach the session's runner worker while it is open and
+  // detach it on close. No-op for cloud sessions or when no adapter is set.
+  useLocalSessionWorker(sessionId, session);
+
   const [pendingExecutionId, setPendingExecutionId] = useState<string | null>(
     null,
   );
@@ -382,6 +399,7 @@ export function useSessionConversation(
           runtimeEnv: options?.runtimeEnv,
           attachments: options?.attachments,
           interactionMode: options?.interactionMode,
+          autoApproveAll: options?.autoApproveAll,
           workspaceFileRefs: options?.workspaceFileRefs,
         });
         setPendingExecutionId(result.executionId);

package/src/session/useSessionPageFlow.ts

@@ -2,6 +2,7 @@
 
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { McpServerUsageInput, ResourceRef } from "@stigmer/sdk";
+import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import type { AgentResolution } from "../agent";
 import { useDefaultAgent } from "../agent";
 import { useStigmer } from "../hooks";
@@ -87,6 +88,31 @@ export interface UseSessionPageFlowReturn {
   /** Session variables (per-execution secrets) manager. */
   readonly sessionVariables: UseSessionVariablesReturn;
 
+  /**
+   * Session-scoped "auto-approve tool calls" preference.
+   *
+   * `false` by default. Flipped to `true` when the user chooses
+   * "Approve & don't ask again" at an approval gate (see {@link submitApproval}),
+   * and carried into every subsequent follow-up via {@link handleSubmit}. Held in
+   * memory only — reset on reload / new session, never persisted server-side.
+   */
+  readonly autoApproveAll: boolean;
+  /**
+   * Toggle the session-scoped auto-approve preference. The reversible "Turn off"
+   * control in the UI calls this with `false`.
+   */
+  readonly setAutoApproveAll: (value: boolean) => void;
+
+  /**
+   * Submit an approval decision for a pending tool call.
+   *
+   * Wraps {@link UseSessionConversationReturn.submitApproval}: when the action is
+   * `APPROVAL_ACTION_APPROVE_ALL`, it also flips the session-scoped
+   * {@link autoApproveAll} preference so future follow-ups skip the gate. The
+   * server independently auto-approves the rest of the current execution.
+   */
+  readonly submitApproval: UseSessionConversationReturn["submitApproval"];
+
   /**
    * Submit a follow-up message. Handles agent override resolution
    * (if the user changed the agent mid-session) and delegates to
@@ -186,6 +212,24 @@ export function useSessionPageFlow(
   const [skillRefs, setSkillRefs] = useState<ResourceRef[]>([]);
   const initialSyncDone = useRef(false);
 
+  // Session-scoped auto-approve, set at the approval gate (not pre-armed in the
+  // composer). Lives only in memory for the life of this page — reset on reload.
+  const [autoApproveAll, setAutoApproveAll] = useState(false);
+
+  const submitApproval = useCallback<UseSessionConversationReturn["submitApproval"]>(
+    async (toolCallId, action, comment) => {
+      // "Approve & don't ask again": remember the choice for the rest of this
+      // live session so future follow-ups carry auto_approve_all. The control
+      // plane separately resolves the current execution's remaining gates and
+      // the runner skips the gate for the rest of that run.
+      if (action === ApprovalAction.APPROVE_ALL) {
+        setAutoApproveAll(true);
+      }
+      await conv.submitApproval(toolCallId, action, comment);
+    },
+    [conv.submitApproval],
+  );
+
   // -------------------------------------------------------------------------
   // Agent — derive from session, allow mid-session changes
   // -------------------------------------------------------------------------
@@ -283,12 +327,15 @@ export function useSessionPageFlow(
         runtimeEnv: context?.runtimeEnv,
         attachments: context?.attachments,
         interactionMode: context?.interactionMode,
+        // Sourced from the session-scoped preference set at the approval gate,
+        // not from the composer (the pre-arm toggle was removed).
+        autoApproveAll: autoApproveAll || undefined,
         workspaceFileRefs: context?.workspaceFileRefs,
       });
 
       sessionVariables.clear();
     },
-    [conv.sendFollowUp, modelId, workspace, mcpServerUsages, skillRefs, sessionVariables.clear, resolution, agentRef, sessionInstanceId, stigmer],
+    [conv.sendFollowUp, modelId, workspace, mcpServerUsages, skillRefs, sessionVariables.clear, resolution, agentRef, sessionInstanceId, stigmer, autoApproveAll],
   );
 
   // -------------------------------------------------------------------------
@@ -333,6 +380,9 @@ export function useSessionPageFlow(
     setSkillRefs,
     workspace,
     sessionVariables,
+    autoApproveAll,
+    setAutoApproveAll,
+    submitApproval,
     handleSubmit,
     displayExecution,
     allExecutions,

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

@@ -48,8 +48,8 @@ function makeMockAdapter(): RunnerAdapter & { calls: string[][] } {
   const calls: string[][] = [];
   return {
     calls,
-    onSessionCreated: vi.fn(async (id: string) => { calls.push(["onSessionCreated", id]); }),
-    onSessionTerminated: vi.fn(async (id: string) => { calls.push(["onSessionTerminated", id]); }),
+    onSessionOpened: vi.fn(async (id: string) => { calls.push(["onSessionOpened", id]); }),
+    onSessionClosed: vi.fn(async (id: string) => { calls.push(["onSessionClosed", id]); }),
     onWorkflowExecutionCreated: vi.fn(async (id: string) => { calls.push(["onWorkflowExecutionCreated", id]); }),
     onWorkflowExecutionTerminated: vi.fn(async (id: string) => { calls.push(["onWorkflowExecutionTerminated", id]); }),
   };