windows-development-sandbox 1.12.0 → 1.13.2

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-K4SU3MHJ.js";
+import "./chunk-VENWSGX2.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-K4SU3MHJ.js";
+import "./chunk-VENWSGX2.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-K4SU3MHJ.js";
+import "./chunk-VENWSGX2.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-K4SU3MHJ.js";
+import "./chunk-VENWSGX2.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-K4SU3MHJ.js";
+import "./chunk-VENWSGX2.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-K4SU3MHJ.js";
+import "./chunk-VENWSGX2.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-K4SU3MHJ.js";
+import "./chunk-VENWSGX2.js";
+
+// src/bin/sbx-show.ts
+run(process.argv.slice(2), { command: "show" });

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/registry.js

@@ -15,6 +15,7 @@ import { agentCommandsCommand } from './agent-commands.js';
 import { vpn } from './vpn.js';
 import { github } from './github.js';
 import { web, webServer } from './web.js';
+import { remote } from './remote.js';
 export const HANDLERS = {
     launch: (ctx) => launch(ctx),
     generate: (ctx) => launch(ctx, true),
@@ -54,5 +55,6 @@ export const HANDLERS = {
     vpn: vpn,
     github: github,
     web: web,
+    remote: remote,
     _web: webServer,
 };

package/dist/cli/commands/remote.d.ts

@@ -0,0 +1,2 @@
+import { type Context } from './context.js';
+export declare function remote(ctx: Context): Promise<number>;

package/dist/cli/commands/remote.js

@@ -0,0 +1,49 @@
+// `sandbox remote [user] [--browser]`: another Windows user's program, used from here (docs/design/remote-access.md).
+// Windows sign-in through the owner's pipe gives a one-time token; the menu then runs over the owner's web UI (every
+// action checked against the role the owner gave, and written to their audit log), or --browser opens it signed in.
+import { allows } from '../../app/kernel/index.js';
+import { fail, safeText } from '../../core/util/index.js';
+import { knockOnDoor } from '../../host/remote/index.js';
+import { currentUserName, runningOwner } from '../../host/sharing/index.js';
+import { openBrowser } from '../../host/web/index.js';
+import { RemoteMenu } from '../menu/remote-menu.js';
+import { remoteClient } from '../services/remote-client.js';
+import { App } from '../tui/index.js';
+import { requireOnPc } from './context.js';
+/** Whose program: the user named, else the owner of the running sandbox when it is someone else's. */
+function ownerOf(ctx) {
+    const named = ctx.options.positionals[0];
+    if (named)
+        return { name: named, id: named };
+    const owner = runningOwner();
+    if (owner.kind === 'other')
+        return { name: owner.user, id: owner.record.sid };
+    return fail('Whose web UI? No sandbox of another user is running.', 'Name them: sandbox remote <their Windows user name>');
+}
+export async function remote(ctx) {
+    requireOnPc('remote');
+    const owner = ownerOf(ctx);
+    const answer = await knockOnDoor(ctx.storageRoot, owner.id);
+    if (!answer.ok)
+        return fail(safeText(answer.reason), 'Ask ' +
+            safeText(owner.name) +
+            ' to turn on web.remote.windowsSignIn, add you to web.remote.users and start the web UI.');
+    if (ctx.options.raw.browser === true) {
+        openBrowser('http://127.0.0.1:' + answer.port + '/#w=' + answer.token);
+        console.log('Opened ' + safeText(owner.name) + "'s web UI in your browser (" + answer.role + '). It runs as them, not you.');
+        return 0;
+    }
+    const client = await remoteClient(answer.port, answer.token);
+    const caller = { kind: 'windows', user: currentUserName(), role: answer.role };
+    const app = new App();
+    try {
+        await new RemoteMenu(app, ctx, client, owner.name, caller).start();
+    }
+    finally {
+        app.close();
+        client.close();
+    }
+    if (!allows(caller, 'control'))
+        console.log('You had view access: nothing was changed.');
+    return 0;
+}

package/dist/cli/commands/sessions/reopen.js

@@ -8,6 +8,9 @@ import { c } from '../../output/index.js';
 /** Where each running session is on this PC, so it can be reopened after a restart. */
 export function sessionsToReopen(registry, sessions) {
     return sessions.flatMap((s) => {
+        // Shells are not reopened: a new one would not be the one that ended.
+        if (s.kind === 'shell')
+            return [];
         const project = projectForGuestDir([...registry.projects, ...registry.roots.map((r) => ({ ...r }))], s.cwd);
         return project
             ? [

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/commands/web.js

@@ -3,10 +3,16 @@
 // running when no sandbox does. startWebOnLaunch is the sandbox start's hook.
 import fs from 'node:fs';
 import path from 'node:path';
+import { accessStoreOf } from '../../app/features/access/index.js';
 import { currentServer, START_WAIT_MS, webStatus } from '../../app/features/web/index.js';
 import { createRpcHost } from '../../app/registry.js';
+import { loadConfig } from '../../core/config/index.js';
 import { packageVersion } from '../../core/package-info.js';
 import { sleep, fail } from '../../core/util/index.js';
+import { AuditLog } from '../../host/audit/index.js';
+import { doorPipeName, HostToolsHelper, networkProfile, RemoteGate, TlsStore, } from '../../host/remote/index.js';
+import { SecretStore } from '../../host/secrets/index.js';
+import { currentUserSid } from '../../host/sharing/index.js';
 import { IDLE_EXIT_MS, openBrowser, WebControl, WebRunner, WebStore } from '../../host/web/index.js';
 import { spawnDetached } from '../../host/sandbox/index.js';
 import { WebService } from '../services/index.js';
@@ -53,6 +59,65 @@ export async function startWebOnLaunch(ctx) {
 export async function web(ctx) {
     return (await definitionHandler(webStatus)(ctx)) ?? 0;
 }
+/** The remote settings as in the file now (read again at most every 3 seconds; a broken file keeps the last). */
+function remoteSettings(ctx) {
+    let last = ctx.loaded.config.web.remote;
+    let readAt = Date.now();
+    return () => {
+        if (Date.now() - readAt < 3000)
+            return last;
+        readAt = Date.now();
+        try {
+            last = loadConfig(ctx.options.config).config.web.remote;
+        }
+        catch {
+            // A settings file being edited or broken: keep what was read last.
+        }
+        return last;
+    };
+}
+/** Remote actions go to the audit log of this data set (k: remote), so the Activity page shows who did what. */
+function remoteAudit(ctx) {
+    const { days, maxMb } = ctx.loaded.config.audit;
+    const log = new AuditLog(AuditLog.dirFor(ctx.storageRoot, ctx.dataPath), { days, maxMb });
+    return (entry) => {
+        try {
+            log.append([{ t: new Date().toISOString(), k: 'remote', p: entry.what, a: entry.outcome, au: entry.who }]);
+        }
+        catch {
+            // The audit log is a record, never a reason for a request to fail.
+        }
+    };
+}
+/**
+ * The gate for other Windows users and devices (docs/design/remote-access.md). The Windows helper is started when it
+ * can be built here: then the owner's own cookie is bound to the owner's connections too, and the sign-in pipe is
+ * served (it refuses everyone while web.remote.windowsSignIn is off).
+ */
+function remoteGate(ctx) {
+    const secrets = SecretStore.standard();
+    let ownerSid = '';
+    try {
+        ownerSid = currentUserSid();
+    }
+    catch {
+        // Unknown: Windows sign-in stays off, the owner signs in with the token as before.
+    }
+    const helper = ownerSid ? HostToolsHelper.start(ctx.storageRoot, doorPipeName(ownerSid)) : null;
+    const audit = remoteAudit(ctx);
+    helper?.onProblem((text) => audit({ who: 'the web UI', what: 'Windows sign-in: ' + text, outcome: 'failed' }));
+    const store = new WebStore(ctx.storageRoot);
+    return new RemoteGate({
+        store: accessStoreOf(ctx),
+        settings: remoteSettings(ctx),
+        ownerSid,
+        helper,
+        audit,
+        tls: new TlsStore(store.dir, secrets),
+        profile: (address) => networkProfile(address),
+        port: () => ctx.loaded.config.web.port,
+    });
+}
 /** Body of the background process (`sandbox _web`): runs until stopped. */
 export async function webServer(ctx) {
     const staticRoot = path.join(ctx.packageRoot, 'dist', 'web');
@@ -66,6 +131,7 @@ export async function webServer(ctx) {
         staticRoot,
         version: packageVersion(),
         idleExitMs: IDLE_EXIT_MS,
+        gate: remoteGate(ctx),
     }).run();
     process.exit(0);
 }

package/dist/cli/manifest.d.ts

@@ -769,17 +769,76 @@ declare const COMMAND_LIST: readonly [{
     readonly interactive: true;
 }, {
     readonly name: "web";
-    readonly summary: "(beta) your sandbox sessions in a browser on this PC: start, stop, status or open";
+    readonly summary: "(beta) your sandbox sessions in a browser on this PC (and, if you allow it, on your network)";
     readonly group: "Web";
-    readonly examples: readonly ["sandbox web open               start the web UI and open it in your browser"];
+    readonly examples: readonly ["sandbox web open               start the web UI and open it in your browser", "sandbox web lan-on             let devices you allow use it on your network", "sandbox web allow-device       show a one-time code for a phone", "sandbox web devices            who may use it; sandbox web revoke <id> signs one out"];
     readonly args: readonly [{
         readonly name: "action";
-        readonly description: "start the server, stop it, show whether it runs, or open it in your browser";
+        readonly description: "start, stop, status, open; devices, allow-device, revoke, revoke-all, lan-on, lan-off (remote access)";
         readonly required: false;
         readonly choices: readonly ["start", "stop", "status", "open"];
+    }, {
+        readonly name: "id";
+        readonly description: "(revoke) the device or sign-in id from sandbox web devices";
+        readonly required: false;
+        readonly when: "revoke";
+    }];
+    readonly options: readonly [{
+        flag: string;
+        type: "string" | "number" | "boolean" | "list";
+        description: string;
+        short?: string | undefined;
+        value?: string | undefined;
+        label?: string | undefined;
+        default?: string | number | undefined;
+        choices?: string[] | "harnesses" | "sessions" | "accounts" | undefined;
+        advanced?: boolean | undefined;
+        when?: string | undefined;
+        noMenu?: boolean | undefined;
+        group?: string | undefined;
+        shownAs?: string | undefined;
+    }, {
+        flag: string;
+        type: "string" | "number" | "boolean" | "list";
+        description: string;
+        short?: string | undefined;
+        value?: string | undefined;
+        label?: string | undefined;
+        default?: string | number | undefined;
+        choices?: string[] | "harnesses" | "sessions" | "accounts" | undefined;
+        advanced?: boolean | undefined;
+        when?: string | undefined;
+        noMenu?: boolean | undefined;
+        group?: string | undefined;
+        shownAs?: string | undefined;
     }];
-    readonly options: readonly [];
     readonly json: true;
+}, {
+    readonly name: "remote";
+    readonly summary: "(beta) use another Windows user's web UI from here, signed in with your Windows account";
+    readonly group: "Web";
+    readonly examples: readonly ["sandbox remote                 the menu over the owner of the running sandbox (their program, your role)", "sandbox remote alice --browser open alice's web UI in your browser, signed in"];
+    readonly args: readonly [{
+        readonly name: "user";
+        readonly description: "whose web UI (default: the owner of the running sandbox)";
+        readonly required: false;
+    }];
+    readonly options: readonly [{
+        flag: string;
+        type: "string" | "number" | "boolean" | "list";
+        description: string;
+        short?: string | undefined;
+        value?: string | undefined;
+        label?: string | undefined;
+        default?: string | number | undefined;
+        choices?: string[] | "harnesses" | "sessions" | "accounts" | undefined;
+        advanced?: boolean | undefined;
+        when?: string | undefined;
+        noMenu?: boolean | undefined;
+        group?: string | undefined;
+        shownAs?: string | undefined;
+    }];
+    readonly interactive: true;
 }, {
     readonly name: "_watch";
     readonly summary: "background history sync";

package/dist/cli/manifest.js

@@ -540,20 +540,49 @@ const COMMAND_LIST = [
     },
     {
         name: 'web',
-        summary: '(beta) your sandbox sessions in a browser on this PC: start, stop, status or open',
+        summary: '(beta) your sandbox sessions in a browser on this PC (and, if you allow it, on your network)',
         group: 'Web',
-        examples: ['sandbox web open               start the web UI and open it in your browser'],
+        examples: [
+            'sandbox web open               start the web UI and open it in your browser',
+            'sandbox web lan-on             let devices you allow use it on your network',
+            'sandbox web allow-device       show a one-time code for a phone',
+            'sandbox web devices            who may use it; sandbox web revoke <id> signs one out',
+        ],
         args: [
             {
                 name: 'action',
-                description: 'start the server, stop it, show whether it runs, or open it in your browser',
+                description: 'start, stop, status, open; devices, allow-device, revoke, revoke-all, lan-on, lan-off (remote access)',
                 required: false,
                 choices: ['start', 'stop', 'status', 'open'],
             },
+            {
+                name: 'id',
+                description: '(revoke) the device or sign-in id from sandbox web devices',
+                required: false,
+                when: 'revoke',
+            },
+        ],
+        options: [
+            text('--role', 'view|control', '(allow-device) what the device may do (default view)', {
+                when: 'allow-device',
+                choices: ['view', 'control'],
+            }),
+            bool('--yes', '(revoke-all, lan-off) do not ask first', { short: '-y', noMenu: true }),
         ],
-        options: [],
         json,
     },
+    {
+        name: 'remote',
+        summary: "(beta) use another Windows user's web UI from here, signed in with your Windows account",
+        group: 'Web',
+        examples: [
+            'sandbox remote                 the menu over the owner of the running sandbox (their program, your role)',
+            "sandbox remote alice --browser open alice's web UI in your browser, signed in",
+        ],
+        args: [{ name: 'user', description: 'whose web UI (default: the owner of the running sandbox)', required: false }],
+        options: [bool('--browser', 'open it in your browser instead of the menu')],
+        interactive: true,
+    },
     { name: '_watch', summary: 'background history sync', group: 'Data', args: [], options: [], hidden: true },
     {
         name: '_web',

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

@@ -1,4 +1,4 @@
-import { type Action, type AnyDefinition } from '../../app/kernel/index.js';
+import { type Action, type AnyDefinition, type OperationIO } from '../../app/kernel/index.js';
 import type { Context } from '../commands/context.js';
 import { type App } from '../tui/index.js';
 import type { ShellExit } from './shell.js';
@@ -12,10 +12,12 @@ export interface Performed {
     readonly notice?: string;
     readonly reload?: boolean;
 }
+/** How a definition is run: in this process (the menu), or on the owner's web UI (sandbox remote). */
+export type DefinitionRunner = (id: string, input: unknown, io: OperationIO) => Promise<unknown>;
 export declare class MenuOperations {
     private readonly app;
-    private readonly ctx;
-    constructor(app: App, ctx: Context);
+    private readonly runner;
+    constructor(app: App, ctx: Context, runner?: DefinitionRunner);
     /** Does what an action of a page says: follows a link, or asks for its fields and runs its operation. */
     perform(action: Action, where: Where, busy?: ShowBusy, onOutput?: (output: unknown) => void): Promise<Performed>;
     /** The values of an action's fields, from the editors that fit them (undefined: one was backed out of). */

package/dist/cli/menu/io-menu.js

@@ -66,10 +66,10 @@ function follow(target) {
 }
 export class MenuOperations {
     app;
-    ctx;
-    constructor(app, ctx) {
+    runner;
+    constructor(app, ctx, runner = (id, input, io) => runDefinition(id, ctx, input, io)) {
         this.app = app;
-        this.ctx = ctx;
+        this.runner = runner;
     }
     /** Does what an action of a page says: follows a link, or asks for its fields and runs its operation. */
     async perform(action, where, busy, onOutput) {
@@ -81,7 +81,14 @@ export class MenuOperations {
         const answers = await this.fields(action, def, where);
         if (!answers)
             return {};
-        return { reload: true, notice: await this.run(def, { ...action.input, ...answers }, where, busy, onOutput) };
+        // An operation that opens a session's terminal (a new shell) leaves the menu to attach to it.
+        let opened;
+        const notice = await this.run(def, { ...action.input, ...answers }, where, busy, (output) => {
+            onOutput?.(output);
+            opened = def.kind === 'operation' ? def.opens?.(output) : undefined;
+        });
+        const exit = opened ? follow(opened).exit : undefined;
+        return { reload: true, notice, ...(exit ? { exit } : {}) };
     }
     /** The values of an action's fields, from the editors that fit them (undefined: one was backed out of). */
     async fields(action, def, where) {
@@ -110,7 +117,7 @@ export class MenuOperations {
             log: (text, tone) => said.push(tone === 'warn' || tone === 'danger' ? Theme.warn(text) : text),
         });
         try {
-            const output = await runDefinition(def.id, this.ctx, input, io);
+            const output = await this.runner(def.id, input, io);
             onOutput?.(output);
             // The notice is one line: an operation that says several lines (accounts use) runs them together.
             const text = def.text?.(output)?.replace(/\n+/g, ' ');

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>;