windows-development-sandbox 1.23.2 → 1.25.1

package/dist/guest/agents/agent-files.js

@@ -63,10 +63,17 @@ export function bootResetPaths(agents, stateDir) {
 }
 /** The marker the sandbox puts above the lines it writes into config.toml. */
 const CODEX_MARKER = '# Set by the sandbox';
+/** The full marker line: what it is and where to change it. */
+const CODEX_MARKER_LINE = CODEX_MARKER + ' from its codex settings (`sandbox config`); a line of your own without it wins.';
+/** Markers whose lines count as the sandbox's: CODEX_MARKER, and a hand-made fix's (`# agent-sandbox:`). */
+const CODEX_MARKERS = [CODEX_MARKER, '# agent-sandbox:'];
+/** The top-level keys the sandbox writes under its marker. */
+const CODEX_OWNED_KEYS = ['sandbox_mode', 'approval_policy', 'model', 'model_reasoning_effort'];
 /**
- * The flags every Codex start gets. Flags beat config.toml and a resumed thread's saved permissions, which is why the
- * sandbox does not rely on the file. Full access with no questions is the one flag that skips Codex's Windows sandbox
- * setup for certain. Pure.
+ * The flags every Codex start through the sandbox gets (the codex.cmd shim, the daemon's sessions). Flags beat
+ * config.toml and a resumed thread's saved permissions; config.toml carries the same settings for a start without
+ * them (codexConfigOwned). Full access with no questions is the one flag that skips Codex's Windows sandbox setup for
+ * certain. Pure.
  */
 export function codexArguments(c) {
     const out = c.sandboxMode === 'danger-full-access' && c.approvalPolicy === 'never'
@@ -85,10 +92,13 @@ export function agentArguments(name, harness, codex) {
 /** The largest config.toml the sandbox edits. */
 export const MAX_CODEX_CONFIG_BYTES = 1024 * 1024;
 /**
- * Codex's config.toml as the sandbox wants it, every other line byte for byte: the lines an older version wrote above
- * the first table (sandbox_mode, approval_policy, under the marker comment) are gone, `[windows] sandbox` follows
- * windowsSandbox ("off" removes the line, so Codex does not set up its own sandbox users), and
- * mcp_oauth_credentials_store = "file" is added when it is not set. Running it again changes nothing. Pure.
+ * Codex's config.toml as the sandbox wants it, every other line byte for byte. Above the first table, under the
+ * marker comment: sandbox_mode, approval_policy (and model, model_reasoning_effort when set), so ANY start of Codex
+ * obeys the codex settings, also one without the shim's flags (a copy installed with npm -g). The marked lines are
+ * replaced each time; a key the user set on a line of their own above the first table is left to them.
+ * `[windows] sandbox` follows windowsSandbox ("off" removes the line, which Codex adds back after its own setup, so it
+ * does not set up its own sandbox users), and mcp_oauth_credentials_store = "file" is added when it is not set.
+ * Keeps the file's line endings; running it again changes nothing. Pure.
  */
 export function codexConfigOwned(toml, c) {
     const eol = toml.includes('\r\n') ? '\r\n' : '\n';
@@ -96,15 +106,31 @@ export function codexConfigOwned(toml, c) {
     let top = firstTable < 0 ? toml : toml.slice(0, firstTable);
     const tables = firstTable < 0 ? '' : toml.slice(firstTable);
     top = top.replace(MARKED_LINES, '');
-    if (c.mcpLoginsInFile && !/^[ \t]*mcp_oauth_credentials_store[ \t]*=/m.test(top)) {
+    if (c.mcpLoginsInFile && !hasKey(top, 'mcp_oauth_credentials_store')) {
         if (top && !top.endsWith('\n'))
             top += eol;
         top += 'mcp_oauth_credentials_store = "file"' + eol + (tables ? eol : '');
     }
-    return top + codexWindowsSandbox(tables, c.windowsSandbox, eol);
+    const values = {
+        sandbox_mode: c.sandboxMode,
+        approval_policy: c.approvalPolicy,
+        model: c.model,
+        model_reasoning_effort: c.reasoningEffort === 'default' ? '' : c.reasoningEffort,
+    };
+    const lines = CODEX_OWNED_KEYS.filter((k) => values[k] && !hasKey(top, k)).map((k) => k + ' = ' + JSON.stringify(values[k]));
+    const marked = lines.length ? [CODEX_MARKER_LINE, ...lines].join(eol) + eol + (top || tables ? eol : '') : '';
+    return marked + top + codexWindowsSandbox(tables, c.windowsSandbox, eol);
+}
+/** True when the top of config.toml sets the key on a line of its own. */
+function hasKey(top, key) {
+    return new RegExp('^[ \t]*' + key + '[ \t]*=', 'm').test(top);
 }
-/** The lines an older version wrote above the first table: its marker comment, then sandbox_mode / approval_policy. */
-const MARKED_LINES = new RegExp('^' + CODEX_MARKER + '[^\r\n]*\r?\n(?:(?:sandbox_mode|approval_policy)[ \t]*=[^\r\n]*\r?\n)*(?:[ \t]*\r?\n)?', 'm');
+/** The lines the sandbox wrote above the first table: a marker comment, the keys it owns, then one blank line. */
+const MARKED_LINES = new RegExp('^(?:' +
+    CODEX_MARKERS.join('|') +
+    ')[^\r\n]*\r?\n(?:(?:' +
+    CODEX_OWNED_KEYS.join('|') +
+    ')[ \t]*=[^\r\n]*(?:\r?\n|$))*(?:[ \t]*\r?\n)?', 'm');
 /** The tables of config.toml (from the first one on) with `[windows] sandbox` set to the mode, or removed for "off". */
 function codexWindowsSandbox(tables, mode, eol) {
     const setting = 'sandbox = "' + mode + '"';

package/dist/guest/agents/local-state.d.ts

@@ -7,7 +7,8 @@ export declare function localStateVars(): Record<string, string>;
 export declare function resetMachineBound(): void;
 /**
  * Boot: Codex's config.toml follows the codex settings (codexConfigOwned): no Windows sandbox setup of its own, its MCP
- * logins in a file. The sandbox mode itself travels as launch flags (codexArguments), which beat this file.
+ * logins in a file, the sandbox mode and approval policy for a start without the launch flags (codexArguments, which
+ * beat this file and still go on every start through the sandbox).
  */
 export declare function codexBootConfig(): void;
 /** Boot: the saved databases of every configured agent are copied to the sandbox's disk, where the agent runs them. */

package/dist/guest/agents/local-state.js

@@ -104,7 +104,8 @@ export function resetMachineBound() {
 }
 /**
  * Boot: Codex's config.toml follows the codex settings (codexConfigOwned): no Windows sandbox setup of its own, its MCP
- * logins in a file. The sandbox mode itself travels as launch flags (codexArguments), which beat this file.
+ * logins in a file, the sandbox mode and approval policy for a start without the launch flags (codexArguments, which
+ * beat this file and still go on every start through the sandbox).
  */
 export function codexBootConfig() {
     if (dryRun || !session.agents?.codex || !session.codex)

package/dist/guest/apps/after-install.d.ts

@@ -1,3 +1,3 @@
-import type { AppEntry } from '../../shared/apps/index.js';
+import { type AppEntry } from '../../shared/apps/index.js';
 /** Settings an app needs on every boot (the sandbox's registry is new each time), and files next to its program. */
 export declare function afterInstall(entry: AppEntry, exe: string): Promise<void>;

package/dist/guest/apps/after-install.js

@@ -1,11 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { associationPlan } from '../../shared/apps/index.js';
 import { SYSTEM } from '../../shared/system.js';
 import { errMsg } from '../../core/util/errors.js';
 import { takePendingComet } from '../accounts/kinds/comet.js';
 import { restoreCometSignIn } from '../browser/comet.js';
 import { log, warn } from '../runtime/log.js';
-import { execAsync } from '../runtime/process.js';
+import { execAsync, runScriptWithJsonAsync } from '../runtime/process.js';
 import { exists, mkdirp } from '../runtime/fs.js';
 import { arch, tool } from '../toolchains/tool-env.js';
 /** The Sysinternals tools whose EULA is accepted up front (each asks once otherwise). */
@@ -58,6 +59,10 @@ export async function afterInstall(entry, exe) {
         mkdirp(path.join(dir, 'Data'));
     if (entry.id === 'comet')
         await restoreComet(exe);
+    const plan = associationPlan(entry.id, exe);
+    if (plan.length) {
+        await runScriptWithJsonAsync('set-registry-values.ps1', 'PlanFile', { values: plan }).catch((e) => warn(entry.name + ': double-click file types were not set (' + errMsg(e) + ')'));
+    }
     if (entry.id === 'sysinternals') {
         for (const name of SYSINTERNALS_TOOLS) {
             await execAsync(SYSTEM.reg(), ['add', 'HKCU\\Software\\Sysinternals\\' + name, '/v', 'EulaAccepted', '/t', 'REG_DWORD', '/d', '1', '/f'], { stdio: 'ignore' }).catch(() => undefined);

package/dist/guest/apps/app-installer.d.ts

@@ -13,6 +13,7 @@ export declare class AppInstaller {
     private readonly parallel;
     private readonly gui;
     private readonly installed;
+    private readonly installedIds;
     constructor(env: ToolEnv, options: AppsOptions, parallel?: number);
     /**
      * Downloads the plain downloads (not pinned, not npm, not remote) of the apps that are not installed yet, into

package/dist/guest/apps/app-installer.js

@@ -2,7 +2,7 @@
 // failing is reported and never stops the others.
 import fs from 'node:fs';
 import path from 'node:path';
-import { appsToInstall } from '../../shared/apps/index.js';
+import { appsToInstall, previewGuideLine } from '../../shared/apps/index.js';
 import { downloader, moveIntoPlace, stagingFolder } from '../../shared/download/index.js';
 import { safeRemove } from '../../shared/io/safe-remove.js';
 import { dryRun, launchDir } from '../runtime/paths.js';
@@ -33,6 +33,7 @@ export class AppInstaller {
     parallel;
     gui = [];
     installed = [];
+    installedIds = [];
     constructor(env, options, parallel = PARALLEL) {
         this.env = env;
         this.options = options;
@@ -82,6 +83,9 @@ export class AppInstaller {
         }
         if (this.installed.length)
             this.env.summary.push('apps: ' + this.installed.join(', ') + ' (shortcuts on the desktop and in Start > Sandbox apps)');
+        const preview = previewGuideLine(this.installedIds);
+        if (preview)
+            this.env.summary.push(preview);
     }
     async installOne(entry) {
         try {
@@ -102,11 +106,17 @@ export class AppInstaller {
                 throw new Error(entry.exe + ' not found in the download');
             await afterInstall(entry, exe);
             // A proxy or MCP server (agent add-ons) is started by the sandbox or the agent: no PATH entry, no shortcut.
-            if (!entry.service && (entry.cli || entry.id === 'sysinternals'))
-                this.env.prepend.push(path.dirname(exe));
+            if (!entry.service && (entry.cli || entry.id === 'sysinternals')) {
+                // rustup's rust-analyzer proxy (in cargo's bin folder) only errors until its component is added.
+                if (entry.id === 'rust-analyzer')
+                    this.env.prepend.unshift(path.dirname(exe));
+                else
+                    this.env.prepend.push(path.dirname(exe));
+            }
             if (!entry.cli && !entry.service)
                 this.gui.push({ name: entry.name, exe, ...this.launchArgs(entry) });
             this.installed.push(entry.name);
+            this.installedIds.push(entry.id);
         }
         catch (e) {
             warn(entry.name + ' could not be installed and is skipped; the other apps are not affected. Reason: ' + errMsg(e));

package/dist/guest/apps/comet-unpack.js

@@ -15,10 +15,11 @@ const INNER = [
     /^chrome\.7z$/i,
     /^chrome\.packed\.7z$/i,
     /^mini_installer\.exe$/i,
-    /^updater\.packed\.7z$/i,
+    /^updater\.(packed\.)?7z$/i,
 ];
 const MAX_LEVELS = 6;
-const MAX_DEPTH = 4;
+/** Comet's installer nests mini_installer.exe five folders down (bin\Offline\{id}\{id}). */
+const MAX_DEPTH = 7;
 const MAX_ENTRIES = 20000;
 /** Where the installer is kept when it could not be unpacked (below the app's folder). */
 export const KEPT_INSTALLER_DIR = 'installer';

package/dist/guest/apps/resolvers-gamedev.js

@@ -1 +1,55 @@
-export const GAMEDEV_RESOLVERS = {};
+// Where the latest version of the game-development apps (catalogue-gamedev.ts) is, when it is not a plain GitHub
+// release: Krita (download.kde.org, with the SHA-256 its mirror publishes beside each file), Inkscape (inkscape.org's
+// portable 7z and its .sha256) and RenderDoc (renderdoc.org's portable zip; it publishes no checksum, the download is
+// HTTPS from renderdoc.org).
+import { fetchText } from '../../shared/download/index.js';
+const firstHash = (text) => /\b([0-9a-f]{64})\b/i.exec(text)?.[1].toLowerCase() ?? null;
+const byVersion = (a, b) => {
+    const x = a.split('.').map(Number);
+    const y = b.split('.').map(Number);
+    for (let i = 0; i < Math.max(x.length, y.length); i++)
+        if ((x[i] ?? 0) !== (y[i] ?? 0))
+            return (x[i] ?? 0) - (y[i] ?? 0);
+    return 0;
+};
+/** The newest Krita release folder that has the portable Windows zip (a hotfix folder may have only some files). */
+async function krita() {
+    const base = 'https://download.kde.org/stable/krita/';
+    const versions = [...(await fetchText(base)).matchAll(/href="(\d+\.\d+\.\d+(?:\.\d+)?)\/"/g)]
+        .map((m) => m[1])
+        .sort(byVersion)
+        .reverse()
+        .slice(0, 4);
+    for (const v of versions) {
+        const file = 'krita-x64-' + v + '.zip';
+        if (!(await fetchText(base + v + '/')).includes('href="' + file + '"'))
+            continue;
+        const url = base + v + '/' + file;
+        return { url, fileName: file, sha256: firstHash(await fetchText(url + '.sha256').catch(() => '')) };
+    }
+    throw new Error('no portable Krita zip on download.kde.org');
+}
+async function inkscape() {
+    const release = await fetchText('https://inkscape.org/release/');
+    const v = /\/release\/inkscape-(\d+\.\d+(?:\.\d+)?)\//.exec(release)?.[1];
+    if (!v)
+        throw new Error('could not find the latest Inkscape release');
+    const page = await fetchText('https://inkscape.org/release/inkscape-' + v + '/windows/64-bit/compressed-7z/dl/');
+    const item = /\/gallery\/item\/\d+\/inkscape-[\w.-]+-x64[\w-]*\.7z/.exec(page);
+    const sums = /https:\/\/media\.inkscape\.org\/media\/resources\/sigs\/[\w.-]+\.sha256/.exec(page)?.[0];
+    if (!item)
+        throw new Error('no portable Inkscape 7z for ' + v);
+    return {
+        url: 'https://inkscape.org' + item[0],
+        fileName: 'inkscape-' + v + '-x64.7z',
+        sha256: sums ? firstHash(await fetchText(sums).catch(() => '')) : null,
+    };
+}
+async function renderdoc() {
+    const page = await fetchText('https://renderdoc.org/builds');
+    const hit = /https:\/\/renderdoc\.org\/stable\/([\d.]+)\/RenderDoc_[\d.]+_64\.zip/.exec(page);
+    if (!hit)
+        throw new Error('could not find the RenderDoc download on renderdoc.org');
+    return { url: hit[0], fileName: 'RenderDoc_' + hit[1] + '_64.zip' };
+}
+export const GAMEDEV_RESOLVERS = { krita, inkscape, renderdoc };

package/dist/guest/boot/boot-console.d.ts

@@ -0,0 +1,28 @@
+import { type ReadyInfo, type ViewStage, type ViewTask } from './progress-view.js';
+import type { BootTaskDef, RunnerObserver, TaskOutcome } from './runner.js';
+export declare class BootConsole implements RunnerObserver {
+    private readonly view;
+    private readonly live;
+    private timer;
+    private open;
+    private constructor();
+    /** `plain`: ordered lines even on a terminal (a dry run). */
+    static create(stages: readonly ViewStage[], tasks: readonly ViewTask[], o: {
+        plain: boolean;
+    }): BootConsole;
+    /** Prints the header and takes the console. */
+    start(header: string): void;
+    started(task: BootTaskDef): void;
+    finished(task: BootTaskDef, outcome: TaskOutcome): void;
+    /** What a running task's place on its row says (null: its title). */
+    detail(taskId: string, text: string | null): void;
+    /** The tool summary: to the file now, to the console once the boot is ready. */
+    summary(lines: readonly string[]): void;
+    /** Runs `work` that writes to the terminal itself (the hooks). */
+    aside<T>(work: () => T): T;
+    /**
+     * The final summary (`ready`, or null when the boot failed); the console is the log's own again. Programs' output
+     * keeps going to the log (the background runs quiet: file only).
+     */
+    release(ready: ReadyInfo | null): void;
+}

package/dist/guest/boot/boot-console.js

@@ -0,0 +1,98 @@
+// The boot's console on the sandbox's terminal: the live progress block when it is a terminal, ordered plain lines
+// otherwise (and in a dry run). While it is open it takes the log's console lines and the output of the programs the
+// boot starts; it is released, with the final summary, right before the first session takes the window.
+import { log, record, routeConsole } from '../runtime/log.js';
+import { routeOutput } from '../runtime/process.js';
+import { CONSOLE_GLYPHS, ProgressView, readyLines, RICH_GLYPHS, } from './progress-view.js';
+/** The spinner's pace (the elapsed times change every tenth of a second too). */
+const FRAME_MS = 100;
+const COLUMNS = 80;
+const SHOW_CURSOR = '\x1b[?25h';
+export class BootConsole {
+    view;
+    live;
+    timer = null;
+    open = false;
+    constructor(view, live) {
+        this.view = view;
+        this.live = live;
+    }
+    /** `plain`: ordered lines even on a terminal (a dry run). */
+    static create(stages, tasks, o) {
+        const live = !o.plain && process.stdout.isTTY === true;
+        // Windows Terminal sets WT_SESSION; the classic console's font has no braille or check marks.
+        const rich = live && Boolean(process.env.WT_SESSION);
+        const view = new ProgressView(stages, tasks, {
+            live,
+            glyphs: rich ? RICH_GLYPHS : CONSOLE_GLYPHS,
+            now: () => Date.now(),
+            screen: {
+                write: (text) => void process.stdout.write(text),
+                columns: () => process.stdout.columns ?? COLUMNS,
+            },
+        });
+        return new BootConsole(view, live);
+    }
+    /** Prints the header and takes the console. */
+    start(header) {
+        record(header);
+        this.open = true;
+        this.view.start(header);
+        routeConsole({
+            line: (message, stage) => this.view.line(message, stage),
+            warning: (message) => this.view.warning(message),
+            notice: (message) => this.view.notice(message),
+        });
+        // Programs the boot starts would draw over the block (or between the plain stages): their output goes to the log;
+        // the hooks keep the terminal. After the release too: the background steps must not write into the session.
+        routeOutput({ capturing: () => !this.open || this.view.capturing, line: (text) => log(text) });
+        if (!this.live)
+            return;
+        this.timer = setInterval(() => this.view.tick(), FRAME_MS);
+        this.timer.unref();
+        // A crash must not leave the terminal without its cursor.
+        process.once('exit', () => {
+            if (this.open)
+                process.stdout.write(SHOW_CURSOR);
+        });
+    }
+    started(task) {
+        this.view.started(task);
+        this.view.tick();
+    }
+    finished(task, outcome) {
+        this.view.finished(task, outcome);
+        this.view.tick();
+    }
+    /** What a running task's place on its row says (null: its title). */
+    detail(taskId, text) {
+        this.view.detail(taskId, text);
+    }
+    /** The tool summary: to the file now, to the console once the boot is ready. */
+    summary(lines) {
+        for (const line of lines)
+            record('  ' + line);
+        this.view.summary(lines);
+    }
+    /** Runs `work` that writes to the terminal itself (the hooks). */
+    aside(work) {
+        return this.view.aside(work);
+    }
+    /**
+     * The final summary (`ready`, or null when the boot failed); the console is the log's own again. Programs' output
+     * keeps going to the log (the background runs quiet: file only).
+     */
+    release(ready) {
+        if (!this.open)
+            return;
+        this.open = false;
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        routeConsole(null);
+        if (ready)
+            for (const line of readyLines(ready))
+                record(line);
+        this.view.release(ready);
+    }
+}

package/dist/guest/boot/boot.d.ts

@@ -15,6 +15,9 @@ export declare class Boot {
     private secrets;
     private basePath;
     private readonly startedAt;
+    private readonly who;
+    /** The console while the boot runs: the stage rows, warnings and summary (released before the first session). */
+    private readonly progress;
     private openGate;
     private readonly gate;
     /** The boot is ready: the runner no longer writes the status (the session owns it). */
@@ -24,9 +27,13 @@ export declare class Boot {
     private stepsDone;
     private stepsTotal;
     run(): Promise<void>;
+    /** The prelude, then every foreground task (the console shows them). */
+    private foreground;
     private stageTitle;
-    /** The names shown for work that goes on after the boot is ready. */
+    /** The toolchain steps that go on after the boot is ready (Visual Studio and what needs it), in plan order. */
     private backgroundNames;
+    /** Runs a stage's hooks; they write to the terminal themselves, so the progress block steps aside for them. */
+    private hooks;
     /**
      * The host's one-shot file, read once. Your saved service sign-ins (accounts.<kind>.share) go to their tools before
      * anything opens them, and leave memory at once; what they give the agent (EXPO_TOKEN ...) joins its environment

package/dist/guest/boot/boot.js

@@ -15,7 +15,7 @@ import { linkProfileDirsAsync } from '../agents/profile-links.js';
 import { restoreClaudeMem } from '../setup/claude-mem.js';
 import { syncClaudeProfile } from '../setup/claude-profile.js';
 import { agentEnv, persistEnvironment } from '../setup/environment.js';
-import { runHooks } from '../setup/hooks.js';
+import { hasHooks, runHooks } from '../setup/hooks.js';
 import { applyAllowOnly, proxyEnv } from '../network/allow-only.js';
 import { applyNetworkPolicy, networkProblems } from '../network/firewall.js';
 import { writeManagedSettings } from '../setup/managed-policy.js';
@@ -37,12 +37,14 @@ import { now } from '../../shared/channel/run-dir.js';
 import { writeJsonAtomic } from '../../shared/io/json.js';
 import { viewSession } from '../sessions/viewer.js';
 import { saveBootEnv } from './boot-env.js';
-import { BOOT_DEFS, STAGES, stageTitle } from './graph.js';
-import { BootRunner, bootSummary, seconds } from './runner.js';
+import { BOOT_DEFS, STAGES, stageName, stageTitle } from './graph.js';
+import { BootRunner, duration } from './runner.js';
+import { BootConsole } from './boot-console.js';
+import { stepsDetail } from './progress-view.js';
 import { installPools } from '../runtime/pools.js';
 import { primaryProject, saveProjectStatus } from './project-status.js';
 import { dryRun, isWin, localDir, logsDir, run, toolsDir } from '../runtime/paths.js';
-import { log, logPath, runQuiet, warn, withLogContext } from '../runtime/log.js';
+import { log, logPath, notice, record, runQuiet, warn, withLogContext } from '../runtime/log.js';
 import { mkdirp } from '../runtime/fs.js';
 import { session, workspace } from '../runtime/session.js';
 import { applyBootEnvironment, BOOT_SECRETS_VARIABLE, takeSecrets } from '../runtime/secrets.js';
@@ -50,7 +52,20 @@ import { setBackgroundWork, setSandboxStatus } from '../runtime/status.js';
 import { errMsg } from '../../core/util/errors.js';
 const PRIMARY_POLLS = 600;
 const POLL_MS = 500;
-const VSCODE_LANGUAGES = ['python', 'java', 'go', 'rust', 'cpp', 'msvc', 'dotnet', 'ruby', 'php', 'deno', 'pwsh'];
+const VSCODE_LANGUAGES = [
+    'python',
+    'java',
+    'go',
+    'rust',
+    'cpp',
+    'msvc',
+    'unreal',
+    'dotnet',
+    'ruby',
+    'php',
+    'deno',
+    'pwsh',
+];
 function startDaemon(env, secrets) {
     spawn(process.execPath, [path.join(path.dirname(process.argv[1]), 'daemon.js')], {
         detached: true,
@@ -159,6 +174,12 @@ export class Boot {
     secrets = Object.freeze({});
     basePath = '';
     startedAt = Date.now();
+    who = {
+        ...(session.vpn ? { vpnServer: session.vpn.server } : {}),
+        agent: session.harnessName,
+    };
+    /** The console while the boot runs: the stage rows, warnings and summary (released before the first session). */
+    progress = BootConsole.create(Array.from({ length: STAGES }, (_, i) => ({ stage: i + 1, name: stageName(i + 1, this.who) })), BOOT_DEFS.filter((d) => !d.background), { plain: dryRun });
     openGate = () => undefined;
     gate = new Promise((resolve) => {
         this.openGate = resolve;
@@ -170,14 +191,39 @@ export class Boot {
     stepsDone = 0;
     stepsTotal = 0;
     async run() {
-        log('Agent sandbox: ' +
-            session.project +
-            ' | workspace ' +
-            workspace +
-            ' | agent ' +
-            session.harnessName +
-            ' | log ' +
-            logPath);
+        const agent = session.harness ? session.harnessName : 'no agent';
+        this.progress.start('Agent sandbox · ' + session.project + ' · ' + agent + ' · ' + workspace);
+        let runner;
+        try {
+            runner = await this.foreground();
+        }
+        catch (e) {
+            this.progress.release(null);
+            throw e;
+        }
+        this.progress.release({
+            ms: Date.now() - this.startedAt,
+            outcomes: runner.results(),
+            background: this.backgroundNames(),
+            logPath,
+        });
+        if (dryRun) {
+            // Same graph, one task at a time: the background tasks run in place, right after the session.
+            this.openGate();
+            await runner.run('background');
+            return;
+        }
+        this.openGate();
+        const later = runner.run('background');
+        // The viewer owns the console now: the background tasks write to the log file only.
+        if (session.harness && session.autoSession !== false && process.stdin.isTTY) {
+            await viewSession(session.launchId);
+            log('\nThis window stays open in ' + workspace + '. Other sessions keep running in their own tabs.');
+        }
+        await later.catch((e) => warn('Background work failed: ' + errMsg(e)));
+    }
+    /** The prelude, then every foreground task (the console shows them). */
+    async foreground() {
         if (!fs.statSync(workspace, { throwIfNoEntry: false })?.isDirectory())
             throw new Error('Workspace folder is missing in the sandbox: ' + workspace);
         this.basePath = process.env.PATH ?? '';
@@ -189,7 +235,7 @@ export class Boot {
         prepareGithubFolder(this.secrets.githubToken);
         installPools();
         const runner = new BootRunner(BOOT_DEFS, this.tasks(), {
-            say: (line, quiet) => (quiet ? runQuiet(() => log(line)) : log(line)),
+            trace: (line) => record(line),
             warn: (line, quiet) => (quiet ? runQuiet(() => warn(line)) : warn(line)),
             now: () => Date.now(),
             dryRun,
@@ -199,36 +245,26 @@ export class Boot {
                 this.lastStatus = s;
                 this.publish();
             },
-            inContext: (ctx, work) => withLogContext({ prefix: ctx.prefix, quiet: ctx.quiet }, work),
+            observer: this.progress,
+            inContext: (ctx, work) => withLogContext({ stage: ctx.stage, task: ctx.title, quiet: ctx.quiet }, work),
         });
         await runner.run('foreground');
-        const background = this.backgroundNames();
-        log(bootSummary(Date.now() - this.startedAt, runner.results(), background, logPath));
-        if (dryRun) {
-            // Same graph, one task at a time: the background tasks run in place, right after the session.
-            this.openGate();
-            await runner.run('background');
-            return;
-        }
-        this.openGate();
-        const later = runner.run('background');
-        // The viewer owns the console now: the background tasks write to the log file only.
-        if (session.harness && session.autoSession !== false && process.stdin.isTTY) {
-            await viewSession(session.launchId);
-            log('\nThis window stays open in ' + workspace + '. Other sessions keep running in their own tabs.');
-        }
-        await later.catch((e) => warn('Background work failed: ' + errMsg(e)));
+        return runner;
     }
     stageTitle(n) {
-        return stageTitle(n, { ...(session.vpn ? { vpnServer: session.vpn.server } : {}), agent: session.harnessName });
+        return stageTitle(n, this.who);
     }
-    /** The names shown for work that goes on after the boot is ready. */
+    /** The toolchain steps that go on after the boot is ready (Visual Studio and what needs it), in plan order. */
     backgroundNames() {
         const t = this.tools;
         if (!t?.later)
             return [];
-        const later = t.names.filter((n) => !(n in t.steps));
-        return later.length ? [later.slice(0, 3).join(', ') + (later.length > 3 ? ' ...' : '')] : [];
+        return t.names.filter((n) => !(n in t.steps));
+    }
+    /** Runs a stage's hooks; they write to the terminal themselves, so the progress block steps aside for them. */
+    hooks(stage, env) {
+        if (hasHooks(stage))
+            this.progress.aside(() => runHooks(stage, env));
     }
     /**
      * The host's one-shot file, read once. Your saved service sign-ins (accounts.<kind>.share) go to their tools before
@@ -262,7 +298,7 @@ export class Boot {
         setSandboxStatus(s.phase, s.message, {
             step: s.step,
             steps: STAGES,
-            title: this.stageTitle(s.step).replace(/ \(.*\)$/, ''),
+            title: stageName(s.step, this.who),
             active: [...s.running.map((name) => ({ name })), ...this.activeSteps],
             done: this.stepsDone,
             total: this.stepsTotal,
@@ -281,7 +317,7 @@ export class Boot {
             },
             audit: () => enableProcessAudit(),
             // 2 - pre-provision hooks and desktop
-            hooksPreProvision: () => runHooks('pre-provision', process.env),
+            hooksPreProvision: () => this.hooks('pre-provision', process.env),
             desktop: () => applyPersonalization(),
             browserGpu: () => keepBrowsersOffGpu(),
             // 3 - developer tools
@@ -343,7 +379,7 @@ export class Boot {
                     await agents.provision(session.harnessName, session.harness, this.env);
             },
             // 8 - pre-agent hooks
-            hooksPreAgent: () => runHooks('pre-agent', this.env),
+            hooksPreAgent: () => this.hooks('pre-agent', this.env),
             // 9 - start
             session: () => this.start(),
             // After the first session runs
@@ -371,6 +407,7 @@ export class Boot {
             ...(session.pcInstalls ? { pcInstalls: session.pcInstalls } : {}),
         }, {
             progress: (p) => {
+                this.progress.detail('toolchains', stepsDetail(p.active.map((a) => a.name + (a.percent === undefined ? '' : ' ' + Math.round(a.percent) + '%')), p.done, p.total));
                 this.activeSteps = p.active;
                 this.stepsDone = p.done;
                 this.stepsTotal = p.total;
@@ -424,8 +461,7 @@ export class Boot {
             lan: this.lan,
         });
         saveProjectStatus(primaryProject(), workspace, 'ready', 'Ready', session.databases ?? [], this.summary);
-        for (const line of this.summary)
-            log('  ' + line);
+        this.progress.summary(this.summary);
     }
     /** The toolchains' lines, then the missing protections, allowOnly and VS Code (in this order). */
     summaryLines(toolchainLines) {
@@ -441,7 +477,8 @@ export class Boot {
         const tools = this.tools;
         if (!tools?.later)
             return;
-        const name = this.backgroundNames()[0] ?? 'Visual Studio';
+        const names = this.backgroundNames();
+        const name = names.length ? names.slice(0, 3).join(', ') + (names.length > 3 ? ' ...' : '') : 'Visual Studio';
         const began = Date.now();
         setBackgroundWork([{ name, state: 'running' }]);
         log('Background: ' + name + ' (installing)');
@@ -468,7 +505,7 @@ export class Boot {
             saveProjectStatus(primaryProject(), workspace, 'ready', 'Ready', session.databases ?? [], this.summary);
             await soft('Sandbox guide for the agent', () => writeGuides(this.summary, this.lan));
             setBackgroundWork([{ name, state: 'done' }]);
-            log('Background done in ' + seconds(Date.now() - began) + ': ' + name);
+            log('Background done in ' + duration(Date.now() - began) + ': ' + name);
         }
         catch (e) {
             setBackgroundWork([{ name, state: 'failed' }]);
@@ -512,7 +549,7 @@ export class Boot {
         });
         if (!(await waitForPrimary()))
             throw new Error('The agent session did not start. Logs: ' + logsDir);
-        log('If Claude asks you to sign in, do it once; the login is saved in persistent storage.');
+        notice('If Claude asks you to sign in, do it once; the login is saved in persistent storage.');
     }
 }
 export function runBoot() {