@stigmer/react 3.34.0 → 3.36.0

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

@@ -1,1174 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { DEFAULT_MODEL_ID, DEFAULT_CURSOR_MODEL_ID, parseRegistryJson } from "../../models/registry";
-import { ModelRegistryContext } from "../../models/ModelRegistryContext";
-import type { ModelRegistryState } from "../../models/ModelRegistryContext";
-import { ExecutionTargetContext } from "../../execution-target-context";
-import { ApprovalDefaultsContext } from "../../approval-defaults-context";
-import type { ApprovalDefaults } from "../../approval-defaults-context";
-import { RunnerAdapterContext } from "../../runner-adapter";
-import type { RunnerAdapter } from "../../runner-adapter";
-const mockGetByReference = vi.fn();
-vi.mock("../../hooks", () => ({
-  useStigmer: () => ({ agent: { getByReference: mockGetByReference } }),
-}));
-
-const mockCreateExecution = vi.fn();
-vi.mock("../../execution/useCreateAgentExecution", () => ({
-  useCreateAgentExecution: () => ({
-    create: mockCreateExecution,
-    isCreating: false,
-    error: null,
-    clearError: vi.fn(),
-  }),
-}));
-
-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: [],
-  hasVariables: false,
-  setVariable: vi.fn(),
-  removeVariable: vi.fn(),
-  clear: vi.fn(),
-  toMap: vi.fn().mockReturnValue(new Map()),
-};
-vi.mock("../../execution/useSessionVariables", () => ({
-  useSessionVariables: () => mockSessionVariables,
-}));
-
-import { useNewSessionFlow } from "../useNewSessionFlow";
-
-const TEST_MODELS = parseRegistryJson({
-  models: [
-    { id: "claude-sonnet-4.6", displayName: "Claude Sonnet 4.6", shortDescription: "", speedTier: "fast", provider: "anthropic", harness: "native", costTier: "standard", featured: true, pricing: { inputPricePerMillion: 3, outputPricePerMillion: 15, cacheWritePricePerMillion: 3.75, cacheReadPricePerMillion: 0.3 } },
-    { id: "default", displayName: "Cursor Auto", shortDescription: "", speedTier: "fast", provider: "cursor", harness: "cursor", costTier: "standard", featured: true, pricing: { inputPricePerMillion: 1.25, outputPricePerMillion: 6, cacheWritePricePerMillion: 1.25, cacheReadPricePerMillion: 0.25 } },
-  ],
-});
-
-function createWrapper(
-  executionTarget?: "local" | "cloud",
-  adapter: RunnerAdapter | null = null,
-  approvalDefaults?: ApprovalDefaults,
-) {
-  const state: ModelRegistryState = { models: TEST_MODELS, isLoading: false, error: null, refetch: () => {} };
-  return function Wrapper({ children }: { children: ReactNode }) {
-    return (
-      <ExecutionTargetContext.Provider value={executionTarget}>
-        <ApprovalDefaultsContext.Provider value={approvalDefaults}>
-          <RunnerAdapterContext.Provider value={adapter}>
-            <ModelRegistryContext.Provider value={state}>
-              {children}
-            </ModelRegistryContext.Provider>
-          </RunnerAdapterContext.Provider>
-        </ApprovalDefaultsContext.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";
-
-function defaultOptions() {
-  return {
-    org: "acme",
-    onSessionCreated: vi.fn(),
-    onError: vi.fn(),
-  };
-}
-
-describe("useNewSessionFlow", () => {
-  beforeEach(() => {
-    localStorage.clear();
-    mockCreateExecution.mockResolvedValue({
-      executionId: "exec-new",
-      sessionId: "sess-new",
-    });
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    localStorage.clear();
-  });
-
-  describe("harness state", () => {
-    it("defaults to native when localStorage is empty", () => {
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-      expect(result.current.harness).toBe("native");
-    });
-
-    it("restores cursor harness from localStorage", () => {
-      localStorage.setItem(STORAGE_KEY_HARNESS, "cursor");
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-      expect(result.current.harness).toBe("cursor");
-    });
-
-    it("falls back to native for unknown localStorage values", () => {
-      localStorage.setItem(STORAGE_KEY_HARNESS, "unknown-value");
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-      expect(result.current.harness).toBe("native");
-    });
-
-    it("persists harness to localStorage on change", () => {
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-
-      act(() => result.current.setHarness("cursor"));
-
-      expect(localStorage.getItem(STORAGE_KEY_HARNESS)).toBe("cursor");
-      expect(result.current.harness).toBe("cursor");
-    });
-
-    it("persists native harness to localStorage", () => {
-      localStorage.setItem(STORAGE_KEY_HARNESS, "cursor");
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-
-      act(() => result.current.setHarness("native"));
-
-      expect(localStorage.getItem(STORAGE_KEY_HARNESS)).toBe("native");
-    });
-  });
-
-  describe("per-harness model persistence", () => {
-    it("uses separate storage keys for native and cursor models", () => {
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-
-      act(() => result.current.setModelId(DEFAULT_MODEL_ID));
-
-      expect(localStorage.getItem(STORAGE_KEY_MODEL_NATIVE)).toBe(
-        DEFAULT_MODEL_ID,
-      );
-      expect(localStorage.getItem(STORAGE_KEY_MODEL_CURSOR)).toBeNull();
-    });
-
-    it("persists cursor model to cursor-specific key", () => {
-      localStorage.setItem(STORAGE_KEY_HARNESS, "cursor");
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-
-      act(() => result.current.setModelId(DEFAULT_CURSOR_MODEL_ID));
-
-      expect(localStorage.getItem(STORAGE_KEY_MODEL_CURSOR)).toBe(
-        DEFAULT_CURSOR_MODEL_ID,
-      );
-    });
-
-    it("restores per-harness model when switching harness", () => {
-      localStorage.setItem(STORAGE_KEY_MODEL_CURSOR, DEFAULT_CURSOR_MODEL_ID);
-
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-
-      act(() => result.current.setHarness("cursor"));
-
-      expect(result.current.modelId).toBe(DEFAULT_CURSOR_MODEL_ID);
-    });
-
-    it("clears modelId when switching to a harness with no stored model", () => {
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-
-      act(() => result.current.setModelId(DEFAULT_MODEL_ID));
-      expect(result.current.modelId).toBe(DEFAULT_MODEL_ID);
-
-      act(() => result.current.setHarness("cursor"));
-
-      // No stored cursor model → modelId should be undefined
-      // (unless the model happens to be valid in the cursor registry)
-      if (result.current.modelId !== undefined) {
-        // If it has a value, it must be valid for cursor harness
-        expect(result.current.modelId).toBe(
-          localStorage.getItem(STORAGE_KEY_MODEL_CURSOR),
-        );
-      }
-    });
-
-    it("invalidates modelId when it is not in the active harness registry", () => {
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-
-      // Set a native-only model
-      act(() => result.current.setModelId(DEFAULT_MODEL_ID));
-      expect(result.current.modelId).toBe(DEFAULT_MODEL_ID);
-
-      // Switch to cursor → native model should be invalidated
-      act(() => result.current.setHarness("cursor"));
-
-      // DEFAULT_MODEL_ID (anthropic) is not in cursor registry
-      expect(result.current.modelId).not.toBe(DEFAULT_MODEL_ID);
-    });
-
-    it("strips compound keys before persisting to localStorage", () => {
-      localStorage.setItem(STORAGE_KEY_HARNESS, "cursor");
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-
-      // Simulate compound key from unified mode ModelSelector
-      act(() => result.current.setModelId("cursor/default"));
-
-      // Should store plain modelId, not compound key
-      expect(localStorage.getItem(STORAGE_KEY_MODEL_CURSOR)).toBe("default");
-    });
-
-    it("restores compound keys from localStorage as plain modelId", () => {
-      localStorage.setItem(STORAGE_KEY_HARNESS, "cursor");
-      // Legacy: compound key was stored before fix
-      localStorage.setItem(STORAGE_KEY_MODEL_CURSOR, "cursor/default");
-
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-
-      // Should extract plain modelId and validate against registry
-      expect(result.current.modelId).toBe(DEFAULT_CURSOR_MODEL_ID);
-    });
-  });
-
-  describe("model validation timing", () => {
-    it("does not restore model while registry is loading", () => {
-      localStorage.setItem(STORAGE_KEY_MODEL_NATIVE, DEFAULT_MODEL_ID);
-      const loadingState: ModelRegistryState = { models: [], isLoading: true, error: null, refetch: () => {} };
-
-      function LoadingWrapper({ children }: { children: ReactNode }) {
-        return (
-          <ModelRegistryContext.Provider value={loadingState}>
-            {children}
-          </ModelRegistryContext.Provider>
-        );
-      }
-
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: LoadingWrapper });
-
-      expect(result.current.modelId).toBeUndefined();
-    });
-
-    it("restores model once registry has loaded", () => {
-      localStorage.setItem(STORAGE_KEY_MODEL_NATIVE, DEFAULT_MODEL_ID);
-
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-
-      expect(result.current.modelId).toBe(DEFAULT_MODEL_ID);
-    });
-
-    it("discards model that no longer exists in the registry", () => {
-      localStorage.setItem(STORAGE_KEY_MODEL_NATIVE, "removed-model-xyz");
-
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-
-      expect(result.current.modelId).toBeUndefined();
-    });
-  });
-
-  describe("submit — owner-pinned runConfig (#664)", () => {
-    it("stamps the pinned model and fast tier over the composer's selection and the restored preference", async () => {
-      localStorage.setItem(STORAGE_KEY_MODEL_NATIVE, DEFAULT_MODEL_ID);
-      const { result } = renderHook(
-        () =>
-          useNewSessionFlow({
-            ...defaultOptions(),
-            runConfig: { modelName: "pinned-model", serviceTier: "fast" },
-          }),
-        { wrapper: createWrapper() },
-      );
-
-      await act(async () => {
-        await result.current.submit("Hello", "user-picked-model");
-      });
-
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.modelName).toBe("pinned-model");
-      expect(execInput.serviceTier).toBe("fast");
-    });
-
-    it("a model-only pin suppresses a composer-armed fast tier (the pin owns the whole run config)", async () => {
-      const { result } = renderHook(
-        () =>
-          useNewSessionFlow({
-            ...defaultOptions(),
-            runConfig: { modelName: "pinned-model" },
-          }),
-        { wrapper: createWrapper() },
-      );
-
-      await act(async () => {
-        await result.current.submit("Hello", undefined, { serviceTier: "fast" });
-      });
-
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.modelName).toBe("pinned-model");
-      expect(execInput.serviceTier).toBeUndefined();
-    });
-
-    it("ignores the pin entirely for guests — the platform share policy owns guest config", async () => {
-      const { result } = renderHook(
-        () =>
-          useNewSessionFlow({
-            ...defaultOptions(),
-            audience: "guest",
-            runConfig: { modelName: "pinned-model", serviceTier: "fast" },
-          }),
-        { wrapper: createWrapper() },
-      );
-
-      // Guests submit against an explicitly pinned shared agent.
-      act(() => {
-        result.current.setAgentRef({ org: "acme", slug: "shared-agent" });
-        result.current.setResolution({ mode: "saved", instanceId: "inst-shared" });
-      });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.modelName).toBeUndefined();
-      expect(execInput.serviceTier).toBeUndefined();
-    });
-
-    it("throws at render for the statically-wrong pin (fast tier, no model)", () => {
-      expect(() =>
-        renderHook(
-          () =>
-            useNewSessionFlow({
-              ...defaultOptions(),
-              runConfig: { serviceTier: "fast" },
-            }),
-          { wrapper: createWrapper() },
-        ),
-      ).toThrowError(/serviceTier "fast" requires modelName/);
-    });
-  });
-
-  describe("submit — one-call bootstrap", () => {
-    it("creates the execution with an embedded sessionSpec in a single call", async () => {
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(mockCreateExecution).toHaveBeenCalledOnce();
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.message).toBe("Hello");
-      expect(execInput.sessionSpec).toBeDefined();
-      // No agent picked: the built-in assistant, nothing to resolve or wait
-      // for — the session spec carries no instance and no agent id.
-      expect(execInput.sessionSpec.agentInstanceId).toBeUndefined();
-      expect(execInput.agentId).toBeUndefined();
-      expect(execInput.sessionId).toBeUndefined();
-    });
-
-    it("passes harness in the sessionSpec", async () => {
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.sessionSpec.harness).toBe("native");
-    });
-
-    it("omits autoApproveAll by default (fail-closed gates unchanged)", async () => {
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.autoApproveAll).toBeUndefined();
-    });
-
-    it("forwards the host approval default into the bootstrap create (#302)", async () => {
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), {
-        wrapper: createWrapper(undefined, null, { autoApproveAll: true }),
-      });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.autoApproveAll).toBe(true);
-    });
-
-    it("carries the user's pre-arm toggle into the bootstrap create (#816)", async () => {
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      expect(result.current.autoApproveAll).toBe(false);
-      act(() => result.current.setAutoApproveAll(true));
-      expect(result.current.autoApproveAll).toBe(true);
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.autoApproveAll).toBe(true);
-    });
-
-    it("the user's toggle-off beats the host approval default (#816)", async () => {
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), {
-        wrapper: createWrapper(undefined, null, { autoApproveAll: true }),
-      });
-
-      expect(result.current.autoApproveAll).toBe(true);
-      act(() => result.current.setAutoApproveAll(false));
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.autoApproveAll).toBeUndefined();
-    });
-
-    it("arms from the account's default_auto_approve preference", async () => {
-      const opts = {
-        ...defaultOptions(),
-        accountDefaults: { autoApprove: true },
-      };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      expect(result.current.autoApproveAll).toBe(true);
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.autoApproveAll).toBe(true);
-    });
-
-    it("a LATE-arriving account preference still arms (derived, not initialized)", () => {
-      // whoAmI resolves after mount — the seed must be part of the
-      // derivation so it cannot be missed by a useState initializer.
-      const initialProps: { accountDefaults?: { autoApprove?: boolean } } = {};
-      const { result, rerender } = renderHook(
-        ({ accountDefaults }: typeof initialProps) =>
-          useNewSessionFlow({ ...defaultOptions(), accountDefaults }),
-        { wrapper: createWrapper(), initialProps },
-      );
-      expect(result.current.autoApproveAll).toBe(false);
-
-      rerender({ accountDefaults: { autoApprove: true } });
-      expect(result.current.autoApproveAll).toBe(true);
-    });
-
-    it("a late arrival never overrides the user's explicit OFF", () => {
-      const initialProps: { accountDefaults?: { autoApprove?: boolean } } = {};
-      const { result, rerender } = renderHook(
-        ({ accountDefaults }: typeof initialProps) =>
-          useNewSessionFlow({ ...defaultOptions(), accountDefaults }),
-        { wrapper: createWrapper(), initialProps },
-      );
-      act(() => result.current.setAutoApproveAll(false));
-
-      rerender({ accountDefaults: { autoApprove: true } });
-      expect(result.current.autoApproveAll).toBe(false);
-    });
-
-    it("guests never inherit the account auto-approve preference", () => {
-      const opts = {
-        ...defaultOptions(),
-        audience: "guest" as const,
-        accountDefaults: { autoApprove: true },
-      };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      expect(result.current.autoApproveAll).toBe(false);
-    });
-
-    it("passes cursor harness in the sessionSpec after switching", async () => {
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      act(() => result.current.setHarness("cursor"));
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.sessionSpec.harness).toBe("cursor");
-    });
-
-    it("forwards metadata and sessionContext verbatim in the sessionSpec", async () => {
-      // The typed-wins merge onto the reserved key happens downstream in
-      // useCreateAgentExecution (covered by its own tests); the flow's job
-      // is faithful forwarding.
-      const opts = {
-        ...defaultOptions(),
-        metadata: { "acme/tenant": "t-1" },
-        sessionContext: "Role: platform admin",
-      };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.sessionSpec.metadata).toEqual({ "acme/tenant": "t-1" });
-      expect(execInput.sessionSpec.sessionContext).toBe("Role: platform admin");
-    });
-
-    it("leaves metadata and sessionContext undefined when not provided", async () => {
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.sessionSpec.metadata).toBeUndefined();
-      expect(execInput.sessionSpec.sessionContext).toBeUndefined();
-    });
-
-    it("calls onSessionCreated with the server-assigned session id", async () => {
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(opts.onSessionCreated).toHaveBeenCalledWith("sess-new");
-    });
-
-    it("sets submitError and calls onError on failure", async () => {
-      mockCreateExecution.mockRejectedValueOnce(new Error("RPC fail"));
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(result.current.submitError).not.toBeNull();
-      expect(opts.onError).toHaveBeenCalled();
-    });
-
-    it("resets isSubmitting after completion", async () => {
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(result.current.isSubmitting).toBe(false);
-    });
-  });
-
-  describe("submit — agent resolution strategies", () => {
-    it("uses the saved resolution's instance directly (no agent lookup)", async () => {
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      act(() => {
-        result.current.setAgentRef({ org: "acme", slug: "reviewer" });
-        result.current.setResolution({ mode: "saved", instanceId: "saved-inst" });
-      });
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(mockGetByReference).not.toHaveBeenCalled();
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.sessionSpec.agentInstanceId).toBe("saved-inst");
-      expect(execInput.agentId).toBeUndefined();
-    });
-
-    it("resolves a non-saved agentRef to agentId and lets the server pick the instance", async () => {
-      mockGetByReference.mockResolvedValueOnce({ metadata: { id: "agt-resolved" } });
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      act(() => {
-        result.current.setAgentRef({ org: "acme", slug: "reviewer" });
-        result.current.setResolution({ mode: "direct" });
-      });
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(mockGetByReference).toHaveBeenCalledWith({ org: "acme", slug: "reviewer" });
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.agentId).toBe("agt-resolved");
-      // The server resolves (and if needed creates) the default instance.
-      expect(execInput.sessionSpec.agentInstanceId).toBeUndefined();
-    });
-  });
-
-  describe("submit with executionTarget", () => {
-    it("passes executionTarget in the sessionSpec when provided", async () => {
-      const opts = { ...defaultOptions(), executionTarget: "local" as const };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(mockCreateExecution).toHaveBeenCalledOnce();
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.sessionSpec.executionTarget).toBe("local");
-    });
-
-    it("does not include executionTarget when not provided", async () => {
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(mockCreateExecution).toHaveBeenCalledOnce();
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.sessionSpec.executionTarget).toBeUndefined();
-    });
-
-    it("uses context executionTarget when per-hook option is omitted", async () => {
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper("local") });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(mockCreateExecution).toHaveBeenCalledOnce();
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.sessionSpec.executionTarget).toBe("local");
-    });
-
-    it("per-hook executionTarget option overrides context", async () => {
-      const opts = { ...defaultOptions(), executionTarget: "local" as const };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper("cloud") });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(mockCreateExecution).toHaveBeenCalledOnce();
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.sessionSpec.executionTarget).toBe("local");
-    });
-  });
-
-  describe("submit — local runner worker (post-create attach)", () => {
-    it("attaches the worker after the bootstrap create returns the session id", 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 session ID only exists after the one-call create, so the attach
-      // follows it. This is safe: the first activity waits on the session's
-      // task queue for a worker (5-minute ScheduleToStart window).
-      const openedOrder = adapter.onSessionOpened.mock.invocationCallOrder[0];
-      const execOrder = mockCreateExecution.mock.invocationCallOrder[0];
-      expect(execOrder).toBeLessThan(openedOrder);
-    });
-
-    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("never attaches a worker when the bootstrap create 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");
-      });
-
-      // The create failed before a session existed, so there is no worker
-      // to attach — and therefore nothing to compensate/detach.
-      expect(adapter.onSessionOpened).not.toHaveBeenCalled();
-      expect(adapter.onSessionClosed).not.toHaveBeenCalled();
-      expect(result.current.submitError).not.toBeNull();
-      expect(opts.onError).toHaveBeenCalled();
-    });
-
-    it("surfaces an attach failure without navigating", async () => {
-      const adapter = createMockAdapter();
-      adapter.onSessionOpened.mockRejectedValueOnce(new Error("runner down"));
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), {
-        wrapper: createWrapper("local", adapter),
-      });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(result.current.submitError).not.toBeNull();
-      expect(opts.onError).toHaveBeenCalled();
-      expect(opts.onSessionCreated).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("host runtime env (getRuntimeEnv)", () => {
-    it("merges host env into the first execution, host wins on collisions", async () => {
-      const getRuntimeEnv = vi.fn().mockResolvedValue({
-        PLATFORM_TOKEN: { value: "fresh-token", isSecret: true },
-      });
-      const opts = { ...defaultOptions(), getRuntimeEnv };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello", undefined, {
-          runtimeEnv: {
-            PLATFORM_TOKEN: { value: "stale-token", isSecret: true },
-            USER_VAR: { value: "kept" },
-          },
-        });
-      });
-
-      expect(getRuntimeEnv).toHaveBeenCalledTimes(1);
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.runtimeEnv).toEqual({
-        PLATFORM_TOKEN: { value: "fresh-token", isSecret: true },
-        USER_VAR: { value: "kept" },
-      });
-    });
-
-    it("evaluates the provider fresh on every submission", async () => {
-      let mint = 0;
-      const getRuntimeEnv = vi.fn(() => ({
-        TOKEN: { value: `token-${++mint}` },
-      }));
-      const opts = { ...defaultOptions(), getRuntimeEnv };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("First");
-      });
-      await act(async () => {
-        await result.current.submit("Second");
-      });
-
-      expect(getRuntimeEnv).toHaveBeenCalledTimes(2);
-      expect(mockCreateExecution.mock.calls[0][0].runtimeEnv).toEqual({
-        TOKEN: { value: "token-1" },
-      });
-      expect(mockCreateExecution.mock.calls[1][0].runtimeEnv).toEqual({
-        TOKEN: { value: "token-2" },
-      });
-    });
-
-    it("aborts before session creation when the provider throws", async () => {
-      const getRuntimeEnv = vi.fn().mockRejectedValue(new Error("token mint failed"));
-      const opts = { ...defaultOptions(), getRuntimeEnv };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      // No orphan session, no execution — the failure is fully pre-flight.
-      expect(mockCreateExecution).not.toHaveBeenCalled();
-      expect(result.current.submitError).toContain("token mint failed");
-      expect(opts.onError).toHaveBeenCalled();
-      expect(result.current.isSubmitting).toBe(false);
-    });
-
-    it("passes composer env through untouched when no provider is configured", async () => {
-      const opts = defaultOptions();
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello", undefined, {
-          runtimeEnv: { USER_VAR: { value: "composer-only" } },
-        });
-      });
-
-      expect(mockCreateExecution.mock.calls[0][0].runtimeEnv).toEqual({
-        USER_VAR: { value: "composer-only" },
-      });
-    });
-  });
-
-  describe("defaultHarness", () => {
-    it("seeds the embedder default when no harness is stored", () => {
-      const opts = { ...defaultOptions(), defaultHarness: "cursor" as const };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      expect(result.current.harness).toBe("cursor");
-    });
-
-    it("stored user choice outranks the embedder default", () => {
-      localStorage.setItem(STORAGE_KEY_HARNESS, "native");
-      const opts = { ...defaultOptions(), defaultHarness: "cursor" as const };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      expect(result.current.harness).toBe("native");
-    });
-
-    it("does not persist the seeded default — only explicit choices", () => {
-      const opts = { ...defaultOptions(), defaultHarness: "cursor" as const };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      // Seeding must not masquerade as a user choice, otherwise the
-      // embedder default would stop applying after the first visit.
-      expect(localStorage.getItem(STORAGE_KEY_HARNESS)).toBeNull();
-
-      act(() => result.current.setHarness("native"));
-      expect(localStorage.getItem(STORAGE_KEY_HARNESS)).toBe("native");
-    });
-
-    it("submits sessions with the seeded default harness", async () => {
-      const opts = { ...defaultOptions(), defaultHarness: "cursor" as const };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(mockCreateExecution.mock.calls[0][0].sessionSpec.harness).toBe("cursor");
-    });
-  });
-
-  describe("accountDefaults (oss#293 Phase 1.5 layered seed)", () => {
-    // Two native models so "stored pick outranks account default" is
-    // distinguishable; the shared TEST_MODELS carries one per harness.
-    const SEED_MODELS = parseRegistryJson({
-      models: [
-        { id: "claude-sonnet-4.6", displayName: "Claude Sonnet 4.6", shortDescription: "", speedTier: "fast", provider: "anthropic", harness: "native", costTier: "standard", featured: true, pricing: { inputPricePerMillion: 3, outputPricePerMillion: 15, cacheWritePricePerMillion: 3.75, cacheReadPricePerMillion: 0.3 } },
-        { id: "gpt-5.3", displayName: "GPT 5.3", shortDescription: "", speedTier: "fast", provider: "openai", harness: "native", costTier: "standard", featured: false, pricing: { inputPricePerMillion: 2, outputPricePerMillion: 8, cacheWritePricePerMillion: 2, cacheReadPricePerMillion: 0.2 } },
-        { id: "default", displayName: "Cursor Auto", shortDescription: "", speedTier: "fast", provider: "cursor", harness: "cursor", costTier: "standard", featured: true, pricing: { inputPricePerMillion: 1.25, outputPricePerMillion: 6, cacheWritePricePerMillion: 1.25, cacheReadPricePerMillion: 0.25 } },
-        { id: "composer-2.5", displayName: "Composer 2.5", shortDescription: "", speedTier: "fast", provider: "cursor", harness: "cursor", costTier: "standard", featured: false, pricing: { inputPricePerMillion: 1, outputPricePerMillion: 5, cacheWritePricePerMillion: 1, cacheReadPricePerMillion: 0.1 } },
-      ],
-    });
-
-    function seedWrapper() {
-      const state: ModelRegistryState = { models: SEED_MODELS, isLoading: false, error: null, refetch: () => {} };
-      return function Wrapper({ children }: { children: ReactNode }) {
-        return (
-          <ModelRegistryContext.Provider value={state}>
-            {children}
-          </ModelRegistryContext.Provider>
-        );
-      };
-    }
-
-    it("seeds the harness when nothing is stored", () => {
-      const opts = { ...defaultOptions(), accountDefaults: { harness: "cursor" as const } };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
-
-      expect(result.current.harness).toBe("cursor");
-    });
-
-    it("a stored harness choice outranks the account default", () => {
-      localStorage.setItem(STORAGE_KEY_HARNESS, "native");
-      const opts = { ...defaultOptions(), accountDefaults: { harness: "cursor" as const } };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
-
-      expect(result.current.harness).toBe("native");
-    });
-
-    it("the account harness outranks the embedder defaultHarness", () => {
-      const opts = {
-        ...defaultOptions(),
-        defaultHarness: "native" as const,
-        accountDefaults: { harness: "cursor" as const },
-      };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
-
-      expect(result.current.harness).toBe("cursor");
-    });
-
-    it("never persists the seeded harness — only explicit choices", () => {
-      const opts = { ...defaultOptions(), accountDefaults: { harness: "cursor" as const } };
-      renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
-
-      expect(localStorage.getItem(STORAGE_KEY_HARNESS)).toBeNull();
-    });
-
-    it("a late-arriving harness seed applies when the user has not picked (whoAmI resolves after mount)", () => {
-      const base: Parameters<typeof useNewSessionFlow>[0] = defaultOptions();
-      const { result, rerender } = renderHook(
-        (opts: Parameters<typeof useNewSessionFlow>[0]) => useNewSessionFlow(opts),
-        { wrapper: seedWrapper(), initialProps: base },
-      );
-      expect(result.current.harness).toBe("native");
-
-      rerender({ ...base, accountDefaults: { harness: "cursor" as const } });
-
-      expect(result.current.harness).toBe("cursor");
-      expect(localStorage.getItem(STORAGE_KEY_HARNESS)).toBeNull();
-    });
-
-    it("a late-arriving harness seed never overrides an explicit pick this mount", () => {
-      const base: Parameters<typeof useNewSessionFlow>[0] = defaultOptions();
-      const { result, rerender } = renderHook(
-        (opts: Parameters<typeof useNewSessionFlow>[0]) => useNewSessionFlow(opts),
-        { wrapper: seedWrapper(), initialProps: base },
-      );
-      act(() => result.current.setHarness("native"));
-
-      rerender({ ...base, accountDefaults: { harness: "cursor" as const } });
-
-      expect(result.current.harness).toBe("native");
-    });
-
-    it("seeds the model for the active harness when nothing is stored", () => {
-      const opts = { ...defaultOptions(), accountDefaults: { nativeModel: "gpt-5.3" } };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
-
-      expect(result.current.modelId).toBe("gpt-5.3");
-    });
-
-    it("a stored model pick outranks the account default", async () => {
-      localStorage.setItem(STORAGE_KEY_MODEL_NATIVE, "claude-sonnet-4.6");
-      const opts = { ...defaultOptions(), accountDefaults: { nativeModel: "gpt-5.3" } };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
-
-      // The stored restore lands in a passive effect once the registry is
-      // ready; the account seed must not win the race before it.
-      await act(async () => {});
-      expect(result.current.modelId).toBe("claude-sonnet-4.6");
-    });
-
-    it("self-heals a stale account model to the platform default (undefined)", () => {
-      const opts = { ...defaultOptions(), accountDefaults: { nativeModel: "retired-model" } };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
-
-      expect(result.current.modelId).toBeUndefined();
-    });
-
-    it("never persists the seeded model — only explicit choices", () => {
-      const opts = { ...defaultOptions(), accountDefaults: { nativeModel: "gpt-5.3" } };
-      renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
-
-      expect(localStorage.getItem(STORAGE_KEY_MODEL_NATIVE)).toBeNull();
-    });
-
-    it("follows the active harness: cursorModel seeds cursor sessions", () => {
-      const opts = {
-        ...defaultOptions(),
-        accountDefaults: { harness: "cursor" as const, nativeModel: "gpt-5.3", cursorModel: "composer-2.5" },
-      };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
-
-      expect(result.current.harness).toBe("cursor");
-      expect(result.current.modelId).toBe("composer-2.5");
-    });
-
-    it("submits the seeded model explicitly — the pill promise (#663) and the DD-003 seed rule", async () => {
-      const opts = { ...defaultOptions(), accountDefaults: { nativeModel: "gpt-5.3" } };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(mockCreateExecution.mock.calls[0][0].modelName).toBe("gpt-5.3");
-    });
-
-    it("guest audience ignores accountDefaults entirely", () => {
-      const opts = {
-        ...defaultOptions(),
-        audience: "guest" as const,
-        accountDefaults: { harness: "native" as const, nativeModel: "gpt-5.3", cursorModel: "composer-2.5" },
-      };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
-
-      // Platform share policy: cursor harness, no client model.
-      expect(result.current.harness).toBe("cursor");
-      expect(result.current.modelId).toBeUndefined();
-    });
-  });
-
-  describe("guest audience", () => {
-    it("creates the session against the pinned resolution", async () => {
-      const opts = { ...defaultOptions(), audience: "guest" as const };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      act(() => {
-        result.current.setAgentRef({ org: "acme", slug: "support-bot" });
-        result.current.setResolution({ mode: "saved", instanceId: "shared-inst" });
-      });
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(mockCreateExecution).toHaveBeenCalledOnce();
-      expect(mockCreateExecution.mock.calls[0][0].sessionSpec.agentInstanceId).toBe("shared-inst");
-      expect(opts.onSessionCreated).toHaveBeenCalledWith("sess-new");
-    });
-
-    it("fails closed on submit without a resolution — never the built-in assistant", async () => {
-      // An integrator with no agent picked gets the built-in assistant; a
-      // guest on a shared page never does — only the pinned shared agent.
-      const opts = { ...defaultOptions(), audience: "guest" as const };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(mockCreateExecution).not.toHaveBeenCalled();
-      expect(result.current.submitError).toContain("still loading");
-      expect(opts.onError).toHaveBeenCalled();
-    });
-
-    it("always uses the cursor harness, ignoring a stored Console choice", () => {
-      // A browser previously used in the Console must not leak its stored
-      // harness into a share/embed session.
-      localStorage.setItem(STORAGE_KEY_HARNESS, "native");
-      const opts = { ...defaultOptions(), audience: "guest" as const };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      expect(result.current.harness).toBe("cursor");
-    });
-
-    it("never inherits the host approval default — guests get platform policy (#302)", async () => {
-      const opts = { ...defaultOptions(), audience: "guest" as const };
-      const { result } = renderHook(() => useNewSessionFlow(opts), {
-        wrapper: createWrapper(undefined, null, { autoApproveAll: true }),
-      });
-
-      act(() => {
-        result.current.setAgentRef({ org: "acme", slug: "support-bot" });
-        result.current.setResolution({ mode: "saved", instanceId: "shared-inst" });
-      });
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.autoApproveAll).toBeUndefined();
-    });
-
-    it("ignores the embedder's defaultHarness — guests get platform policy", () => {
-      const opts = {
-        ...defaultOptions(),
-        audience: "guest" as const,
-        defaultHarness: "native" as const,
-      };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      expect(result.current.harness).toBe("cursor");
-    });
-
-    it("does not restore a stored model — modelId stays undefined", () => {
-      localStorage.setItem(STORAGE_KEY_MODEL_CURSOR, DEFAULT_CURSOR_MODEL_ID);
-      const opts = { ...defaultOptions(), audience: "guest" as const };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      expect(result.current.modelId).toBeUndefined();
-    });
-
-    it("never writes Console preference keys", () => {
-      const opts = { ...defaultOptions(), audience: "guest" as const };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      act(() => result.current.setHarness("native"));
-      act(() => result.current.setModelId(DEFAULT_CURSOR_MODEL_ID));
-
-      expect(localStorage.getItem(STORAGE_KEY_HARNESS)).toBeNull();
-      expect(localStorage.getItem(STORAGE_KEY_MODEL_NATIVE)).toBeNull();
-      expect(localStorage.getItem(STORAGE_KEY_MODEL_CURSOR)).toBeNull();
-    });
-
-    it("submits with the cursor harness and NO model (server resolves Auto)", async () => {
-      // Stored values simulate a Console-used browser: neither may leak.
-      localStorage.setItem(STORAGE_KEY_HARNESS, "native");
-      localStorage.setItem(STORAGE_KEY_MODEL_CURSOR, DEFAULT_CURSOR_MODEL_ID);
-      const opts = { ...defaultOptions(), audience: "guest" as const };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      act(() => {
-        result.current.setAgentRef({ org: "acme", slug: "support-bot" });
-        result.current.setResolution({ mode: "saved", instanceId: "shared-inst" });
-      });
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      const execInput = mockCreateExecution.mock.calls[0][0];
-      expect(execInput.sessionSpec.harness).toBe("cursor");
-      // Omitted model = cursor's Auto ("default") in the runner. If this ever
-      // carries a value, guest follow-ups would silently pin to it via
-      // lastExecModelId in useSessionPageFlow.
-      expect(execInput.modelName).toBeUndefined();
-    });
-
-    it("surfaces launch-gate refusal copy verbatim from the status description", async () => {
-      // The backend resolves owner-customizable refusal copy server-side and
-      // carries it in the gRPC status description — the flow must hand it to
-      // onError untouched (no client-side mapping exists by design).
-      const ownerCopy = "This agent is currently unavailable. Please check back later.";
-      const { ConnectError, Code } = await import("@connectrpc/connect");
-      mockCreateExecution.mockRejectedValueOnce(
-        new ConnectError(ownerCopy, Code.FailedPrecondition),
-      );
-
-      const opts = { ...defaultOptions(), audience: "guest" as const };
-      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
-
-      act(() => {
-        result.current.setAgentRef({ org: "acme", slug: "support-bot" });
-        result.current.setResolution({ mode: "saved", instanceId: "shared-inst" });
-      });
-      await act(async () => {
-        await result.current.submit("Hello");
-      });
-
-      expect(result.current.submitError).toBe(ownerCopy);
-      expect(opts.onError).toHaveBeenCalledWith(ownerCopy);
-    });
-  });
-});