@genesislcap/ai-assistant 15.60.0 → 15.62.0

package/sandbox/autopilot.ts

@@ -0,0 +1,358 @@
+/**
+ * The autopilot UI in the sandbox (GENC-1660, Part 1 UI track). See `README.md`, "Checking the
+ * autopilot UI".
+ *
+ * Two halves, both driving the element through its ordinary inputs:
+ *
+ * - `SandboxAutopilotHost` stands in for `AutopilotDriver` behind the slim bar, the banner and the
+ *   badge. Its buttons really move it: Pause pauses, Resume resumes, Keep paused keeps it paused.
+ * - The demo widget (`sandbox-confirm`) is a real registered widget with a DOM-free controller,
+ *   opened through the driver's `presentInteraction` and claimed by a real interceptor, so `heldBy`
+ *   moves through a real `InteractionHold` and the element decides what to show for itself.
+ */
+import type { ChatMessage } from '@genesislcap/foundation-ai';
+import { customElement, GenesisElement, html, observable, when } from '@genesislcap/web-core';
+import type { AutopilotHost, AutopilotHostState } from '../src/autopilot/autopilot-driver';
+import type { AiDriver } from '../src/components/ai-driver/ai-driver';
+import type { AutopilotCopy } from '../src/config/config';
+import { registerInteraction } from '../src/state/interaction-registry';
+import type { AiChatInteraction } from '../src/types/ai-chat-widget';
+import type { InteractionContext } from '../src/types/interaction-context';
+import type { InteractionHold } from '../src/types/interaction-interceptor';
+
+// ─── The stub host ───────────────────────────────────────────────────────────
+
+/** What the panel sets. `off` is no autopilot at all: the element shows exactly what it does today. */
+export type SandboxAutopilotMode = 'off' | 'running' | 'paused' | 'self-paused';
+
+const COPY: AutopilotCopy = {
+  running: 'Building from your plan…',
+  paused: 'Paused',
+  selfPaused: "Waiting for your answer: I'll carry on after this",
+  handBackLead: 'I need your input on this one:',
+  toggleLabel: 'Autopilot',
+  description: "Answers the assistant's questions on your behalf, so the work keeps going.",
+  pauseLabel: 'Pause autopilot',
+  resumeLabel: 'Resume autopilot',
+  resumeDecideLabel: 'Resume autopilot and force it to decide this one',
+  keepPausedLabel: 'Keep paused',
+  markLabel: 'Done in autopilot mode',
+  checkInMessage: "I've done a lot in one go, so I've stopped to check in. Shall I carry on?",
+  carryOnLabel: 'Carry on',
+  tooLongMessage: 'This conversation has grown too long for me to carry on as it is.',
+  compactLabel: 'Compact and carry on',
+  failedMessage: 'Something went wrong on that last step.',
+  tryAgainLabel: 'Try again',
+  sendLabel: 'Send',
+  budgetReason: 'This one is taking more working out than I expected, so over to you.',
+  errorReason: 'Something went wrong while I was deciding this one.',
+  noDecisionReason: "I couldn't settle this one.",
+  watchdogReason: 'This is taking longer than expected, so I need you to look at it.',
+};
+
+const HAND_BACK_REASON = "your brief doesn't say whether quantities can be decimals.";
+
+/**
+ * An `AutopilotHost` whose mode the panel sets and whose buttons move it, as the real one's do.
+ * `onChange` tells the panel, so its controls follow a click on the slim bar.
+ */
+export class SandboxAutopilotHost implements AutopilotHost {
+  readonly copy = COPY;
+  private readonly listeners = new Set<() => void>();
+
+  constructor(
+    private mode: SandboxAutopilotMode,
+    private status: string,
+    private needsUser: boolean,
+    /** The pending demo widget's id, which a self-pause hands back. */
+    private interactionId: () => string | undefined,
+    private readonly onChange: (mode: SandboxAutopilotMode) => void,
+    /**
+     * Whether something is happening, as the real driver reports it: derived by the panel from the
+     * simulated state and the demo widget. Running and idle, the composer comes back.
+     */
+    private readonly working: () => boolean,
+  ) {}
+
+  get state(): AutopilotHostState {
+    const selfPaused = this.mode === 'self-paused';
+    // A self-pause is the autopilot's own, for one interaction: it is still running.
+    const mode = (
+      {
+        off: 'unavailable',
+        running: 'running',
+        paused: 'paused',
+        'self-paused': 'running',
+      } as const
+    )[this.mode];
+    const status =
+      this.status ||
+      (selfPaused ? COPY.selfPaused : this.mode === 'running' ? COPY.running : COPY.paused);
+    return {
+      mode,
+      ...(selfPaused
+        ? {
+            pause: {
+              scope: 'this-interaction' as const,
+              interactionId: this.interactionId(),
+              reason: HAND_BACK_REASON,
+            },
+          }
+        : this.mode === 'paused'
+          ? { pause: { scope: 'until-resumed' as const } }
+          : {}),
+      status: this.mode === 'off' ? '' : status,
+      needsUser: this.needsUser || selfPaused,
+      working: this.mode !== 'off' && this.working(),
+    };
+  }
+
+  /** The panel moved: take its values and tell the element. */
+  update(mode: SandboxAutopilotMode, status: string, needsUser: boolean): void {
+    this.mode = mode;
+    this.status = status;
+    this.needsUser = needsUser;
+    this.notify();
+  }
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  pause(): void {
+    this.move('paused');
+  }
+
+  resume(): void {
+    this.move('running');
+  }
+
+  stop(): void {
+    this.move('paused');
+  }
+
+  keepPaused(): void {
+    this.move('paused');
+  }
+
+  private move(mode: SandboxAutopilotMode): void {
+    if (this.mode === 'off') return;
+    this.mode = mode;
+    this.onChange(mode);
+    this.notify();
+  }
+
+  notify(): void {
+    for (const fn of this.listeners) fn();
+  }
+}
+
+// ─── The demo widget: Appendix A's confirm button ────────────────────────────
+
+export const DEMO_WIDGET = 'sandbox-confirm';
+
+interface ConfirmData {
+  question: string;
+  label: string;
+}
+
+/** DOM-free: the button and a claimant both reach `press()`. */
+class ConfirmController {
+  constructor(
+    readonly data: ConfirmData,
+    private readonly ctx: InteractionContext,
+  ) {
+    ctx.exposeDecision({ options: [data.label], choose: () => this.press() });
+  }
+
+  press(): void {
+    this.ctx.resolve({ status: 'approved', payload: { pressed: true } });
+  }
+}
+
+/** Register the demo widget, with how it behaves while a claimant holds it. */
+export const registerDemoWidget = (whileAutopilot: 'visible' | 'hidden'): void => {
+  registerInteraction(DEMO_WIDGET, {
+    controller: (data, ctx) => new ConfirmController(data as ConfirmData, ctx),
+    whileAutopilot,
+    asText: (data, result) => {
+      const d = data as ConfirmData;
+      return result ? `${d.question} → ${d.label}` : d.question;
+    },
+  });
+};
+
+const template = html<SandboxConfirm>`
+  <p class="question">${(x) => x.data?.question}</p>
+  ${when(
+    (x) => x.interaction?.status === 'resolved',
+    html<SandboxConfirm>`
+      <span>✓ ${(x) => x.data?.label}</span>
+    `,
+  )}
+  ${when(
+    (x) => x.interaction?.status === 'pending',
+    html<SandboxConfirm>`
+      <rapid-button
+        appearance="accent"
+        ?hidden=${(x) => x.claimantOwns}
+        @click=${(x) => {
+          x.controller?.press();
+          return true;
+        }}
+      >
+        ${(x) => x.data?.label}
+      </rapid-button>
+      ${when(
+        (x) => x.claimantOwns,
+        html<SandboxConfirm>`
+          <small class="held">Held by ${(x) => x.heldBy}: its button is the claimant's.</small>
+        `,
+      )}
+    `,
+  )}
+`;
+
+/**
+ * The view. It renders from `heldBy` (through `claimantOwns`, so a button the controller did not
+ * expose is never hidden) and calls the controller; it never resolves anything itself.
+ */
+@customElement({
+  name: DEMO_WIDGET,
+  template,
+  styles: `
+    :host { display: block; }
+    .question { margin: 0 0 8px; }
+    .held { display: block; opacity: 0.7; font-style: italic; }
+  `,
+})
+export class SandboxConfirm extends GenesisElement {
+  interactionId = '';
+  @observable interaction?: AiChatInteraction<ConfirmData>;
+  @observable heldBy = 'user';
+  @observable claimantOwns = false;
+  private unsubscribe?: () => void;
+
+  get data(): ConfirmData | undefined {
+    return this.interaction?.data;
+  }
+
+  get controller(): ConfirmController | undefined {
+    return this.interaction?.status === 'pending'
+      ? (this.interaction.interactionContext.controller as ConfirmController)
+      : undefined;
+  }
+
+  interactionChanged(): void {
+    this.unsubscribe?.();
+    this.unsubscribe = undefined;
+    if (this.interaction?.status !== 'pending') return;
+    const ctx = this.interaction.interactionContext;
+    const read = () => {
+      this.heldBy = ctx.heldBy;
+      this.claimantOwns = ctx.claimantOwns(this.data?.label ?? '');
+    };
+    read();
+    this.unsubscribe = ctx.subscribe(read);
+  }
+
+  disconnectedCallback(): void {
+    this.unsubscribe?.();
+    super.disconnectedCallback();
+  }
+}
+
+// ─── Claiming it through a real interceptor ──────────────────────────────────
+
+/** The id the sandbox's interceptor claims under: the same one the real autopilot uses. */
+const CLAIMANT = 'autopilot';
+
+/**
+ * Install an interceptor on `driver` that claims the demo widget when `claim()` says so, and keeps
+ * its hold so the panel can hand it to the person and back. Returns the remover and the hold.
+ */
+export const installDemoClaimant = (
+  driver: AiDriver,
+  claim: () => boolean,
+  /** Told when the demo widget opens or closes, as the real autopilot notifies its host. */
+  onChange: () => void,
+): {
+  remove: () => void;
+  hold: () => InteractionHold | undefined;
+  pendingId: () => string | undefined;
+} => {
+  let hold: InteractionHold | undefined;
+  let pendingId: string | undefined;
+  const remove =
+    driver.addInteractionInterceptor?.({
+      id: CLAIMANT,
+      onInteractionOpened: (opened) => {
+        if (opened.componentName !== DEMO_WIDGET) return undefined;
+        hold = opened.hold;
+        pendingId = opened.interactionId;
+        opened.ctx.onDispose(() => {
+          if (pendingId === opened.interactionId) {
+            hold = undefined;
+            pendingId = undefined;
+            onChange();
+          }
+        });
+        // After the claim lands, so the host reads the widget's id and holder as they now are.
+        queueMicrotask(onChange);
+        return claim() ? 'claim' : undefined;
+      },
+    }) ?? (() => undefined);
+  return { remove, hold: () => hold, pendingId: () => pendingId };
+};
+
+/** Open the demo widget, as a working agent's tool would ask. */
+export const openDemoWidget = (driver: AiDriver): void => {
+  void driver
+    .presentInteraction?.(DEMO_WIDGET, { question: 'Deploy the app now?', label: 'Deploy' })
+    .catch(() => undefined);
+};
+
+// ─── Delegated messages, for the Transcript seed ─────────────────────────────
+
+/**
+ * Each kind of delegated message: narration before a widget the autopilot answered, the "I chose"
+ * echo, and a written answer given on the user's behalf. All render as the assistant, with the mark.
+ * Unstamped: the fixtures stamp it like every other seed.
+ */
+export const autopilotTranscript = (): ChatMessage[] => [
+  { role: 'user', content: 'Build me a trade blotter from my plan.' },
+  {
+    role: 'assistant',
+    content: "Your brief has no external feeds, so I'll skip Data Feeds.",
+    delegate: 'autopilot',
+    excludeFromProvider: true,
+  },
+  {
+    role: 'assistant',
+    content: '',
+    interaction: {
+      interactionId: 'sandbox-answered',
+      componentName: DEMO_WIDGET,
+      data: { question: 'Add data feeds?', label: 'No, skip this step' },
+      resolved: { status: 'approved', payload: { pressed: true } },
+      answeredBy: 'autopilot',
+    },
+  },
+  {
+    role: 'assistant',
+    content: 'I chose: Approve trade, Reject trade',
+    delegate: 'autopilot',
+    excludeFromProvider: true,
+  },
+  { role: 'assistant', content: 'Which currency should notional amounts use?' },
+  {
+    role: 'user',
+    content: 'GBP — the brief prices everything in sterling.',
+    delegate: 'autopilot',
+    delegateFraming: "(Answered on the user's behalf, from their brief.)",
+  },
+  { role: 'assistant', content: 'Using GBP for every notional field.' },
+];

package/sandbox/controls.ts

@@ -59,6 +59,28 @@ const el = <K extends keyof HTMLElementTagNameMap>(
   return node;
 };
 
+/**
+ * Which groups are open, by title, so a reload keeps the panel as it was left. Separate from the
+ * sandbox state: it is panel chrome, not something the assistant is driven by.
+ */
+export const GROUPS_OPEN_KEY = 'ai-assistant-sandbox:groups-open';
+
+const readGroupsOpen = (): Record<string, boolean> => {
+  try {
+    return JSON.parse(localStorage.getItem(GROUPS_OPEN_KEY) ?? '{}') ?? {};
+  } catch {
+    return {};
+  }
+};
+
+const writeGroupOpen = (title: string, open: boolean): void => {
+  try {
+    localStorage.setItem(GROUPS_OPEN_KEY, JSON.stringify({ ...readGroupsOpen(), [title]: open }));
+  } catch {
+    // Storage unavailable: the panel still works, it just forgets.
+  }
+};
+
 const withHint = (row: HTMLElement, hint?: string): HTMLElement => {
   if (hint) {
     const small = el('small', 'hint');
@@ -98,7 +120,8 @@ export function renderControls<S extends Record<string, any>>(
 
   for (const group of groups) {
     const details = el('details', 'group');
-    details.open = group.open ?? true;
+    details.open = readGroupsOpen()[group.title] ?? group.open ?? true;
+    details.addEventListener('toggle', () => writeGroupOpen(group.title, details.open));
     const summary = el('summary');
     summary.textContent = group.title;
     details.appendChild(summary);

package/sandbox/fixtures.ts

@@ -11,6 +11,7 @@ import type {
   ChatRequestOptions,
 } from '@genesislcap/foundation-ai';
 import type { AgentConfig } from '../src/config/config';
+import { autopilotTranscript } from './autopilot';
 
 /** The stub ignores it; it exists only to keep the driver's warning out of the console. */
 const STUB_PROMPT = 'Sandbox stub. Replies are canned.';
@@ -328,6 +329,7 @@ export const TRANSCRIPTS = {
   huge: HUGE,
   loop: LOOP,
   wall: WALL,
+  autopilot: stamped(autopilotTranscript()),
 } as const;
 
 export type TranscriptName = keyof typeof TRANSCRIPTS;

package/sandbox/sandbox.ts

@@ -14,7 +14,14 @@ import type { FoundationAiAssistant } from '../src/main/main';
 import type { PopoutMode } from '../src/main/main.types';
 import { WebStorageSessionProvider } from '../src/state/persistence';
 import { estimateContextTokens } from '../src/utils/context-tokens';
-import { renderControls, type ControlGroup } from './controls';
+import {
+  installDemoClaimant,
+  openDemoWidget,
+  registerDemoWidget,
+  SandboxAutopilotHost,
+  type SandboxAutopilotMode,
+} from './autopilot';
+import { GROUPS_OPEN_KEY, renderControls, type ControlGroup } from './controls';
 import {
   buildAgents,
   buildAttachmentChips,
@@ -151,6 +158,15 @@ interface SandboxState {
   budgetMeter: 'off' | 'single' | 'segmented' | 'segmented-remainder';
   // Simulated runtime
   runtime: 'idle' | 'loading' | 'cancelling' | 'blocked' | 'compacting' | 'restoring';
+  // Autopilot (GENC-1660)
+  autopilotMode: SandboxAutopilotMode;
+  autopilotHidesComposer: boolean;
+  autopilotStatus: string;
+  autopilotNeedsUser: boolean;
+  demoHeldBy: 'user' | 'autopilot';
+  demoWhileAutopilot: 'visible' | 'hidden';
+  delegateMarker: 'subtle' | 'none';
+  showBubble: boolean;
   transcript: TranscriptName;
   transcriptAge: TranscriptAge;
   // Stage
@@ -198,6 +214,14 @@ const DEFAULT_STATE: SandboxState = {
   flowInProgress: false,
   budgetMeter: 'off',
   runtime: 'idle',
+  autopilotMode: 'off',
+  autopilotHidesComposer: true,
+  autopilotStatus: '',
+  autopilotNeedsUser: false,
+  demoHeldBy: 'autopilot',
+  demoWhileAutopilot: 'hidden',
+  delegateMarker: 'subtle',
+  showBubble: false,
   transcript: 'rich',
   transcriptAge: 'fresh',
   width: 480,
@@ -353,6 +377,7 @@ const buildChatConfig = (s: SandboxState): ChatConfig => ({
     // `undefined` disables the feature outright (no cog control, nothing enabled);
     // `userConfigurable` turns the defaults on and adds the multiselect to the cog.
     animations: s.animations ? { userConfigurable: true } : undefined,
+    delegatedMessages: { marker: s.delegateMarker },
     messageFeedback:
       s.messageFeedback === 'off'
         ? undefined
@@ -550,6 +575,78 @@ const applyRuntime = (s: SandboxState): void => {
   assistant.showLoadingIndicator = s.runtime === 'loading' || s.runtime === 'cancelling';
 };
 
+// ─── Autopilot (GENC-1660) ───────────────────────────────────────────────────
+//
+// The stub host goes on as `autopilotHostOverride`, the element's ordinary input for one; the demo
+// widget is claimed by a real interceptor on the element's own driver. See `autopilot.ts`.
+
+let autopilotHost: SandboxAutopilotHost | undefined;
+let demoClaimant: ReturnType<typeof installDemoClaimant> | undefined;
+let demoDriver: unknown;
+let demoRegisteredAs: string | undefined;
+let bubble: HTMLElement | undefined;
+
+/** The id a per-call override is filed under, as an agent's tool would file its own. */
+const SANDBOX_OVERRIDE = 'sandbox-autopilot';
+
+const applyAutopilot = (s: SandboxState): void => {
+  if (demoRegisteredAs !== s.demoWhileAutopilot) {
+    registerDemoWidget(s.demoWhileAutopilot);
+    demoRegisteredAs = s.demoWhileAutopilot;
+  }
+  autopilotHost ??= new SandboxAutopilotHost(
+    s.autopilotMode,
+    s.autopilotStatus,
+    s.autopilotNeedsUser,
+    () => demoClaimant?.pendingId(),
+    // A click on the slim bar or the banner moves the panel too.
+    (mode) => {
+      state.autopilotMode = mode;
+      saveState(state);
+      refreshReadouts();
+    },
+    // Working, as the real driver says it: the simulated state is Busy, or the demo widget is open
+    // and the autopilot holds it (deciding it).
+    () =>
+      state.runtime === 'loading' ||
+      state.runtime === 'cancelling' ||
+      (state.demoHeldBy === 'autopilot' && !!demoClaimant?.pendingId()),
+  );
+  autopilotHost.update(s.autopilotMode, s.autopilotStatus, s.autopilotNeedsUser);
+  const host = s.autopilotMode === 'off' ? undefined : autopilotHost;
+  if (assistant.autopilotHostOverride !== host) assistant.autopilotHostOverride = host;
+
+  // The agent's own rule hiding the composer while it works — bootstrap's
+  // `chatInputDuringExecution: 'hidden'` — as the per-call override a tool would file.
+  const actions = (assistant as any)._sessionRef?.actions.aiAssistant;
+  actions?.removeInputOverride({ id: SANDBOX_OVERRIDE });
+  if (s.autopilotHidesComposer) actions?.addInputOverride({ id: SANDBOX_OVERRIDE, mode: 'hidden' });
+
+  // Re-installed whenever the element's driver changes (a remount, or new agents).
+  const driver = (assistant as any).driver;
+  if (driver !== demoDriver) {
+    demoClaimant?.remove();
+    demoClaimant = driver
+      ? installDemoClaimant(
+          driver,
+          () => state.demoHeldBy === 'autopilot',
+          () => autopilotHost?.notify(),
+        )
+      : undefined;
+    demoDriver = driver;
+  }
+  demoClaimant?.hold()?.set(s.demoHeldBy === 'autopilot' ? 'claimant' : 'user');
+
+  // The collapsed assistant, for the "needs you" badge.
+  if (s.showBubble && !bubble) {
+    bubble = document.createElement('foundation-ai-chat-bubble');
+    document.body.appendChild(bubble);
+  } else if (!s.showBubble && bubble) {
+    bubble.remove();
+    bubble = undefined;
+  }
+};
+
 // FAST's `baseLayerLuminance` drives the whole neutral ramp. These are
 // `StandardLuminance.LightMode` / `DarkMode` from `@microsoft/fast-components`,
 // inlined so the sandbox doesn't reach past the design system for two numbers.
@@ -610,6 +707,7 @@ function apply(): void {
   applyContext(state);
   applyBudgetMeter(state);
   applyRuntime(state);
+  applyAutopilot(state);
   applyGradientSend(state.gradientSend);
   applyDivider(state.showDivider);
   assistant.attachments = buildAttachmentChips(state.chips);
@@ -910,6 +1008,93 @@ const GROUPS: ReadonlyArray<ControlGroup<SandboxState>> = [
       },
     ],
   },
+  {
+    title: 'Autopilot',
+    open: false,
+    controls: [
+      {
+        kind: 'select',
+        key: 'autopilotMode',
+        label: 'Mode',
+        featured: true,
+        hint: 'Unavailable is the UI as it is today. Self-paused hands the demo widget back, with its banner.',
+        options: [
+          { value: 'off', label: 'Unavailable (no autopilot)' },
+          { value: 'running', label: 'Running' },
+          { value: 'paused', label: 'Paused' },
+          { value: 'self-paused', label: 'Self-paused (handed one back)' },
+        ],
+      },
+      {
+        kind: 'toggle',
+        key: 'autopilotHidesComposer',
+        label: 'Agent hides the composer while working',
+        hint: "Bootstrap's chatInputDuringExecution: 'hidden'. Only while busy: set Simulated state to Busy. Paused then shows the slim bar; off, it shows the composer with the Autopilot pill.",
+      },
+      {
+        kind: 'text',
+        key: 'autopilotStatus',
+        label: 'Status text',
+        placeholder: 'From the copy',
+      },
+      {
+        kind: 'toggle',
+        key: 'autopilotNeedsUser',
+        label: 'Needs you',
+        hint: 'Drives the badge on the collapsed bubble.',
+      },
+      {
+        kind: 'toggle',
+        key: 'showBubble',
+        label: 'Show the collapsed bubble',
+        hint: 'The floating orb, bottom right, where the badge appears.',
+      },
+      {
+        kind: 'action',
+        label: 'Open the demo widget',
+        hint: 'A confirm button with a controller, as a tool would ask. One at a time.',
+        run: () => openDemoWidget((assistant as any).driver),
+      },
+      {
+        kind: 'select',
+        key: 'demoHeldBy',
+        label: 'Demo widget held by',
+        hint: 'Moved through the real hold, so the element decides what to show.',
+        options: [
+          { value: 'autopilot', label: 'The autopilot' },
+          { value: 'user', label: 'The person' },
+        ],
+      },
+      {
+        kind: 'select',
+        key: 'demoWhileAutopilot',
+        label: 'Demo widget while held',
+        hint: 'Its registration: hidden drops the whole bubble, visible hides only its button.',
+        options: [
+          { value: 'hidden', label: 'Hidden' },
+          { value: 'visible', label: 'Visible' },
+        ],
+      },
+      {
+        kind: 'select',
+        key: 'delegateMarker',
+        label: 'Delegated mark',
+        hint: 'Seed the Autopilot transcript to see each kind of delegated message.',
+        options: [
+          { value: 'subtle', label: 'Subtle' },
+          { value: 'none', label: 'None' },
+        ],
+      },
+      {
+        kind: 'readout',
+        label: 'Element',
+        render: () =>
+          assistant
+            ? `held by ${assistant.activeHeldBy} · halo ${assistant.showHalo} · slim bar ${assistant.slimBarVisible ? 'on' : 'off'}`
+            : '—',
+      },
+    ],
+  },
   {
     title: 'Transcript',
     controls: [
@@ -922,6 +1107,7 @@ const GROUPS: ReadonlyArray<ControlGroup<SandboxState>> = [
           { value: 'short', label: 'Short' },
           { value: 'rich', label: 'Tools, markdown, agent switch' },
           { value: 'long', label: 'Long (28 turns)' },
+          { value: 'autopilot', label: 'Autopilot: delegated messages' },
           { value: 'huge', label: 'Huge (~20k tokens)' },
           { value: 'loop', label: 'Tool loop (~22k, no user turns inside)' },
           { value: 'wall', label: 'Wall (~24k in one indivisible tool result)' },
@@ -1040,6 +1226,7 @@ const GROUPS: ReadonlyArray<ControlGroup<SandboxState>> = [
         label: 'Reset sandbox',
         run: () => {
           localStorage.removeItem(STORAGE_KEY);
+          localStorage.removeItem(GROUPS_OPEN_KEY);
           sessionStorage.clear();
           location.reload();
         },