windows-development-sandbox 1.13.0 → 1.14.0

package/dist/bin/chunk-LQHEUN2A.js

@@ -0,0 +1,7 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  attach
+} from "./chunk-BQ23GBLC.js";
+export {
+  attach
+};

package/dist/bin/claude-host.js

@@ -1,5 +1,11 @@
 #!/usr/bin/env node
-import { run } from '../cli/index.js';
-const args = process.argv.slice(2);
-const personal = args.includes('--personal') ? ['--personal'] : [];
-run(['host-claude', ...personal, '--', ...args.filter((a) => a !== '--personal')]);
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  run
+} from "./chunk-F7IMME5G.js";
+import "./chunk-BQ23GBLC.js";
+
+// src/bin/claude-host.ts
+var args = process.argv.slice(2);
+var personal = args.includes("--personal") ? ["--personal"] : [];
+run(["host-claude", ...personal, "--", ...args.filter((a) => a !== "--personal")]);

package/dist/bin/claude-sbx.js

@@ -1,3 +1,9 @@
 #!/usr/bin/env node
-import { run } from '../cli/index.js';
-run(process.argv.slice(2), { harness: 'claude' });
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  run
+} from "./chunk-F7IMME5G.js";
+import "./chunk-BQ23GBLC.js";
+
+// src/bin/claude-sbx.ts
+run(process.argv.slice(2), { harness: "claude" });

package/dist/bin/codex-sbx.js

@@ -1,3 +1,9 @@
 #!/usr/bin/env node
-import { run } from '../cli/index.js';
-run(process.argv.slice(2), { harness: 'codex' });
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  run
+} from "./chunk-F7IMME5G.js";
+import "./chunk-BQ23GBLC.js";
+
+// src/bin/codex-sbx.ts
+run(process.argv.slice(2), { harness: "codex" });

package/dist/bin/gemini-sbx.js

@@ -1,3 +1,9 @@
 #!/usr/bin/env node
-import { run } from '../cli/index.js';
-run(process.argv.slice(2), { harness: 'gemini' });
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  run
+} from "./chunk-F7IMME5G.js";
+import "./chunk-BQ23GBLC.js";
+
+// src/bin/gemini-sbx.ts
+run(process.argv.slice(2), { harness: "gemini" });

package/dist/bin/sandbox.js

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
-// sandbox / windows-development-sandbox: the menu with no arguments, any command, or `sandbox <agent>`.
-import { run } from '../cli/index.js';
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  run
+} from "./chunk-F7IMME5G.js";
+import "./chunk-BQ23GBLC.js";
+
+// src/bin/sandbox.ts
 run(process.argv.slice(2));

package/dist/bin/sbx-hide.js

@@ -1,3 +1,9 @@
 #!/usr/bin/env node
-import { run } from '../cli/index.js';
-run(process.argv.slice(2), { command: 'hide' });
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  run
+} from "./chunk-F7IMME5G.js";
+import "./chunk-BQ23GBLC.js";
+
+// src/bin/sbx-hide.ts
+run(process.argv.slice(2), { command: "hide" });

package/dist/bin/sbx-show.js

@@ -1,3 +1,9 @@
 #!/usr/bin/env node
-import { run } from '../cli/index.js';
-run(process.argv.slice(2), { command: 'show' });
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  run
+} from "./chunk-F7IMME5G.js";
+import "./chunk-BQ23GBLC.js";
+
+// src/bin/sbx-show.ts
+run(process.argv.slice(2), { command: "show" });

package/dist/cli/commands/launch/launch.js

@@ -130,7 +130,7 @@ class Launcher {
         const engine = await openEngine(config);
         const provider = providerFor(config, config.storage.contained === 'off'
             ? {}
-            : { contained: realContainedDeps(ctx.storageRoot, config.storage.containedMaxGb) });
+            : { contained: realContainedDeps(ctx.storageRoot, config.storage.containedMaxGb, Boolean(ctx.options.config)) });
         if (!generateOnly)
             assertCanLaunch(isSandboxRunning() ? runningOwner() : undefined);
         // Contained storage: the image is mounted now (before anything reads or writes the data set), and let go of again

package/dist/cli/commands/launch/prepare.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import fs from 'node:fs';
-import { AccountStore } from '../../../host/profile/index.js';
+import { AccountsService } from '../../services/index.js';
 import { SandboxChannel } from '../../../host/channel/index.js';
 import { describePrune, hostDataFolder, pruneStorage } from '../../../host/storage/index.js';
 import { RepoGuardStore, readDataSize, saveMarkedProjects } from '../../../host/guard/index.js';
@@ -73,16 +73,33 @@ async function prepareWorkspaceView(ctx, run) {
         '; ' +
         plan.options.view);
 }
+/**
+ * Every agent that keeps a login starts the new sandbox on its default (the launched agent on --account when given),
+ * so a session of any agent opened later uses the login you chose. Returns the launched agent's login.
+ */
+function launchAccounts(ctx, launched, wanted) {
+    const accounts = new AccountsService(ctx);
+    let account = null;
+    for (const agent of accounts.agents().filter((a) => a.kept)) {
+        if (agent.name === launched) {
+            account = accounts.ensure(launched, wanted);
+            continue;
+        }
+        try {
+            accounts.ensure(agent.name, null);
+        }
+        catch (e) {
+            // Another agent's saved login could not be put in place: the launch goes on, and that agent says so.
+            console.warn(c.yellow('Could not switch ' + agent.name + ' to its default account: ' + errMsg(e)));
+        }
+    }
+    return account;
+}
 /** Everything a real launch does before the sandbox starts (skipped by `generate`, which only writes files). */
 export async function prepare(ctx, run) {
     const { options, dataPath, storageRoot } = ctx;
     const { config } = run;
-    const accounts = new AccountStore(storageRoot, config.claudeProfile.sharePluginsAcrossAccounts);
-    const account = options.account ?? accounts.defaultName();
-    if (account && run.harnessName === 'claude' && account !== accounts.activeFor(dataPath))
-        accounts.activate(dataPath, account);
-    else if (run.harnessName === 'claude')
-        accounts.syncPlugins(dataPath);
+    const account = launchAccounts(ctx, run.harnessName, options.account ?? null);
     const terminal = config.provisioning.terminal.enabled
         ? await ensureTerminal(dataPath, config.provisioning.refresh, { pwsh: config.toolchains.pwsh.enabled !== false })
         : { exe: null, message: 'disabled' };

package/dist/cli/commands/launch/running.js

@@ -6,6 +6,7 @@ import { NeedsRestart } from '../../../host/projects/index.js';
 import { RunDir } from '../../../shared/channel/index.js';
 import { errMsg, fail, sleep } from '../../../core/util/index.js';
 import { c, follow, working, table } from '../../output/index.js';
+import { AccountsService } from '../../services/index.js';
 import { bootLine, readyIn, stillWorking } from './boot-progress.js';
 import { hereDir, joinHere, readyHere, offerRestart } from '../projects/index.js';
 /** How long a session may take to start (its project's setup, the agent's install). */
@@ -65,6 +66,9 @@ export function waitForStart(ctx, requestId, what) {
 /** Asks the sandbox for a session; the agent's definition goes along (the sandbox may have booted with another). */
 function requestSession(ctx, channel, harness, args, joined) {
     const harnessSpec = ctx.loaded.config.harnesses[harness];
+    // --account into a running sandbox switches its login first (sessions already running switch on their restart).
+    if (ctx.options.account && !ctx.borrowed)
+        new AccountsService(ctx).ensure(harness, ctx.options.account);
     return channel.requestSession(harness, args, joined.guestDir, {
         ...(joined.spec ? { project: joined.spec } : {}),
         ...(harnessSpec ? { harnessSpec } : {}),

package/dist/cli/commands/repair/checks/contained.js

@@ -10,7 +10,7 @@ import { containedAvailability, ContainedStorage, containedPaths } from '../../.
 import { ok } from './common.js';
 function storageOf(env) {
     const { config } = env.ctx.loaded;
-    return new ContainedStorage(realContainedDeps(env.storageRoot, config.storage.containedMaxGb), config.storage.dataName);
+    return new ContainedStorage(realContainedDeps(env.storageRoot, config.storage.containedMaxGb, Boolean(env.ctx.options.config)), config.storage.dataName);
 }
 /** Only when contained storage is on, or an image or a record of one exists. */
 const inUse = (env) => {

package/dist/cli/commands/storage/offer.js

@@ -88,7 +88,7 @@ export async function storageBeforeCommand(ctx, command) {
     ensureStorageRoot(ctx.storageRoot, protectPrivateFolder);
     // Contained storage (beta): a mount an earlier sandbox left behind is only mentioned here; repair fixes it.
     if (command !== 'launch' && !ctx.options.json) {
-        const stale = staleMountNote(ctx.storageRoot, ctx.loaded.config.storage.dataName, isSandboxRunning());
+        const stale = staleMountNote(ctx.storageRoot, ctx.loaded.config.storage.dataName, isSandboxRunning);
         if (stale)
             console.error(c.yellow(stale));
     }

package/dist/cli/menu/live.d.ts

@@ -5,20 +5,49 @@ export interface LiveOptions {
     readonly derive: () => string;
     /** The line changed: draw again. */
     readonly onChange: () => void;
+    /** How often the line is derived again (and the shortest gap between two process lists). */
     readonly intervalMs?: number;
+    /** The longest gap between two process lists while no sandbox runs and nobody presses a key. */
+    readonly idleMaxMs?: number;
+    /** Whether a process still runs (default: a signal-0 check, which starts no program). */
+    readonly alive?: (pid: number) => boolean;
+    /** Whether the process list is needed (default: not inside a sandbox, where "is it running?" is always yes). */
+    readonly needsList?: () => boolean;
+    /**
+     * A cheap fingerprint of what a sandbox start changes (the data folder's run folder): while none runs, a change
+     * fetches the list at the next tick instead of after the idle gap.
+     */
+    readonly signal?: () => string;
 }
+/** The gap before the next process list after `unchanged` lists in a row found the same: doubling, up to `max`. */
+export declare function listGap(unchanged: number, base: number, max: number): number;
 export declare class LiveStatus {
     private readonly o;
     private tasklist;
+    /** The sandbox's processes in the last list (none: no sandbox was running). */
+    private pids;
+    private fetchedAt;
+    /** Lists in a row that found the same answer (the gap to the next one grows with it). */
+    private unchanged;
+    /** The signal when the list was last fetched. */
+    private signalled;
     private text;
     private timer;
     private pending;
     private running;
     constructor(o: LiveOptions);
+    private get interval();
     /** The status line as of the last refresh. */
     line(): string;
     /** Reads the process list now and derives the line (one fetch at a time; a caller during one waits for it). */
     refresh(): Promise<void>;
+    private fetch;
+    private load;
+    /** Whether the process list may have changed since it was fetched (checked on every tick, cheaply). */
+    private listDue;
+    private tick;
+    /** A key was pressed: someone is looking, so a list older than one interval is fetched again (after the draw). */
+    touch(): void;
     private derive;
     /** Starts keeping the line fresh and answers the host's process questions from it (until stop). */
     start(): Promise<void>;

package/dist/cli/menu/live.js

@@ -1,14 +1,42 @@
 // What the menu shows about the running sandbox (the status line), kept fresh in the background. Drawing and keys only
-// read the last copy: the process list is fetched without blocking (every few seconds, and after an action), and the
-// screen is told when what it shows has changed. While it runs, the host's own "is the sandbox running?" questions are
-// answered from the same copy, so no page waits for a child process.
+// read the last copy, and the screen is told when what it shows has changed. While it runs, the host's own "is the
+// sandbox running?" questions are answered from the same copy, so no page waits for a child process.
+//
+// The process list (tasklist) is the expensive part: on a busy PC one run costs a large share of a second of CPU. So it
+// is not fetched on a timer: while a sandbox runs, its processes are checked by id (no program started) and the list is
+// fetched again only when one of them has ended; while none runs, the list is fetched less and less often while nothing
+// changes (and again soon after a key press, someone is looking, or when the data folder's run folder changes, a start
+// writes there), and after every action.
 import { sandboxStatus } from '../../app/features/sandbox/index.js';
-import { readTasklistAsync, useTasklistCache } from '../../host/sandbox/index.js';
+import { insideSandbox, readTasklistAsync, sandboxPids, useTasklistCache } from '../../host/sandbox/index.js';
 /** The same rule as the web's live status: the sandbox status query's interval. */
 const DEFAULT_INTERVAL_MS = sandboxStatus.live?.everyMs ?? 2500;
+/** While no sandbox runs, nobody presses a key and the data folder is quiet, the list is fetched this seldom. */
+const DEFAULT_IDLE_MAX_MS = 30000;
+/** The gap before the next process list after `unchanged` lists in a row found the same: doubling, up to `max`. */
+export function listGap(unchanged, base, max) {
+    return Math.min(max, base * 2 ** Math.max(0, Math.min(unchanged, 16)));
+}
+/** A process with this id exists (EPERM: it does, but belongs to someone else, such as the sandbox's own service). */
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}
 export class LiveStatus {
     o;
     tasklist;
+    /** The sandbox's processes in the last list (none: no sandbox was running). */
+    pids = [];
+    fetchedAt = 0;
+    /** Lists in a row that found the same answer (the gap to the next one grows with it). */
+    unchanged = 0;
+    /** The signal when the list was last fetched. */
+    signalled = '';
     text = '';
     timer;
     pending;
@@ -16,30 +44,72 @@ export class LiveStatus {
     constructor(o) {
         this.o = o;
     }
+    get interval() {
+        return this.o.intervalMs ?? DEFAULT_INTERVAL_MS;
+    }
     /** The status line as of the last refresh. */
     line() {
         return this.text;
     }
     /** Reads the process list now and derives the line (one fetch at a time; a caller during one waits for it). */
     refresh() {
-        this.pending ??= (async () => {
-            try {
-                const list = await (this.o.fetch ?? readTasklistAsync)();
-                // Stopped meanwhile: a command may be running, and nothing here may touch the host's facts any more.
-                if (!this.running)
-                    return;
-                this.tasklist = list;
-                this.derive();
-            }
-            catch {
-                // The line keeps what it showed; the next refresh tries again.
-            }
-            finally {
-                this.pending = undefined;
-            }
-        })();
+        // The next gap starts again from the shortest one.
+        this.unchanged = -1;
+        return this.fetch();
+    }
+    fetch() {
+        // Cleared in a callback, so also after a fetch that finished without waiting for anything.
+        this.pending ??= this.load().finally(() => (this.pending = undefined));
         return this.pending;
     }
+    async load() {
+        try {
+            const needed = (this.o.needsList ?? (() => !insideSandbox()))();
+            this.signalled = this.o.signal?.() ?? '';
+            // Not needed: an empty copy, so nothing runs tasklist itself either.
+            const list = needed ? await (this.o.fetch ?? readTasklistAsync)() : '';
+            // Stopped meanwhile: a command may be running, and nothing here may touch the host's facts any more.
+            if (!this.running)
+                return;
+            const pids = sandboxPids(list);
+            const same = this.tasklist !== undefined && pids.length > 0 === this.pids.length > 0;
+            this.unchanged = same ? this.unchanged + 1 : 0;
+            this.tasklist = list;
+            this.pids = pids;
+            this.fetchedAt = Date.now();
+            this.derive();
+        }
+        catch {
+            // The line keeps what it showed; the next refresh tries again.
+        }
+    }
+    /** Whether the process list may have changed since it was fetched (checked on every tick, cheaply). */
+    listDue(now) {
+        if (this.tasklist === undefined)
+            return true;
+        if (this.pids.length)
+            return !this.pids.every((pid) => (this.o.alive ?? processAlive)(pid));
+        if (this.o.signal && this.o.signal() !== this.signalled)
+            return true;
+        return now - this.fetchedAt >= listGap(this.unchanged, this.interval, this.o.idleMaxMs ?? DEFAULT_IDLE_MAX_MS);
+    }
+    tick() {
+        if (this.pending)
+            return;
+        if (this.listDue(Date.now()))
+            void this.fetch();
+        else
+            this.derive();
+    }
+    /** A key was pressed: someone is looking, so a list older than one interval is fetched again (after the draw). */
+    touch() {
+        if (!this.running || this.pending || this.pids.length || Date.now() - this.fetchedAt < this.interval)
+            return;
+        setImmediate(() => {
+            if (this.running)
+                void this.refresh();
+        });
+    }
     derive() {
         const next = this.o.derive();
         if (next === this.text)
@@ -54,7 +124,7 @@ export class LiveStatus {
             return;
         this.running = true;
         useTasklistCache(() => this.tasklist);
-        this.timer = setInterval(() => void this.refresh(), this.o.intervalMs ?? DEFAULT_INTERVAL_MS);
+        this.timer = setInterval(() => this.tick(), this.interval);
         this.timer.unref();
         await this.refresh();
     }
@@ -65,5 +135,6 @@ export class LiveStatus {
         this.timer = undefined;
         useTasklistCache(null);
         this.tasklist = undefined;
+        this.pids = [];
     }
 }

package/dist/cli/menu/menu.d.ts

@@ -1,10 +1,11 @@
 import type { Context } from '../commands/context.js';
 import { Terminal } from '../tui/index.js';
-/** What a test may replace: the terminal, the process list fetch and how often it is fetched. */
+/** What a test may replace: the terminal, the process list fetch, how often it is fetched and the process check. */
 export interface MenuOptions {
     readonly terminal?: Terminal;
     readonly fetchTasklist?: () => Promise<string>;
     readonly refreshMs?: number;
+    readonly processAlive?: (pid: number) => boolean;
 }
 export declare class Menu {
     private readonly ctx;

package/dist/cli/menu/menu.js

@@ -6,6 +6,7 @@ import path from 'node:path';
 import { loadConfig } from '../../core/config/index.js';
 import { errMsg } from '../../core/util/index.js';
 import { SandboxChannel } from '../../host/channel/index.js';
+import { RunDir } from '../../shared/channel/index.js';
 import { isSandboxRunning } from '../../host/sandbox/index.js';
 import { lookAtSandbox } from '../commands/shared-use.js';
 import { commandLine } from '../history.js';
@@ -26,6 +27,15 @@ import { readMenuView, saveMenuView } from './memory.js';
 import { SECTION_LABELS, Shell } from './shell.js';
 /** Where the menu was last left: it opens there again (also in a later run, from menu-state.json). */
 let lastView;
+/** When the data folder's run folder last changed (a start writes there): a stat, never a read of what is in it. */
+function runFolderStamp(dataPath) {
+    try {
+        return String(fs.lstatSync(new RunDir(dataPath).root).mtimeMs);
+    }
+    catch {
+        return '';
+    }
+}
 export class Menu {
     ctx;
     runArgv;
@@ -40,9 +50,12 @@ export class Menu {
             derive: () => this.status(),
             onChange: () => this.app.requestRedraw(),
             intervalMs: options.refreshMs,
+            alive: options.processAlive,
+            signal: () => runFolderStamp(ctx.dataPath),
         });
         this.app.status = () => this.live.line();
         this.app.afterAction = () => this.live.refresh();
+        this.app.onKey = () => this.live.touch();
         try {
             Frame.version =
                 JSON.parse(fs.readFileSync(path.join(ctx.packageRoot, 'package.json'), 'utf8'))
@@ -95,7 +108,8 @@ export class Menu {
         }
         try {
             const shell = this.shell();
-            await this.live.start();
+            // The first screen does not wait for the process list: the pages show "Loading…" until it is there.
+            this.app.ready = this.live.start();
             await shell.restore(lastView ?? readMenuView(SECTION_LABELS) ?? { section: 0, screens: {} });
             for (;;) {
                 const exit = await this.app.show(shell);
@@ -112,7 +126,7 @@ export class Menu {
                     if (code !== undefined)
                         return code;
                 }
-                await this.live.start();
+                this.app.ready = this.live.start();
                 await shell.reload();
             }
         }

package/dist/cli/menu/pages/list-page.d.ts

@@ -57,6 +57,11 @@ export declare abstract class ListPage<T> implements Page {
     protected ticked(): T[];
     /** Loads the data again; a slow load does not hold up the keys (the tab keeps what it showed, then updates). */
     open(): Promise<void>;
+    /**
+     * The section came on screen again: it shows what it had at once and loads the data again after that screen is
+     * drawn (the list is rebuilt on the entry and search the user is on). The first time, it is open().
+     */
+    show(): Promise<void>;
     /**
      * Loads the data and waits for it at most QUICK_LOAD_MS. In time, the list is built here (`build`) or by the caller;
      * later, the list is built when the data arrives, on the entry and search the user has moved to meanwhile.

package/dist/cli/menu/pages/list-page.js

@@ -97,6 +97,23 @@ export class ListPage {
     async open() {
         await this.reload(true);
     }
+    /**
+     * The section came on screen again: it shows what it had at once and loads the data again after that screen is
+     * drawn (the list is rebuilt on the entry and search the user is on). The first time, it is open().
+     */
+    async show() {
+        if (!this.loaded)
+            return this.open();
+        const mine = ++this.generation;
+        setImmediate(() => {
+            if (mine !== this.generation)
+                return;
+            void this.loadData().then(() => {
+                if (mine === this.generation)
+                    this.rebuildLate();
+            });
+        });
+    }
     /**
      * Loads the data and waits for it at most QUICK_LOAD_MS. In time, the list is built here (`build`) or by the caller;
      * later, the list is built when the data arrives, on the entry and search the user has moved to meanwhile.
@@ -125,6 +142,8 @@ export class ListPage {
     }
     async loadData() {
         try {
+            // The first screen is drawn before the menu's facts (the process list) are known; loads wait for them.
+            await this.app.ready;
             await this.load();
         }
         catch (e) {

package/dist/cli/menu/shell.d.ts

@@ -47,6 +47,8 @@ export interface Page {
     setFocus(list: boolean): void;
     /** The section was opened (or the shell came back from a command): load what it shows again. */
     open(): Promise<void>;
+    /** The section came on screen again: show what it had at once and load it again in the background (default open). */
+    show?(): Promise<void>;
     render(size: Size): FrameParts;
     /** A `quit` from the page means "Esc with nothing left to close": the shell moves to the navigation. */
     handle(key: Key): Promise<Step<ShellExit>> | Step<ShellExit>;

package/dist/cli/menu/shell.js

@@ -76,7 +76,7 @@ export class Shell {
         this.remember();
         this.active = Math.max(0, Math.min(this.pages.length - 1, index));
         this.page.setFocus(this.focus === 'list');
-        await this.page.open();
+        await (this.page.show ?? this.page.open).call(this.page);
         if (this.restored.has(this.active))
             return;
         this.restored.add(this.active);

package/dist/cli/services/accounts-service.d.ts

@@ -31,6 +31,13 @@ export declare class AccountsService {
     save(name: string, fromHost: boolean, agent?: string): AccountRef;
     /** Makes the sandbox use a saved login. Running sessions keep the old one until restart(). */
     activate(name: string, agent?: string): AccountRef;
+    /** The agent's default login, if it keeps logins and one is set. */
+    defaultName(agent?: string): string | null;
+    /**
+     * Makes the sandbox use `wanted`, else the agent's default, when it uses another login now (a launch, or a session
+     * started with --account). Returns the login it then uses; null when the agent keeps no login or none is saved.
+     */
+    ensure(agent: string, wanted: string | null): string | null;
     /** Whether a session of this agent is running that would pick up a new login on restart. */
     hasRunningSessions(agent?: string): boolean;
     /** Restarts the agent's running sessions (conversations continue); returns the sandbox's own message. */

package/dist/cli/services/accounts-service.js

@@ -74,6 +74,26 @@ export class AccountsService {
         store.activate(this.ctx.dataPath, name, stateDir);
         return { name, email: null };
     }
+    /** The agent's default login, if it keeps logins and one is set. */
+    defaultName(agent = CLAUDE) {
+        return agent === CLAUDE ? this.claude.defaultName() : this.other(agent).store.defaultName();
+    }
+    /**
+     * Makes the sandbox use `wanted`, else the agent's default, when it uses another login now (a launch, or a session
+     * started with --account). Returns the login it then uses; null when the agent keeps no login or none is saved.
+     */
+    ensure(agent, wanted) {
+        if (!this.agents().some((a) => a.name === agent && a.kept))
+            return null;
+        const name = wanted ?? this.defaultName(agent);
+        if (!name)
+            return this.activeName(agent);
+        if (name !== this.activeName(agent))
+            this.activate(name, agent);
+        else if (agent === CLAUDE)
+            this.claude.syncPlugins(this.ctx.dataPath);
+        return name;
+    }
     /** Whether a session of this agent is running that would pick up a new login on restart. */
     hasRunningSessions(agent = CLAUDE) {
         return (isSandboxRunning() && new SandboxChannel(this.ctx.dataPath).runningSessions().some((s) => s.harness === agent));

package/dist/cli/tui/app.d.ts

@@ -13,6 +13,10 @@ export declare class App {
     status: () => string;
     /** Awaited after an action changed something, before the screen loads what it shows again. */
     afterAction: () => Promise<void>;
+    /** Settles when the facts pages load from are known (the first screen is drawn without waiting for it). */
+    ready: Promise<void>;
+    /** Told about every key (after it was handled and drawn): someone is looking at the screen. */
+    onKey: () => void;
     /** The navigation on the left of every screen (none: no navigation column). */
     nav: () => NavState | undefined;
     /** The screens being shown, innermost last: a dialog is drawn over the one below it. */

package/dist/cli/tui/app.js

@@ -19,6 +19,10 @@ export class App {
     status = () => '';
     /** Awaited after an action changed something, before the screen loads what it shows again. */
     afterAction = () => Promise.resolve();
+    /** Settles when the facts pages load from are known (the first screen is drawn without waiting for it). */
+    ready = Promise.resolve();
+    /** Told about every key (after it was handled and drawn): someone is looking at the screen. */
+    onKey = () => undefined;
     /** The navigation on the left of every screen (none: no navigation column). */
     nav = () => undefined;
     /** The screens being shown, innermost last: a dialog is drawn over the one below it. */
@@ -67,6 +71,7 @@ export class App {
                     drawnAt = Date.now();
                 }
                 const step = await screen.handle(await this.terminal.key());
+                this.onKey();
                 if (step)
                     return step.done;
             }

package/dist/cli/tui/terminal.d.ts

@@ -10,6 +10,12 @@ export interface Key {
 export declare class ExitRequested extends Error {
     constructor();
 }
+/**
+ * How long a lone ESC waits for the rest of an escape sequence before it counts as the Esc key. Node's default is
+ * 500 ms, which every Esc (back, close) waited for. Terminals send a key's whole sequence in one write, so a short wait
+ * is enough.
+ */
+export declare const ESCAPE_TIMEOUT_MS = 25;
 /** Whether this terminal is known to take synchronized updates (AGENT_SANDBOX_SYNC_UPDATE=1 or 0 overrides). */
 export declare function supportsSyncUpdate(env?: NodeJS.ProcessEnv): boolean;
 export declare class Terminal {