windows-development-sandbox 1.27.3 → 1.29.0

package/dist/host/guard/commands.js

@@ -16,6 +16,7 @@ export const COMMANDS = new RegExp('^(' +
         // this tool's own commands (package.json "bin")
         'sandbox',
         'windows-development-sandbox',
+        // Removed commands, still blocked: a planted claude-sbx.cmd would run on a PC where nothing else has that name.
         'agent-sandbox',
         'claude-sbx',
         'claude-sandbox',

package/dist/host/health/path-copies.d.ts

@@ -1,4 +1,4 @@
-export declare const COMMAND_NAMES: readonly ["sandbox", "agent-sandbox", "claude-sbx"];
+export declare const COMMAND_NAMES: readonly ["sandbox"];
 export type CopyKind = 'managed-machine' | 'managed-user' | 'npm' | 'old-scripts' | 'other';
 /** One folder on the PATH that holds the commands. */
 export interface CommandCopy {

package/dist/host/health/path-copies.js

@@ -1,10 +1,10 @@
-// Every copy of the sandbox commands on the PATH (sandbox, agent-sandbox, claude-sbx), in the order Windows finds them:
+// Every copy of the sandbox commands on the PATH (sandbox), in the order Windows finds them:
 // the machine PATH, then yours, and in each folder PATHEXT order. Read only: nothing is run, and a file is only checked
 // for existing. Used by doctor to say which copy runs and how to remove each of the others.
 import fs from 'node:fs';
 import path from 'node:path';
 import { expandVariables } from '../../core/util/index.js';
-export const COMMAND_NAMES = ['sandbox', 'agent-sandbox', 'claude-sbx'];
+export const COMMAND_NAMES = ['sandbox'];
 const normal = (p) => path
     .normalize(expandVariables(p.trim().replace(/^"|"$/g, '')))
     .replace(/[\\/]+$/, '')

package/dist/host/install/index.d.ts

@@ -1,5 +1,5 @@
 export { type InstallScope, InstallLayout, compareVersions, VERSION_PATTERN, NODE_PATTERN } from './layout.js';
-export { shimText, readBins, writeShims } from './shims.js';
+export { shimText, readBins, writeShims, removeStaleShims, REMOVED_COMMANDS } from './shims.js';
 export { InstallRecordFile, InstallRecordSchema, type InstallRecord } from './install-record.js';
 export { UpdateTask } from './scheduled-task.js';
 export { machineInstall, userInstall, managedInstalls, describeCopy, hiddenInstallLine, takeHiddenInstallNotice, } from './copies.js';

package/dist/host/install/index.js

@@ -1,5 +1,5 @@
 export { InstallLayout, compareVersions, VERSION_PATTERN, NODE_PATTERN } from './layout.js';
-export { shimText, readBins, writeShims } from './shims.js';
+export { shimText, readBins, writeShims, removeStaleShims, REMOVED_COMMANDS } from './shims.js';
 export { InstallRecordFile, InstallRecordSchema } from './install-record.js';
 export { UpdateTask } from './scheduled-task.js';
 export { machineInstall, userInstall, managedInstalls, describeCopy, hiddenInstallLine, takeHiddenInstallNotice, } from './copies.js';

package/dist/host/install/shims.d.ts

@@ -6,5 +6,12 @@ import type { InstallLayout } from './layout.js';
 export declare function shimText(name: string, kind: 'cmd' | 'sh', target?: string): string;
 /** The commands a package.json declares (name -> program path inside the package). Invalid names are refused. */
 export declare function readBins(packageJson: unknown): Record<string, string>;
-/** Writes <bin>.cmd and <bin> for every command in `bins` (name -> program path inside the package). */
+/** Commands earlier versions installed (name -> program they ran). Their shims go when nothing declares them. */
+export declare const REMOVED_COMMANDS: Readonly<Record<string, string>>;
+/** Deletes the shim of a removed command, only when the file is exactly the text we wrote for it. */
+export declare function removeStaleShims(layout: InstallLayout, keep?: Readonly<Record<string, string>>): void;
+/**
+ * Writes <bin>.cmd and <bin> for every command in `bins` (name -> program path inside the package), and removes the
+ * shims of commands that no longer exist.
+ */
 export declare function writeShims(layout: InstallLayout, bins: Record<string, string>): void;

package/dist/host/install/shims.js

@@ -1,6 +1,7 @@
 // The commands on PATH. Each one is a tiny script that reads the two pointer files and runs the version they name, so
 // an update never has to rewrite a shim: it only moves the pointers. A .cmd for cmd.exe and PowerShell, and a POSIX
 // script (same name, no extension) for Git Bash.
+import fs from 'node:fs';
 import path from 'node:path';
 import { z } from 'zod';
 import { fail } from '../../core/util/index.js';
@@ -46,10 +47,47 @@ export function readBins(packageJson) {
             fail('package.json declares a command with an invalid name: ' + name);
     return bins;
 }
-/** Writes <bin>.cmd and <bin> for every command in `bins` (name -> program path inside the package). */
+/** Commands earlier versions installed (name -> program they ran). Their shims go when nothing declares them. */
+export const REMOVED_COMMANDS = {
+    'agent-sandbox': 'dist/bin/agent-sandbox.js',
+    'claude-sbx': 'dist/bin/claude-sbx.js',
+    'claude-sandbox': 'dist/bin/claude-sbx.js',
+    'codex-sbx': 'dist/bin/codex-sbx.js',
+    'codex-sandbox': 'dist/bin/codex-sbx.js',
+    'gemini-sbx': 'dist/bin/gemini-sbx.js',
+    'gemini-sandbox': 'dist/bin/gemini-sbx.js',
+    'claude-host': 'dist/bin/claude-host.js',
+    'sbx-show': 'dist/bin/sbx-show.js',
+    'sbx-hide': 'dist/bin/sbx-hide.js',
+};
+/** Deletes the shim of a removed command, only when the file is exactly the text we wrote for it. */
+export function removeStaleShims(layout, keep = {}) {
+    for (const [name, target] of Object.entries(REMOVED_COMMANDS)) {
+        if (name in keep)
+            continue;
+        for (const [file, kind] of [
+            [name + '.cmd', 'cmd'],
+            [name, 'sh'],
+        ]) {
+            const full = path.join(layout.binDir, file);
+            try {
+                if (fs.readFileSync(full, 'utf8') === shimText(name, kind, target))
+                    fs.rmSync(full, { force: true });
+            }
+            catch {
+                // Not there, or not readable: nothing of ours to remove.
+            }
+        }
+    }
+}
+/**
+ * Writes <bin>.cmd and <bin> for every command in `bins` (name -> program path inside the package), and removes the
+ * shims of commands that no longer exist.
+ */
 export function writeShims(layout, bins) {
     for (const [name, target] of Object.entries(bins)) {
         writeFileAtomic(path.join(layout.binDir, name + '.cmd'), shimText(name, 'cmd', target));
         writeFileAtomic(path.join(layout.binDir, name), shimText(name, 'sh', target));
     }
+    removeStaleShims(layout, bins);
 }

package/dist/host/launch/generate.js

@@ -15,6 +15,7 @@ import { folderAttachment } from '../storage/providers/index.js';
 import { assertTestWritable } from '../test-guard.js';
 import { writeLoadSettings } from '../life/watchdog.js';
 import { loadProfileOf } from './risk-notes.js';
+import { launchHasSandboxSource, stagePcLogs } from './pc-logs.js';
 import { planBootProjects } from './boot-projects.js';
 import { planDatabases } from './database-plan.js';
 import { collectMappings } from './mappings.js';
@@ -135,6 +136,9 @@ opened) {
     fs.writeFileSync(path.join(launchPath, 'env.cmd'), logonEnv(session.workspace), 'utf8');
     copyRuntime(o.packageRoot, launchPath);
     stageHooks(o.packageRoot, launchPath, o.run.scripts);
+    // Developing the sandbox inside a sandbox: this PC's recent crash reports and logs (never for other projects).
+    if (launchHasSandboxSource([workspaceHost, ...boot.projects.map((p) => p.host)], o.packageRoot))
+        stagePcLogs(storageRoot, dataPath, launchPath);
     const enginePlan = engine.plan(buildLaunchPlan({
         config,
         memoryMb,

package/dist/host/launch/index.d.ts

@@ -10,3 +10,4 @@ export { msvcHint, projectEntries, readProjectFiles, uvHint } from './project-sc
 export { hostDatabases, pcLanguages } from './pc-scan.js';
 export { collectMappings } from './mappings.js';
 export { RUNTIME_FILES, copyRuntime, gitIdentity, stageGitIdentity, stageHooks, stageScripts } from './stage.js';
+export { isSandboxSourceRepo, launchHasSandboxSource, stagePcLogs } from './pc-logs.js';

package/dist/host/launch/index.js

@@ -10,3 +10,4 @@ export { msvcHint, projectEntries, readProjectFiles, uvHint } from './project-sc
 export { hostDatabases, pcLanguages } from './pc-scan.js';
 export { collectMappings } from './mappings.js';
 export { RUNTIME_FILES, copyRuntime, gitIdentity, stageGitIdentity, stageHooks, stageScripts } from './stage.js';
+export { isSandboxSourceRepo, launchHasSandboxSource, stagePcLogs } from './pc-logs.js';

package/dist/host/launch/pc-logs.d.ts

@@ -0,0 +1,6 @@
+/** Whether a folder is a checkout (or git worktree) of this sandbox's own source repo, judged by the installed copy. */
+export declare function isSandboxSourceRepo(folder: string, packageRoot: string): boolean;
+/** Whether this launch has the sandbox's own source repo among its projects (the launch folder or a mapped project). */
+export declare function launchHasSandboxSource(folders: readonly string[], packageRoot: string): boolean;
+/** Copies the PC's recent crash reports and log tails into <launchPath>\pc-logs. Returns the folder. */
+export declare function stagePcLogs(storageRoot: string, dataPath: string, launchPath: string): string;

package/dist/host/launch/pc-logs.js

@@ -0,0 +1,129 @@
+// PC logs for developing the sandbox inside a sandbox: when a launch includes this very source repo, the PC's recent
+// crash reports and logs are copied into <launch>\pc-logs (C:\AgentLaunch\pc-logs, read-only, gone with the sandbox).
+// The gate is the repository url: a repo that only claims the package name does not pass. If one ever did, it would
+// see the owner's crash diagnostics (memory numbers, Windows events, process names), which hold no secrets.
+// Nothing else from <storage> is copied: no state files, logins, secrets or session ledger.
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { assertNoLinks, ensureDir } from '../../core/util/index.js';
+const PACKAGE_NAME = 'windows-development-sandbox';
+const MAX_PACKAGE_JSON_BYTES = 256 * 1024;
+const MAX_REPORTS = 10;
+const MAX_REPORT_BYTES = 64 * 1024;
+const TAIL_BYTES = 256 * 1024;
+const PackageSchema = z.object({
+    name: z.string(),
+    repository: z.union([z.string(), z.object({ url: z.string().optional() }).passthrough()]).optional(),
+});
+function repoUrl(pkg) {
+    const url = typeof pkg.repository === 'string' ? pkg.repository : pkg.repository?.url;
+    if (!url)
+        return null;
+    return url
+        .trim()
+        .toLowerCase()
+        .replace(/^git\+/, '')
+        .replace(/\.git$/, '')
+        .replace(/\/+$/, '');
+}
+/** The package.json in a folder, read with a size cap and no links; null when missing, too big or not valid. */
+function readPackage(folder) {
+    try {
+        const file = path.join(folder, 'package.json');
+        assertNoLinks(folder, file);
+        const stat = fs.lstatSync(file);
+        if (!stat.isFile() || stat.size > MAX_PACKAGE_JSON_BYTES)
+            return null;
+        const parsed = PackageSchema.safeParse(JSON.parse(fs.readFileSync(file, 'utf8')));
+        return parsed.success ? parsed.data : null;
+    }
+    catch {
+        // No package.json, a link, or not JSON: not the sandbox's source.
+        return null;
+    }
+}
+/** Whether a folder is a checkout (or git worktree) of this sandbox's own source repo, judged by the installed copy. */
+export function isSandboxSourceRepo(folder, packageRoot) {
+    const own = readPackage(packageRoot);
+    const ownUrl = own ? repoUrl(own) : null;
+    if (!ownUrl)
+        return false;
+    const pkg = readPackage(folder);
+    return pkg !== null && pkg.name === PACKAGE_NAME && repoUrl(pkg) === ownUrl;
+}
+/** Plain file, no links on the way: its first `max` bytes (head) or last `max` bytes (tail); null when unreadable. */
+function readBounded(root, file, max, from) {
+    try {
+        assertNoLinks(root, file);
+        const stat = fs.lstatSync(file);
+        if (!stat.isFile())
+            return null;
+        const length = Math.min(stat.size, max);
+        const buffer = Buffer.alloc(length);
+        const fd = fs.openSync(file, 'r');
+        try {
+            fs.readSync(fd, buffer, 0, length, from === 'tail' ? stat.size - length : 0);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        return buffer;
+    }
+    catch {
+        // Missing or unreadable: left out.
+        return null;
+    }
+}
+const README = [
+    'These files come from the PC that started this sandbox: its recent crash reports and logs, for developing the',
+    'sandbox itself. They are read-only here and gone when the sandbox closes.',
+    '',
+    'They are not part of the repo: never copy them into the workspace and never commit them.',
+    '',
+    'crashes\\   the newest crash reports (what Windows logged when a sandbox ended, plus the memory log)',
+    '*.log       the last 256 KB of the PC memory log, the host watcher log and the live-folders log',
+    '',
+].join('\r\n');
+/** Whether this launch has the sandbox's own source repo among its projects (the launch folder or a mapped project). */
+export function launchHasSandboxSource(folders, packageRoot) {
+    return folders.some((f) => isSandboxSourceRepo(f, packageRoot));
+}
+/** Copies the PC's recent crash reports and log tails into <launchPath>\pc-logs. Returns the folder. */
+export function stagePcLogs(storageRoot, dataPath, launchPath) {
+    const target = path.join(launchPath, 'pc-logs');
+    ensureDir(target);
+    fs.writeFileSync(path.join(target, 'README.txt'), README, 'utf8');
+    const crashes = path.join(storageRoot, 'logs', 'crashes');
+    let names = [];
+    try {
+        assertNoLinks(storageRoot, crashes);
+        names = fs
+            .readdirSync(crashes)
+            .filter((f) => /^crash-[\w.-]+\.txt$/.test(f))
+            .sort()
+            .slice(-MAX_REPORTS);
+    }
+    catch {
+        // No reports folder yet: none to copy.
+    }
+    for (const name of names) {
+        const text = readBounded(storageRoot, path.join(crashes, name), MAX_REPORT_BYTES, 'head');
+        if (!text)
+            continue;
+        ensureDir(path.join(target, 'crashes'));
+        fs.writeFileSync(path.join(target, 'crashes', name), text);
+    }
+    const data = path.basename(dataPath);
+    const tails = [
+        [path.join(storageRoot, 'logs', 'host-memory-' + data + '.log'), 'host-memory.log'],
+        [path.join(storageRoot, 'logs', 'host-sync-' + data + '.log'), 'host-sync.log'],
+        [path.join(storageRoot, 'state', 'live-folders.log'), 'live-folders.log'],
+    ];
+    for (const [source, name] of tails) {
+        const text = readBounded(storageRoot, source, TAIL_BYTES, 'tail');
+        if (text)
+            fs.writeFileSync(path.join(target, name), text);
+    }
+    return target;
+}

package/dist/host/life/crash-report.d.ts

@@ -22,6 +22,10 @@ export declare function findingLines(events: readonly StopEvent[]): string[];
 export declare function findDumps(dirs: readonly string[], since: Date): DumpFile[];
 /** Whether the newest launch started at or before `lastSeen` had vGPU on (host-only .wsb in <storage>\launches). */
 export declare function launchHadVgpu(storageRoot: string, lastSeen: string): boolean;
+/**
+ * "This PC still had ..." from the last line of its memory log, when RAM and commit were both 4 GB or more free (pure).
+ */
+export declare function memoryWasFineLine(hostMemoryLog: string): string | null;
 /**
  * The report text (pure): what happened (the sandbox's or this PC's stop code, where the dump is) and the memory log's
  * last lines. `memoryLog` is the sandbox's own file, so it is shown through safeText.

package/dist/host/life/crash-report.js

@@ -54,7 +54,10 @@ export function findingLines(events) {
         lines.push('WHEA-Logger: Windows reported a hardware error (CPU, memory, a bus or a disk): heat or failing hardware.');
     if (has((e) => lower(e).startsWith('hyper-v')))
         lines.push("Hyper-V events: the sandbox's virtual machine (or the service that runs it) reported a problem.");
-    if (has((e) => /^(application error|windows error reporting)$/i.test(e.provider)))
+    const isAppCrash = (e) => /^(application error|windows error reporting)$/i.test(e.provider);
+    if (has((e) => isAppCrash(e) && /vmwp\.exe/i.test(e.process)))
+        lines.push("vmwp.exe, the Windows program that runs the sandbox's VM, crashed. That is a fault in Windows' Hyper-V code or a driver it uses (with vGPU on, usually the graphics driver), not a program inside the sandbox running out of memory.");
+    else if (has(isAppCrash))
         lines.push("A crash report names vmwp.exe or vmmem, the programs that hold the sandbox's VM.");
     return lines;
 }
@@ -122,6 +125,30 @@ function hostMemoryTail(storageRoot, dataPath) {
         return '';
     }
 }
+/**
+ * "This PC still had ..." from the last line of its memory log, when RAM and commit were both 4 GB or more free (pure).
+ */
+export function memoryWasFineLine(hostMemoryLog) {
+    const last = hostMemoryLog
+        .split(/\r?\n/)
+        .filter((l) => l.trim() !== '')
+        .pop();
+    if (!last)
+        return null;
+    const ram = /RAM free\/total MB (\d{1,9})\/(\d{1,9})/.exec(last);
+    const commit = /commit free\/limit MB (\d{1,9})\/(\d{1,9})/.exec(last);
+    if (!ram || !commit)
+        return null;
+    const freeRam = Number(ram[1]);
+    const freeCommit = Number(commit[1]);
+    if (freeRam < 4096 || freeCommit < 4096)
+        return null;
+    return ('This PC still had ' +
+        Math.floor(freeRam / 1024) +
+        ' GB of RAM and ' +
+        Math.floor(freeCommit / 1024) +
+        ' GB of memory (RAM plus paging file) free just before, so it did not run out of memory.');
+}
 /**
  * The report text (pure): what happened (the sandbox's or this PC's stop code, where the dump is) and the memory log's
  * last lines. `memoryLog` is the sandbox's own file, so it is shown through safeText.
@@ -152,6 +179,7 @@ export function crashReportText(cause, events, memoryLog, lastSeen, extra = {})
         .map((l) => '  ' + safeText(l));
     const freeze = freezeLine(cause, lastSeen);
     const meaning = findingLines(unique);
+    const fine = memoryWasFineLine(extra.hostMemoryLog ?? '');
     const dumps = extra.dumps ?? [];
     const vgpu = extra.vgpu ? ['vGPU was on for this sandbox. ' + vgpuWarning('its launch settings'), ''] : [];
     return [
@@ -165,6 +193,7 @@ export function crashReportText(cause, events, memoryLog, lastSeen, extra = {})
         ...vgpu,
         'What that usually means:',
         ...(meaning.length ? meaning.map((l) => '  ' + l) : ['  (no memory, blue screen or hardware event was logged)']),
+        ...(fine ? ['  ' + fine] : []),
         '',
         'Crash dumps Windows left (C:\\Windows\\Minidump, MEMORY.DMP):',
         ...(dumps.length ? dumps.map((d) => '  ' + d.name + '  ' + d.at) : ['  (none from that time)']),

package/dist/host/life/last-end.js

@@ -39,6 +39,7 @@ export function heartbeatLine(hb) {
         hb.step +
         (hb.hostStep > 0 ? ' (this PC asked for step ' + hb.hostStep + ')' : '') +
         (hb.diskQueueReported !== undefined ? ', this PC disk queue ' + hb.diskQueueReported : '') +
+        (hb.held ? ', ' + hb.held + ' builds held by the memory gate' : '') +
         (top ? '; biggest: ' + top : ''));
 }
 /** The likeliest reason, from the last heartbeat (pure). */

package/dist/host/sandbox/platform.js

@@ -63,7 +63,7 @@ export function assertCanLaunch(owner) {
             ? other + ' (Windows allows one per PC).'
             : 'A Windows Sandbox is already running (Windows allows one at a time).', other
             ? 'Use it with sandbox attach if it is shared with you, or start yours after it stops.'
-            : 'Attach to it with sandbox claude -t, show it with sbx-show, or shut it down with sandbox stop.');
+            : 'Attach to it with sandbox claude -t, show it with sandbox show, or shut it down with sandbox stop.');
     }
 }
 /** cmd.exe expands %VAR% and ^ even inside quotes, and a quote ends them: such a path could run something else. */

package/dist/host/sandbox/window.js

@@ -1,5 +1,5 @@
 // Headless mode: Windows Sandbox always opens its client window, so we hide it (ShowWindow SW_HIDE) as soon as it
-// appears. The VM and the logged-in session keep running; `sbx-show` brings the window back. The work is done by
+// appears. The VM and the logged-in session keep running; `sandbox show` brings the window back. The work is done by
 // HostTools.exe (native\csharp\HostTools\Window.cs), else by native\scripts\*-window.ps1 with the same C#.
 import path from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';

package/dist/host/tools/windows-terminal.d.ts

@@ -19,10 +19,13 @@ declare const TerminalSettingsSchema: z.ZodObject<{
 export declare function withPwshProfile(settings: z.output<typeof TerminalSettingsSchema>, visible: boolean): z.output<typeof TerminalSettingsSchema> | null;
 /** settings.json that makes new tabs read the current environment; null when it already does. Pure. */
 export declare function withReloadEnvironment(settings: z.output<typeof TerminalSettingsSchema>): z.output<typeof TerminalSettingsSchema> | null;
+/** settings.json that copies on select; null when the user already chose (true or false). Pure. */
+export declare function withCopyOnSelect(settings: z.output<typeof TerminalSettingsSchema>): z.output<typeof TerminalSettingsSchema> | null;
 /**
  * Shows the PowerShell 7 profile once pwsh is installed in this data folder (and `allowed`, i.e. toolchains.pwsh is
  * not off), hides it otherwise. settings.json is written by the sandbox too: read with a size cap, through no links,
- * shape-checked, only rewritten when the profile changes; a file that does not parse is left alone.
+ * shape-checked, only rewritten when the profile changes or a default switch is missing (reload the environment,
+ * copy on select; a value the user set stays); a file that does not parse is left alone.
  */
 export declare function syncPwshProfile(dataPath: string, allowed: boolean): void;
 export declare function ensureTerminal(dataPath: string, refresh: boolean, options?: {

package/dist/host/tools/windows-terminal.js

@@ -24,6 +24,9 @@ const SETTINGS = {
     theme: 'dark',
     firstWindowPreference: 'defaultProfile',
     confirmCloseAllTabs: false,
+    // Copied the moment the mouse is released, so an agent's redraw cannot clear the selection first.
+    copyOnSelect: true,
+    copyFormatting: 'none',
     // New tabs pick up the PATH and variables the runner writes machine-wide after the window opened.
     compatibility: { reloadEnvironmentVariables: true },
     warning: { confirmCloseAllTabs: false, largePaste: false, multiLinePaste: false },
@@ -75,10 +78,17 @@ export function withReloadEnvironment(settings) {
         return null;
     return { ...settings, compatibility: { ...compatibility, reloadEnvironmentVariables: true } };
 }
+/** settings.json that copies on select; null when the user already chose (true or false). Pure. */
+export function withCopyOnSelect(settings) {
+    if ('copyOnSelect' in settings)
+        return null;
+    return { ...settings, copyOnSelect: true };
+}
 /**
  * Shows the PowerShell 7 profile once pwsh is installed in this data folder (and `allowed`, i.e. toolchains.pwsh is
  * not off), hides it otherwise. settings.json is written by the sandbox too: read with a size cap, through no links,
- * shape-checked, only rewritten when the profile changes; a file that does not parse is left alone.
+ * shape-checked, only rewritten when the profile changes or a default switch is missing (reload the environment,
+ * copy on select; a value the user set stays); a file that does not parse is left alone.
  */
 export function syncPwshProfile(dataPath, allowed) {
     const file = path.join(terminalDir(dataPath), 'settings', 'settings.json');
@@ -100,16 +110,22 @@ export function syncPwshProfile(dataPath, allowed) {
     }
     const withProfile = withPwshProfile(parsed, visible);
     if (withProfile) {
-        writeJson(file, withReloadEnvironment(withProfile) ?? withProfile);
+        const reloaded = withReloadEnvironment(withProfile) ?? withProfile;
+        writeJson(file, withCopyOnSelect(reloaded) ?? reloaded);
         return;
     }
-    // Only the reload switch is missing: set that one value in the text, so comments and the layout stay.
-    if (withReloadEnvironment(parsed)) {
-        const edits = modify(text, ['compatibility', 'reloadEnvironmentVariables'], true, {
-            formattingOptions: { insertSpaces: true, tabSize: 4 },
-        });
-        writeFileAtomic(file, applyEdits(text, edits));
-    }
+    // Only default switches are missing: set those values in the text, so comments and the layout stay.
+    const missing = [];
+    if (withReloadEnvironment(parsed))
+        missing.push([['compatibility', 'reloadEnvironmentVariables'], true]);
+    if (withCopyOnSelect(parsed))
+        missing.push([['copyOnSelect'], true]);
+    if (missing.length === 0)
+        return;
+    let edited = text;
+    for (const [at, value] of missing)
+        edited = applyEdits(edited, modify(edited, at, value, { formattingOptions: { insertSpaces: true, tabSize: 4 } }));
+    writeFileAtomic(file, edited);
 }
 export async function ensureTerminal(dataPath, refresh, options = {}) {
     const result = await installTerminal(dataPath, refresh);

package/dist/runtime/agent.js

@@ -25502,7 +25502,7 @@ var SandboxSchema = external_exports.strictObject({
     'The last resort that keeps the sandbox up, in MB below its commit limit (RAM plus paging file): builds are slowed down long before (sandbox.pressureResponse); only if everything the agents start together would take the sandbox to the very edge of its memory, where Windows inside it would start failing, is a build refused memory instead of Windows. "auto" = the larger of 1536 MB and 3 % of the commit limit; "none" = no backstop. Yours only: a project file cannot change it.'
   ),
   pressureResponse: external_exports.boolean().describe(
-    "When the sandbox (or this PC) runs low on memory, slow builds down in steps, like a PC that gets slower instead of failing: build programs get lower CPU and memory priority, then less CPU, then compilers take turns (the waiting ones briefly suspended and trimmed to the paging file). Nothing is stopped or killed, and the agents themselves are never touched. Yours only: a project file cannot change it."
+    "When the sandbox (or this PC) runs low on memory, slow builds down in steps, like a PC that gets slower instead of failing: build programs get lower CPU and memory priority, then less CPU, then compilers take turns (the waiting ones briefly suspended and trimmed to the paging file). Nothing is stopped or killed, and the agents themselves are never touched. A memory gate also holds new compilers and linkers for a moment when the memory of the build programs grows faster than 4 GB in 3 seconds (3 GB with vGPU), and lets them go one at a time. Yours only: a project file cannot change it."
   ),
   vGpu: external_exports.boolean().describe(
     "Virtual GPU. Off by default: Microsoft notes it widens the sandbox attack surface. The sandbox then uses this PC's graphics card, and with some graphics drivers heavy use can freeze the whole PC: turn it on only when a program in the sandbox needs the GPU (the mesa toolchain gives software OpenGL without it). Browsers in the sandbox never use it (they draw in software)."
@@ -25516,7 +25516,7 @@ var SandboxSchema = external_exports.strictObject({
   printerRedirection: external_exports.boolean().describe("Printers from this PC."),
   protectedClient: external_exports.boolean().describe("Run the sandbox window in Protected Client mode (recommended)."),
   headless: external_exports.boolean().describe(
-    "Hide the sandbox window (sbx-show brings it back). A headless sandbox shuts down when its last session ends."
+    'Hide the sandbox window ("Show the window" brings it back). A headless sandbox shuts down when its last session ends.'
   ),
   keepAwake: external_exports.boolean().describe(
     "Keep this PC from sleeping while a sandbox runs, so agents left working overnight keep going (the screen may still turn off; closing a laptop lid still sleeps it)."
@@ -27700,6 +27700,8 @@ var PressureStatusSchema = external_exports.object({
   lowered: external_exports.number().int().min(0).max(1024),
   /** Compilers waiting their turn right now (name, process id, seconds until they may go on). */
   paused: external_exports.array(external_exports.object({ name: Text(64), pid: external_exports.number().int(), seconds: external_exports.number().int().min(0).max(60) })).max(8),
+  /** Build programs the memory gate holds right now (let go one at a time). */
+  held: external_exports.number().int().min(0).max(1024).optional(),
   /** The CPU share the compilers get together (percent; 100 = no cap). */
   cpuPercent: external_exports.number().int().min(0).max(100).optional(),
   /** The PC itself asked for slowing down (its memory or CPU is low). */
@@ -27720,6 +27722,8 @@ var HeartbeatSchema = external_exports.object({
   topProcesses: external_exports.array(external_exports.object({ name: Text(64), privateMb: external_exports.number().int().min(0).max(1e7) })).max(5),
   /** The disk queue this PC last reported while asking the sandbox to slow down. */
   diskQueueReported: external_exports.number().min(0).max(1e5).optional(),
+  /** Build programs the memory gate holds right now (let go one at a time). */
+  held: external_exports.number().int().min(0).max(1024).optional(),
   /** "ending": the sandbox is shutting down in order (idle shutdown, sandbox stop, Windows shutting down). */
   phase: external_exports.enum(["ready", "working", "ending"])
 });