@stigmer/react 3.12.6 → 3.12.8

package/src/memory/useRejectMemory.ts

@@ -0,0 +1,65 @@
+"use client";
+
+import { useCallback, useState } from "react";
+import type { Memory } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/api_pb";
+import { useStigmer } from "../hooks.js";
+import { toError } from "../internal/toError.js";
+
+/** Return value of {@link useRejectMemory}. */
+export interface UseRejectMemoryReturn {
+  /** Reject a proposed memory by its resource ID. Resolves with the rejected record. */
+  readonly rejectMemory: (id: string) => Promise<Memory>;
+  /** `true` while the reject request is in flight. */
+  readonly isRejecting: boolean;
+  /** Error from the last failed reject, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Reset `error` to `null`. */
+  readonly clearError: () => void;
+}
+
+/**
+ * Behavior hook that wraps `memory.reject()`. A rejected memory is never
+ * recalled; the record is kept as an audit trail until deleted.
+ *
+ * Rejecting an already-rejected memory succeeds and changes nothing.
+ * Rejecting a confirmed memory fails with FAILED_PRECONDITION —
+ * deleting a confirmed memory is how it is revoked.
+ *
+ * Rejection is deliberately one click on every surface, with no
+ * confirmation dialog (DD-005 D4): expensive review teaches users to
+ * ignore the proposal queue.
+ *
+ * @example
+ * ```tsx
+ * const { rejectMemory, isRejecting } = useRejectMemory();
+ *
+ * await rejectMemory(memory.metadata?.id ?? "");
+ * refetch(); // refresh the list after the decision
+ * ```
+ */
+export function useRejectMemory(): UseRejectMemoryReturn {
+  const stigmer = useStigmer();
+  const [isRejecting, setIsRejecting] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const clearError = useCallback(() => setError(null), []);
+
+  const rejectMemory = useCallback(
+    async (id: string): Promise<Memory> => {
+      setIsRejecting(true);
+      setError(null);
+
+      try {
+        return await stigmer.memory.reject(id);
+      } catch (err) {
+        setError(toError(err));
+        throw err;
+      } finally {
+        setIsRejecting(false);
+      }
+    },
+    [stigmer],
+  );
+
+  return { rejectMemory, isRejecting, error, clearError };
+}

package/src/memory/useUpdateMemoryContent.ts

@@ -0,0 +1,67 @@
+"use client";
+
+import { useCallback, useState } from "react";
+import type { Memory } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/api_pb";
+import { toMemoryUpdateInput } from "@stigmer/sdk";
+import { useStigmer } from "../hooks.js";
+import { toError } from "../internal/toError.js";
+
+/** Return value of {@link useUpdateMemoryContent}. */
+export interface UseUpdateMemoryContentReturn {
+  /** Replace a memory's fact text. Resolves with the updated record. */
+  readonly updateContent: (memory: Memory, content: string) => Promise<Memory>;
+  /** `true` while the update request is in flight. */
+  readonly isUpdating: boolean;
+  /** Error from the last failed update, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Reset `error` to `null`. */
+  readonly clearError: () => void;
+}
+
+/**
+ * Behavior hook that edits a memory's fact text — the one field the
+ * subject owns after capture (DD-004).
+ *
+ * The update RPC replaces the entire spec, so the loaded record is
+ * mapped through the generated `toMemoryUpdateInput` and only `content`
+ * is overridden — the wipe-safe editing rule. Subject and provenance
+ * ride along verbatim (they are update-immutable server-side), and the
+ * consent lifecycle is never touched by updates.
+ *
+ * @example
+ * ```tsx
+ * const { updateContent, isUpdating } = useUpdateMemoryContent();
+ *
+ * await updateContent(memory, editedText);
+ * refetch(); // refresh the list after the edit
+ * ```
+ */
+export function useUpdateMemoryContent(): UseUpdateMemoryContentReturn {
+  const stigmer = useStigmer();
+  const [isUpdating, setIsUpdating] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const clearError = useCallback(() => setError(null), []);
+
+  const updateContent = useCallback(
+    async (memory: Memory, content: string): Promise<Memory> => {
+      setIsUpdating(true);
+      setError(null);
+
+      try {
+        return await stigmer.memory.update({
+          ...toMemoryUpdateInput(memory),
+          content,
+        });
+      } catch (err) {
+        setError(toError(err));
+        throw err;
+      } finally {
+        setIsUpdating(false);
+      }
+    },
+    [stigmer],
+  );
+
+  return { updateContent, isUpdating, error, clearError };
+}

package/src/organization/OrgPreferencesPanel.tsx

@@ -7,6 +7,7 @@ import type { Organization } from "@stigmer/protos/ai/stigmer/tenancy/organizati
 import { useOrganization } from "./useOrganization.js";
 import { useUpdateOrganization } from "./useUpdateOrganization.js";
 import { useCheckPermission } from "../iam-policy/useCheckPermission.js";
+import { MemoryEnabledRow } from "../internal/MemoryEnabledRow.js";
 import { StandingContextField } from "../internal/StandingContextField.js";
 import { SpinnerIcon } from "../internal/SpinnerIcon.js";
 
@@ -60,6 +61,14 @@ export function OrgPreferencesPanel({
     clearError,
   } = useUpdateOrganization();
 
+  // The memory toggle saves instantly (its own hook instance, so a flip's
+  // in-flight/error state never bleeds into the form's Save button).
+  const {
+    update: updateMemoryFlag,
+    isUpdating: isSavingMemoryFlag,
+    error: memoryFlagError,
+  } = useUpdateOrganization();
+
   // Fail-open: OSS local mode has no IAM service, so editing stays
   // available there; cloud gets a genuine server verdict.
   const { allowed: canEdit } = useCheckPermission(
@@ -100,10 +109,16 @@ export function OrgPreferencesPanel({
       clearError();
       try {
         // update() is a full-spec replace: spread the complete mapped input
-        // so unedited spec fields survive, and override only preferences.
+        // so unedited spec fields survive. `preferences` is a nested message,
+        // so the override spreads the mapper's COMPLETE preferences too —
+        // fields this form does not own (memory_enabled) survive the save.
+        const mapped = toOrganizationUpdateInput(organization);
         const updated = await update({
-          ...toOrganizationUpdateInput(organization),
-          preferences: { standingContext: standingContext.trim() || undefined },
+          ...mapped,
+          preferences: {
+            ...mapped.preferences,
+            standingContext: standingContext.trim() || undefined,
+          },
         });
         refetch();
         onUpdated?.(updated);
@@ -114,6 +129,30 @@ export function OrgPreferencesPanel({
     [canSubmit, organization, standingContext, update, clearError, refetch, onUpdated],
   );
 
+  // The memory consent flag applies instantly (the UX-checkpoint decision):
+  // a consent bit flipped-but-unsaved that silently reverts on navigation is
+  // the failure consent UX must not have. Same wipe-safe double spread.
+  const handleMemoryToggle = useCallback(
+    async (next: boolean) => {
+      if (!organization) return;
+      try {
+        const mapped = toOrganizationUpdateInput(organization);
+        const updated = await updateMemoryFlag({
+          ...mapped,
+          preferences: {
+            ...mapped.preferences,
+            memoryEnabled: next || undefined,
+          },
+        });
+        refetch();
+        onUpdated?.(updated);
+      } catch {
+        // error state is managed by the toggle's own hook instance
+      }
+    },
+    [organization, updateMemoryFlag, refetch, onUpdated],
+  );
+
   // -----------------------------------------------------------------------
   // Loading state
   // -----------------------------------------------------------------------
@@ -175,6 +214,16 @@ export function OrgPreferencesPanel({
         helperText="Shared with agents as background context — not instructions. Applies to executions started by signed-in members of this organization and is visible on their execution records."
       />
 
+      <MemoryEnabledRow
+        id={`${baseId}-memory-enabled`}
+        checked={organization.spec?.preferences?.memoryEnabled ?? false}
+        onToggle={(next) => void handleMemoryToggle(next)}
+        saving={isSavingMemoryFlag}
+        readOnly={!canEdit}
+        error={memoryFlagError}
+        helperText="Allow agents to remember confirmed facts about members of this organization. Each member must also turn memory on in their own account preferences. Changes apply immediately."
+      />
+
       {!canEdit && (
         <p className="stg:text-[0.65rem] stg:text-muted-foreground">
           Only organization admins can edit these preferences.

package/src/organization/__tests__/OrgPreferencesPanel.test.tsx

@@ -125,6 +125,71 @@ describe("OrgPreferencesPanel", () => {
     expect(screen.queryByRole("button", { name: "Save changes" })).toBeNull();
   });
 
+  it("memory toggle applies instantly with the full mapped input (wipe-safe)", async () => {
+    const update = vi.fn(async (_input: OrganizationInput) => ORG);
+    renderPanel(createMockStigmer({ update }));
+    await findSyncedField("We deploy to us-east-1.");
+
+    // No Save click: consent applies the moment it is flipped (the
+    // UX-checkpoint decision — a flipped-but-unsaved consent bit that
+    // silently reverts on navigation is the failure this prevents).
+    fireEvent.click(screen.getByRole("switch", { name: "Memory" }));
+
+    await waitFor(() => expect(update).toHaveBeenCalledTimes(1));
+    const input = update.mock.calls[0]![0];
+    expect(input.preferences?.memoryEnabled).toBe(true);
+    // The double spread: the flip must not wipe the sibling preference…
+    expect(input.preferences?.standingContext).toBe("We deploy to us-east-1.");
+    // …nor any profile field this row never renders.
+    expect(input.name).toBe("Acme Corp");
+    expect(input.description).toBe("We make everything.");
+  });
+
+  it("saving standing context preserves memory_enabled (the wipe-hazard regression)", async () => {
+    const orgWithMemoryOn = create(OrganizationSchema, {
+      metadata: { id: "acme", name: "Acme Corp", slug: "acme", org: "acme" },
+      spec: {
+        description: "We make everything.",
+        logoUrl: "https://acme.example/logo.png",
+        preferences: {
+          standingContext: "We deploy to us-east-1.",
+          memoryEnabled: true,
+        },
+      },
+    });
+    const update = vi.fn(async (_input: OrganizationInput) => orgWithMemoryOn);
+    const client = {
+      organization: {
+        get: vi.fn(async () => orgWithMemoryOn),
+        update,
+      },
+      iamPolicy: {
+        checkMyPermission: vi.fn(async () => ({ isAuthorized: true })),
+      },
+    } as never;
+    renderPanel(client);
+
+    const field = await findSyncedField("We deploy to us-east-1.");
+    fireEvent.change(field, { target: { value: "Prefer terse answers." } });
+    fireEvent.click(screen.getByRole("button", { name: "Save changes" }));
+
+    await waitFor(() => expect(update).toHaveBeenCalledTimes(1));
+    // Update is a full-spec replace: without the nested preferences
+    // spread, this save would silently switch the org's memory OFF.
+    expect(update.mock.calls[0]![0].preferences?.memoryEnabled).toBe(true);
+  });
+
+  it("memory toggle is read-only without can_edit", async () => {
+    renderPanel(createMockStigmer({ canEdit: false }));
+    await screen.findByLabelText("Standing context");
+
+    await waitFor(() =>
+      expect(
+        screen.getByRole("switch", { name: "Memory" }).hasAttribute("disabled"),
+      ).toBe(true),
+    );
+  });
+
   it("shows the fetch error with a retry action when loading fails", async () => {
     const client = {
       organization: {

package/src/session/AutoApproveIndicator.tsx

@@ -0,0 +1,45 @@
+"use client";
+
+/**
+ * Armed-only indicator for the session-scoped auto-approve state, docked
+ * above the composer. Renders nothing about approvals until auto-approve is
+ * actually ON — the composer stays clean by default — and while ON it is the
+ * always-visible safety surface: the user can never be silently
+ * auto-approving without seeing this strip and its one-click "Turn off".
+ *
+ * The way ON lives elsewhere (the Config facet's Run Config switch, the
+ * gate-time "Approve & don't ask again", the account's `default_auto_approve`
+ * preference, the host's `approvalDefaults`); this strip is deliberately only
+ * the way OFF plus the disclosure. Shared by `SessionViewer` and
+ * `NewSessionViewer` (DD-016) — a persisted account preference can arm the
+ * launcher before the first message, so both surfaces need the disclosure.
+ */
+export function AutoApproveIndicator({ onTurnOff }: { readonly onTurnOff: () => void }) {
+  return (
+    <div
+      role="status"
+      className="stg:flex stg:items-center stg:gap-2 stg:border-t stg:border-border-muted stg:px-4 stg:py-1.5 stg:text-xs stg:text-muted-foreground"
+    >
+      <ShieldCheckIcon />
+      <span className="stg:min-w-0 stg:flex-1 stg:truncate">
+        Auto-approving tool calls for this session
+      </span>
+      <button
+        type="button"
+        onClick={onTurnOff}
+        className="stg:shrink-0 stg:rounded stg:font-medium stg:text-foreground stg:underline-offset-2 stg:hover:underline stg:focus-visible:outline-none stg:focus-visible:ring-2 stg:focus-visible:ring-ring"
+      >
+        Turn off
+      </button>
+    </div>
+  );
+}
+
+function ShieldCheckIcon() {
+  return (
+    <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className="stg:shrink-0 stg:text-success" aria-hidden="true">
+      <path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z" />
+      <path d="m9 12 2 2 4-4" />
+    </svg>
+  );
+}

package/src/session/NewSessionViewer.tsx

@@ -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";
@@ -374,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
@@ -387,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,
     ],
   );
@@ -461,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

@@ -18,6 +18,7 @@ import {
   type SurfaceVirtualDocument,
 } from "../workspace/WorkspaceSurface.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";
@@ -51,6 +52,8 @@ import { ArtifactDocument } from "../execution/ArtifactDocument.js";
 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 {
@@ -239,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
@@ -293,6 +307,19 @@ export interface SessionViewerProps {
    * unopinionated about Console auth (DD-004).
    */
   readonly headerActions?: ReactNode;
+  /**
+   * 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
+   */
+  readonly transcriptExport?: boolean;
   /**
    * Host-injected access management control (e.g. the Console's
    * `ManageAccessButton` with its own permission gating). Rendered inside
@@ -368,12 +395,14 @@ export function SessionViewer({
   getRuntimeEnv,
   audience = "integrator",
   runConfig,
+  accountDefaults,
   showModelSelector = true,
   panel: panelMode = "auto",
   defaultPanelOpen,
   panelOpen,
   onPanelOpenChange,
   headerActions,
+  transcriptExport = true,
   accessSlot,
   onApplied,
   threadSlots,
@@ -385,6 +414,7 @@ export function SessionViewer({
     getRuntimeEnv,
     audience,
     runConfig,
+    accountDefaults,
   });
   const { conv } = flow;
   const isGuest = audience === "guest";
@@ -650,9 +680,22 @@ export function SessionViewer({
       // 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.
-      headerActions={headerActions}
+      // 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 && !panelEnabled ? (
+          <>
+            {headerActions}
+            <TranscriptExportMenu sessionId={sessionId} />
+          </>
+        ) : (
+          headerActions
+        )
+      }
       chip={
         panelEnabled ? (
           <SessionPanelChip
@@ -720,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
       }
@@ -948,6 +995,10 @@ 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)} />
         )}
@@ -1068,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({
@@ -1091,6 +1153,8 @@ function SessionPanelRegion({
   workspaceFileReader,
   workspaceContentSearcher,
   isCurated,
+  isObserver,
+  exportSessionId,
 }: SessionPanelRegionProps) {
   const { editors, activeKey, activeFile, reveal } = useWorkspaceEditors(
     panel.editorsStore,
@@ -1258,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
@@ -1272,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,
     ],
@@ -1386,36 +1461,6 @@ function SessionStarting() {
   );
 }
 
-/**
- * Low-weight, always-visible indicator shown while the session-scoped
- * auto-approve preference is active. The "Turn off" control reverts the
- * preference in one click — the safety affordance for "Approve & don't ask
- * again". Visible from the first render when the host pre-armed the
- * preference via `StigmerProvider`'s `approvalDefaults` (#302); otherwise
- * nothing about approvals appears until the user opts in at a gate. Either
- * way the user keeps the last word.
- */
-function AutoApproveIndicator({ onTurnOff }: { onTurnOff: () => void }) {
-  return (
-    <div
-      role="status"
-      className="stg:flex stg:items-center stg:gap-2 stg:border-t stg:border-border-muted stg:px-4 stg:py-1.5 stg:text-xs stg:text-muted-foreground"
-    >
-      <ShieldCheckIcon />
-      <span className="stg:min-w-0 stg:flex-1 stg:truncate">
-        Auto-approving tool calls for this session
-      </span>
-      <button
-        type="button"
-        onClick={onTurnOff}
-        className="stg:shrink-0 stg:rounded stg:font-medium stg:text-foreground stg:underline-offset-2 stg:hover:underline stg:focus-visible:outline-none stg:focus-visible:ring-2 stg:focus-visible:ring-ring"
-      >
-        Turn off
-      </button>
-    </div>
-  );
-}
-
 /**
  * The plan document tab's empty state — reachable only when a streaming plan
  * auto-opened the tab and its turn then ended without publishing (stopped or
@@ -1616,11 +1661,3 @@ function LoaderIcon() {
   );
 }
 
-function ShieldCheckIcon() {
-  return (
-    <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className="stg:shrink-0 stg:text-success" aria-hidden="true">
-      <path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z" />
-      <path d="m9 12 2 2 4-4" />
-    </svg>
-  );
-}