@stigmer/react 3.12.7 → 3.12.9

package/src/session/NewSessionViewer.tsx

@@ -6,7 +6,7 @@ import type { UseGitHubConnectionReturn } from "../github/useGitHubConnection.js
 import type { WorkspaceFileLister } from "../workspace/WorkspaceFileLister.js";
 import type { WorkspaceFileReader } from "../workspace/WorkspaceFileReader.js";
 import type { WorkspaceContentSearcher } from "../workspace/WorkspaceContentSearcher.js";
-import type { ComposerAutoApproveProps, InteractionModeOption } from "../composer/index.js";
+import type { InteractionModeOption } from "../composer/index.js";
 import { SessionComposer } from "../composer/index.js";
 import type { HarnessOption } from "../models/harness.js";
 import type { AccountExecutionDefaults } from "../identity-account/useAccountExecutionDefaults.js";
@@ -18,6 +18,7 @@ import { useNewSessionFlow } from "./useNewSessionFlow.js";
 import { useSessionPanel } from "./useSessionPanel.js";
 import { useSessionRailViews } from "./useSessionRailViews.js";
 import { SessionPanelChip } from "./SessionPanelChip.js";
+import { AutoApproveIndicator } from "./AutoApproveIndicator.js";
 import type { RuntimeEnvProvider } from "./runtime-env.js";
 import type { SessionAudience, SessionPanelMode } from "./audience.js";
 import type { SessionRunConfig } from "./run-config.js";
@@ -299,19 +300,6 @@ export function NewSessionViewer({
   // SessionViewer derives (DD-016), gating the chip and the region together.
   const panelEnabled = panelMode !== "none" && !isGuest;
 
-  // Always-visible auto-approve toggle (#816), present before the first
-  // message is ever typed — the walk-away user arms it here and the create
-  // carries spec.auto_approve_all server-side. Guests never get it (the
-  // operator-consent reasoning as the #302 host default). Memoized per
-  // DD-010 — the composer is memo'd and an inline object would defeat it.
-  const autoApprove = useMemo<ComposerAutoApproveProps | undefined>(
-    () =>
-      isGuest
-        ? undefined
-        : { armed: flow.autoApproveAll, onChange: flow.setAutoApproveAll },
-    [isGuest, flow.autoApproveAll, flow.setAutoApproveAll],
-  );
-
   // Guest agent binding is host configuration, not a picker interaction:
   // the composer's agent machinery (picker, env-collection, personal
   // environments — all org reads a guest token cannot make) stays fully
@@ -387,6 +375,13 @@ export function NewSessionViewer({
       harness: flow.harness,
       executionTarget: undefined,
       modelId: flow.modelId,
+      // Pre-session arming (#816): the switch covers the session this
+      // surface will create — the bootstrap execution carries
+      // spec.auto_approve_all. Guests never get it (they never render the
+      // panel either — belt and braces for the operator-consent withhold).
+      autoApprove: isGuest
+        ? undefined
+        : { armed: flow.autoApproveAll, onChange: flow.setAutoApproveAll },
       // Curated audiences see the configuration but cannot strip it — the
       // Setup tab renders read-only without mutation callbacks (DD-011).
       mutations: isCurated
@@ -400,6 +395,7 @@ export function NewSessionViewer({
     [
       flow.agentRef, flow.mcpServerUsages, flow.skillRefs,
       flow.sessionVariables, flow.harness, flow.modelId,
+      flow.autoApproveAll, flow.setAutoApproveAll, isGuest,
       isCurated, handleRemoveAgent, handleRemoveMcp, handleRemoveSkill,
     ],
   );
@@ -465,7 +461,6 @@ export function NewSessionViewer({
           onInteractionModeChange={setInteractionMode}
           showInteractionModePicker={!isGuest}
           showModelSelector={modelSelectorVisible}
-          autoApprove={autoApprove}
           enableAttachments={!isGuest}
           defaultModelId={flow.modelId}
           onModelChange={flow.setModelId}
@@ -475,6 +470,14 @@ export function NewSessionViewer({
           ariaLabel="Start a new session"
         />
 
+        {/* Armed-only disclosure (#816 rework): a persisted account preference
+            or the host's approvalDefaults can pre-arm the session this surface
+            will create — the user must see that before the first send, with
+            the one-click way off. Guests never inherit either seed. */}
+        {!isGuest && flow.autoApproveAll && (
+          <AutoApproveIndicator onTurnOff={() => flow.setAutoApproveAll(false)} />
+        )}
+
         {footerContent}
 
         <p className="stg:text-center stg:text-[0.65rem] stg:text-muted-foreground">

package/src/session/SessionViewer.tsx

@@ -17,7 +17,8 @@ import {
   WorkspaceSurface,
   type SurfaceVirtualDocument,
 } from "../workspace/WorkspaceSurface.js";
-import type { ComposerAutoApproveProps, InteractionModeOption, SessionComposerHandle, SessionComposerSubmitContext } from "../composer/index.js";
+import type { InteractionModeOption, SessionComposerHandle, SessionComposerSubmitContext } from "../composer/index.js";
+import type { AccountExecutionDefaults } from "../identity-account/useAccountExecutionDefaults.js";
 import type { ApplyResourceResult } from "../library/useApplyResource.js";
 import { SessionViewerLayout } from "./SessionViewerLayout.js";
 import { useWorkspaceEditors, isVirtualEntryId } from "../internal/store/index.js";
@@ -52,6 +53,7 @@ import { useSessionRailViews } from "./useSessionRailViews.js";
 import { useSessionPanel, type SessionPanelController } from "./useSessionPanel.js";
 import { SessionPanelChip } from "./SessionPanelChip.js";
 import { TranscriptExportMenu } from "./TranscriptExportMenu.js";
+import { AutoApproveIndicator } from "./AutoApproveIndicator.js";
 import { useSessionWriteBacks } from "./useSessionWriteBacks.js";
 import { useWorkspaceReadRefs } from "./useWorkspaceReadRefs.js";
 import {
@@ -240,6 +242,17 @@ export interface SessionViewerProps {
    * server-side share policy owns. See {@link SessionRunConfig}.
    */
   readonly runConfig?: SessionRunConfig;
+  /**
+   * The user's account-level execution defaults, typically from
+   * `useAccountExecutionDefaults()` — same seam as
+   * `NewSessionViewer.accountDefaults` (DD-016). On the session page only
+   * the `autoApprove` default applies: it seeds the session-scoped
+   * auto-approve state so a declared `default_auto_approve` preference
+   * covers follow-ups on existing sessions too. An explicit flip of the
+   * Config facet's switch wins for this session. Ignored for the
+   * `"guest"` audience.
+   */
+  readonly accountDefaults?: AccountExecutionDefaults;
   /**
    * Whether the follow-up composer offers the model picker. `false`
    * hides the picker while keeping the SDK's model sourcing (persisted
@@ -295,14 +308,14 @@ export interface SessionViewerProps {
    */
   readonly headerActions?: ReactNode;
   /**
-   * Whether the viewer renders its built-in whole-conversation export
-   * control ({@link TranscriptExportMenu}) in the header corner
-   * (stigmer/stigmer#814). Default ON — a deliberate DD-011 divergence,
-   * owner-ratified: wherever a conversation can be viewed its transcript
-   * should be one click away, the control is an additive header button (no
-   * rendering-strategy or DOM-structure change to existing content), and
-   * the export carries only what the current caller can already read.
-   * Hosts that own their export surface (or inert demo scenes) opt out.
+   * Whether the viewer offers its built-in whole-conversation export
+   * (stigmer/stigmer#814). Placement is panel-aware: viewers with the
+   * session panel export from the Config facet's Transcript section, and
+   * panel-less viewers (guests, `panel="none"`) render the header
+   * {@link TranscriptExportMenu} instead — so wherever a conversation can
+   * be viewed, its transcript stays reachable. The export carries only
+   * what the current caller can already read (`can_view`-scoped). Hosts
+   * that own their export surface (or inert demo scenes) opt out.
    *
    * @default true
    */
@@ -382,6 +395,7 @@ export function SessionViewer({
   getRuntimeEnv,
   audience = "integrator",
   runConfig,
+  accountDefaults,
   showModelSelector = true,
   panel: panelMode = "auto",
   defaultPanelOpen,
@@ -400,6 +414,7 @@ export function SessionViewer({
     getRuntimeEnv,
     audience,
     runConfig,
+    accountDefaults,
   });
   const { conv } = flow;
   const isGuest = audience === "guest";
@@ -661,15 +676,18 @@ export function SessionViewer({
   return (
     <SessionViewerLayout
       className={className}
-      // Top-right controls: host actions + the built-in transcript export +
-      // the panel chip. The chip is the panel's always-mounted toggle; while
-      // collapsed it carries only the pending-item count. Execution status
-      // is never surfaced as header chrome — the thread itself communicates
-      // run state. A viewer without a panel (guests — session configuration
-      // is not a visitor's business — or a host's panel="none") has no
-      // toggle: it is simply absent.
+      // Top-right controls: host actions + the panel chip. The chip is the
+      // panel's always-mounted toggle; while collapsed it carries only the
+      // pending-item count. Execution status is never surfaced as header
+      // chrome — the thread itself communicates run state. A viewer without
+      // a panel (guests — session configuration is not a visitor's business —
+      // or a host's panel="none") has no toggle: it is simply absent.
+      //
+      // Transcript export lives in the panel's Config facet; the header menu
+      // renders ONLY for panel-less viewers, so no audience loses export
+      // (guests and panel="none" hosts have no facet to reach it through).
       headerActions={
-        transcriptExport ? (
+        transcriptExport && !panelEnabled ? (
           <>
             {headerActions}
             <TranscriptExportMenu sessionId={sessionId} />
@@ -745,6 +763,10 @@ export function SessionViewer({
             workspaceFileReader={workspaceFileReader}
             workspaceContentSearcher={workspaceContentSearcher}
             isCurated={isCurated}
+            isObserver={isObserver}
+            // Drives the Config facet's Transcript section only — a host
+            // that opted out of export gets no facet section either.
+            exportSessionId={transcriptExport ? sessionId : null}
           />
         ) : null
       }
@@ -849,20 +871,6 @@ const ConversationColumn = memo(function ConversationColumn({
     void conv.stop();
   }, [conv.stop]);
 
-  // Always-visible auto-approve toggle (#816), replacing the old armed-only
-  // indicator banner: the walk-away user needs a way ON before any gate
-  // exists, not just a way off after one. Guests never get it (they don't
-  // inherit the host default and this is the operator's consent surface);
-  // observers have no composer at all. Memoized per DD-010 — the composer
-  // is memo'd and an inline object would defeat it.
-  const autoApprove = useMemo<ComposerAutoApproveProps | undefined>(
-    () =>
-      isGuest
-        ? undefined
-        : { armed: flow.autoApproveAll, onChange: flow.setAutoApproveAll },
-    [isGuest, flow.autoApproveAll, flow.setAutoApproveAll],
-  );
-
   // Edit-and-resubmit: stop the in-flight turn, pre-fill the composer with
   // the original text, and remember which execution is being edited. The
   // append-only execution log is never rewritten — submitting while editing
@@ -987,6 +995,13 @@ const ConversationColumn = memo(function ConversationColumn({
           />
         )}
         {!isObserver && sendError && <SendErrorBanner error={sendError} />}
+        {/* Armed-only disclosure (#816 rework): auto-approve's way ON lives in
+            the Config facet and the account preference — this strip is the
+            always-visible proof it is on, plus the one-click way off. Never
+            shown to observers (they cannot arm or disarm anything). */}
+        {!isObserver && flow.autoApproveAll && (
+          <AutoApproveIndicator onTurnOff={() => flow.setAutoApproveAll(false)} />
+        )}
         {/* Pending file reviews dock here — pinned above the composer so the
             decision the agent is blocked on can never scroll out of view. The
             thread renders only observational rows (badges) and read-only
@@ -1028,7 +1043,6 @@ const ConversationColumn = memo(function ConversationColumn({
             onInteractionModeChange={setInteractionMode}
             showInteractionModePicker={!isGuest}
             showModelSelector={modelSelectorVisible}
-            autoApprove={autoApprove}
             enableAttachments={!isGuest}
             workspace={isGuest ? undefined : flow.workspace}
             gitHubConnection={isGuest ? undefined : gitHubConnection}
@@ -1105,6 +1119,17 @@ interface SessionPanelRegionProps {
   readonly workspaceContentSearcher?: WorkspaceContentSearcher;
   /** Curated audience (endUser or guest): the Setup facet renders read-only. */
   readonly isCurated: boolean;
+  /**
+   * Observer audience (incl. channel-origin sessions): read-only viewers who
+   * must never receive the Config facet's auto-approve switch — the same
+   * withhold as approval submission. (Guests never render the panel at all.)
+   */
+  readonly isObserver: boolean;
+  /**
+   * Session id for the Config facet's Transcript export section, or `null`
+   * when the host opted out of export (`transcriptExport={false}`).
+   */
+  readonly exportSessionId: string | null;
 }
 
 function SessionPanelRegion({
@@ -1128,6 +1153,8 @@ function SessionPanelRegion({
   workspaceFileReader,
   workspaceContentSearcher,
   isCurated,
+  isObserver,
+  exportSessionId,
 }: SessionPanelRegionProps) {
   const { editors, activeKey, activeFile, reveal } = useWorkspaceEditors(
     panel.editorsStore,
@@ -1295,6 +1322,16 @@ function SessionPanelRegion({
       harness: flow.harness,
       executionTarget: flow.executionTarget,
       modelId: flow.model[0],
+      // Arming auto-approve is an operator decision — withheld from
+      // observers with the same gate as approval submission (guests never
+      // render the panel). The switch stays interactive mid-run: flipping
+      // it ON releases the in-flight run's gates via the flow's standing
+      // responder (#816).
+      autoApprove: isObserver
+        ? undefined
+        : { armed: flow.autoApproveAll, onChange: flow.setAutoApproveAll },
+      // Transcript export is view-scoped, so observers keep it (#814).
+      sessionId: exportSessionId,
       // Curated audiences see the configuration but cannot strip it — the
       // Config facet renders read-only without mutation callbacks (DD-011).
       mutations: isCurated
@@ -1309,6 +1346,7 @@ function SessionPanelRegion({
     [
       flow.agentRef, flow.isDefaultAgent, flow.mcpServerUsages, flow.skillRefs,
       flow.sessionVariables, flow.harness, flow.executionTarget, flow.model,
+      flow.autoApproveAll, flow.setAutoApproveAll, isObserver, exportSessionId,
       isCurated, handleRemoveAgent, handleRemoveMcp, handleRemoveSkill,
       accessSlot,
     ],

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

@@ -33,6 +33,7 @@ const emptyWorkspace = {
   clear: vi.fn(),
 };
 
+const setAutoApproveAll = vi.fn();
 const stubEmptyFlow = {
   harness: "native" as const,
   setHarness: vi.fn(),
@@ -48,6 +49,8 @@ const stubEmptyFlow = {
   setSkillRefs: vi.fn(),
   workspace: emptyWorkspace,
   sessionVariables: { entries: [], isEmpty: true, clear: vi.fn() },
+  autoApproveAll: false,
+  setAutoApproveAll,
   isSubmitting: false,
   submitError: null,
   submit: vi.fn(),
@@ -125,6 +128,35 @@ describe("NewSessionViewer — persistent panel chip", () => {
   });
 });
 
+describe("NewSessionViewer — auto-approve placement (#816 rework)", () => {
+  const INDICATOR_TEXT = "Auto-approving tool calls for this session";
+
+  it("shows no indicator while auto-approve is off — the launcher stays clean", () => {
+    render(<NewSessionViewer org="acme" onSessionCreated={vi.fn()} />);
+    expect(screen.queryByText(INDICATOR_TEXT)).toBeNull();
+  });
+
+  it("shows the armed-only indicator when a seed pre-arms the session, with Turn off", () => {
+    mockFlow = { ...stubEmptyFlow, autoApproveAll: true };
+    render(<NewSessionViewer org="acme" onSessionCreated={vi.fn()} />);
+
+    expect(screen.getByText(INDICATOR_TEXT)).toBeTruthy();
+    fireEvent.click(screen.getByRole("button", { name: "Turn off" }));
+    expect(setAutoApproveAll).toHaveBeenCalledExactlyOnceWith(false);
+  });
+
+  it("offers the auto-approve switch in the Config facet, wired to the flow", () => {
+    render(<NewSessionViewer org="acme" onSessionCreated={vi.fn()} />);
+
+    fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+    const toggle = screen.getByRole("switch", { name: "Auto-approve" });
+    expect(toggle.getAttribute("aria-checked")).toBe("false");
+
+    fireEvent.click(toggle);
+    expect(setAutoApproveAll).toHaveBeenCalledExactlyOnceWith(true);
+  });
+});
+
 describe("NewSessionViewer — composer stays centered", () => {
   // The composer's wrapper is the probe's parent (wrapper > h1 + composer +
   // footer). `my-auto` is unconditional safe-centering; the old `my-6`

package/src/session/__tests__/SessionViewer-autoApprove.test.tsx

@@ -0,0 +1,244 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
+
+// ---------------------------------------------------------------------------
+// Wiring-contract tests for auto-approve placement (the #816 rework):
+//
+// - The composer carries NO auto-approve control — the session-level switch
+//   lives in the Config facet (SetupTab receives the `autoApprove` group for
+//   every audience that may submit approvals, never observers; guests never
+//   render the panel at all).
+// - The armed-only AutoApproveIndicator above the composer is the
+//   always-visible disclosure: present exactly while the state is armed,
+//   with a one-click "Turn off"; never rendered for observers.
+// ---------------------------------------------------------------------------
+
+type CapturedProps = Record<string, unknown>;
+
+const composerProps: CapturedProps[] = [];
+vi.mock("../../composer", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../composer")>();
+  return {
+    ...actual,
+    SessionComposer: (props: CapturedProps) => {
+      composerProps.push(props);
+      return <div data-testid="composer-probe" />;
+    },
+  };
+});
+
+vi.mock("../../execution/MessageThread", () => ({
+  MessageThread: () => <div data-testid="thread-probe" />,
+}));
+
+vi.mock("../../execution/FileReviewDock", () => ({
+  FileReviewDock: () => <div data-testid="file-review-dock-probe" />,
+}));
+
+// SetupTab renders for real: the facet switch is asserted through its
+// actual DOM (a switch labeled "Auto-approve" in the Run Config section),
+// reached by opening the panel and selecting the Config rail view.
+
+const stubWorkspace = {
+  entries: [],
+  hasEntries: false,
+  toInput: vi.fn().mockReturnValue([]),
+  addGitRepo: vi.fn(),
+  addLocalPath: vi.fn(),
+  removeEntry: vi.fn(),
+  clear: vi.fn(),
+};
+
+const stubConv = {
+  session: { spec: {} } as Record<string, unknown>,
+  isLoading: false,
+  loadError: null,
+  completedExecutions: [],
+  activeStreamExecution: null,
+  activePhase: null,
+  isStreaming: false,
+  isConnecting: false,
+  sendFollowUp: vi.fn(),
+  canSendFollowUp: true,
+  isSending: false,
+  sendError: null,
+  clearSendError: vi.fn(),
+  pendingUserMessage: null,
+  workspaceEntries: [],
+  mcpServerUsages: [],
+  skillRefs: [],
+  pendingApprovals: [],
+  submitApproval: vi.fn(),
+  submittingApprovalIds: new Set<string>(),
+  fileChangeSets: [],
+  submitFileDecision: vi.fn(),
+  submittingFileDecisionKeys: new Set<string>(),
+  fileDecisionErrors: new Map<string, Error>(),
+  streamError: null,
+  reconnectStream: vi.fn(),
+  approvalError: null,
+  retryLastSend: vi.fn(),
+};
+
+const setAutoApproveAll = vi.fn();
+const stubSessionPageFlow = {
+  conv: stubConv,
+  harness: "native" as const,
+  executionTarget: undefined,
+  model: [undefined, vi.fn()] as const,
+  interactionMode: ["agent" as const, vi.fn()] as const,
+  agentRef: { org: "acme", slug: "support-bot" },
+  setAgentRef: vi.fn(),
+  resolution: null,
+  setResolution: vi.fn(),
+  isDefaultAgent: false,
+  mcpServerUsages: [],
+  setMcpServerUsages: vi.fn(),
+  skillRefs: [],
+  setSkillRefs: vi.fn(),
+  workspace: stubWorkspace,
+  sessionVariables: { entries: [], isEmpty: true, clear: vi.fn() },
+  autoApproveAll: false,
+  setAutoApproveAll,
+  submitApproval: vi.fn(),
+  handleSubmit: vi.fn(),
+  submitError: null as Error | null,
+  displayExecution: null,
+  allExecutions: [],
+  sandboxWorkspaceRoot: undefined,
+};
+vi.mock("../useSessionPageFlow", () => ({
+  useSessionPageFlow: () => stubSessionPageFlow,
+}));
+
+vi.mock("../../hooks", () => ({
+  useStigmer: () => ({
+    agentExecution: {
+      uploadAttachment: vi.fn(),
+      getArtifactContent: vi.fn(),
+    },
+  }),
+}));
+
+import { SessionViewer } from "../SessionViewer";
+
+const INDICATOR_TEXT = "Auto-approving tool calls for this session";
+
+function lastComposerProps(): CapturedProps {
+  expect(composerProps.length).toBeGreaterThan(0);
+  return composerProps.at(-1)!;
+}
+
+/** Selects the panel's Config facet (the rail's radio). */
+function openConfigFacet() {
+  fireEvent.click(screen.getByRole("radio", { name: "Config" }));
+}
+
+function facetSwitch(): HTMLElement | null {
+  return screen.queryByRole("switch", { name: "Auto-approve" });
+}
+
+beforeEach(() => {
+  composerProps.length = 0;
+  stubConv.session = { spec: {} };
+  stubSessionPageFlow.autoApproveAll = false;
+});
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe("SessionViewer — composer stays clean (#816 rework)", () => {
+  it("hands the composer no auto-approve control at all", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    expect("autoApprove" in lastComposerProps()).toBe(false);
+  });
+});
+
+describe("SessionViewer — Config facet auto-approve switch (#816 rework)", () => {
+  it("renders the switch reflecting the flow state, and flipping calls the flow (integrator)", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" defaultPanelOpen />);
+    openConfigFacet();
+
+    const toggle = facetSwitch();
+    expect(toggle).not.toBeNull();
+    expect(toggle!.getAttribute("aria-checked")).toBe("false");
+    fireEvent.click(toggle!);
+    expect(setAutoApproveAll).toHaveBeenCalledExactlyOnceWith(true);
+  });
+
+  it("mirrors an armed flow state into the switch", () => {
+    stubSessionPageFlow.autoApproveAll = true;
+    render(<SessionViewer sessionId="ses_1" org="acme" defaultPanelOpen />);
+    openConfigFacet();
+
+    expect(facetSwitch()!.getAttribute("aria-checked")).toBe("true");
+  });
+
+  it("endUser gets the switch — the walk-away persona is an end user", () => {
+    render(
+      <SessionViewer
+        sessionId="ses_1"
+        org="acme"
+        audience="endUser"
+        defaultPanelOpen
+      />,
+    );
+    openConfigFacet();
+
+    expect(facetSwitch()).not.toBeNull();
+  });
+
+  it("observers never get the switch — the approval-submission withhold", () => {
+    render(
+      <SessionViewer
+        sessionId="ses_1"
+        org="acme"
+        audience="observer"
+        defaultPanelOpen
+      />,
+    );
+    openConfigFacet();
+
+    expect(facetSwitch()).toBeNull();
+  });
+
+  it("channel-origin sessions never get the switch (observer by construction)", () => {
+    stubConv.session = {
+      spec: {},
+      metadata: { labels: { "stigmer.ai/channel-id": "chn_1" } },
+    };
+    render(<SessionViewer sessionId="ses_1" org="acme" defaultPanelOpen />);
+    openConfigFacet();
+
+    expect(facetSwitch()).toBeNull();
+  });
+});
+
+describe("SessionViewer — armed-only indicator (#816 rework)", () => {
+  it("absent while auto-approve is off — the composer stays clean", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    expect(screen.queryByText(INDICATOR_TEXT)).toBeNull();
+  });
+
+  it("renders while armed, and Turn off flips the flow state", () => {
+    stubSessionPageFlow.autoApproveAll = true;
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    expect(screen.getByText(INDICATOR_TEXT)).toBeTruthy();
+    fireEvent.click(screen.getByRole("button", { name: "Turn off" }));
+    expect(setAutoApproveAll).toHaveBeenCalledExactlyOnceWith(false);
+  });
+
+  it("never renders for observers — they cannot arm or disarm anything", () => {
+    stubSessionPageFlow.autoApproveAll = true;
+    render(
+      <SessionViewer sessionId="ses_1" org="acme" audience="observer" />,
+    );
+
+    expect(screen.queryByText(INDICATOR_TEXT)).toBeNull();
+  });
+});