windows-development-sandbox 1.27.3 → 1.28.0

package/dist/guest/governor/core.d.ts

@@ -1,12 +1,62 @@
 import type { PressureStatus } from '../../shared/channel/schema.js';
-import type { LoadProfile } from '../../shared/memory/index.js';
+import { z } from 'zod';
+import { type LoadProfile } from '../../shared/memory/index.js';
 import { type GovernorState, type MemSample } from './decide.js';
+/** memgov.exe's arguments: samples every 2 s and the memory gate for this profile. */
+export declare function memgovArgs(profile: LoadProfile): string[];
+/** What the memory gate in memgov reports on its stdout (one JSON line each). */
+export declare const GateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"ready">;
+    mode: z.ZodEnum<{
+        notify: "notify";
+        poll: "poll";
+    }>;
+    growthMb: z.ZodNumber;
+    windowMs: z.ZodNumber;
+    event: z.ZodLiteral<"gate">;
+    at: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"off">;
+    reason: z.ZodString;
+    event: z.ZodLiteral<"gate">;
+    at: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"trip">;
+    grewMb: z.ZodNumber;
+    ms: z.ZodNumber;
+    jobMb: z.ZodNumber;
+    held: z.ZodArray<z.ZodObject<{
+        pid: z.ZodNumber;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    event: z.ZodLiteral<"gate">;
+    at: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"hold">;
+    pid: z.ZodNumber;
+    name: z.ZodString;
+    event: z.ZodLiteral<"gate">;
+    at: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"release">;
+    pid: z.ZodNumber;
+    name: z.ZodString;
+    heldMs: z.ZodNumber;
+    forced: z.ZodBoolean;
+    event: z.ZodLiteral<"gate">;
+    at: z.ZodNumber;
+}, z.core.$strict>], "kind">;
+export type GateEvent = z.output<typeof GateEventSchema>;
+/** One memory-log line for a gate event (names cut to 64 characters). */
+export declare function gateLine(e: GateEvent): string;
 /** The newest numbers the governor saw (for the heartbeat file). */
 export interface GovernorSnapshot {
     readonly ramFreePercent: number;
     readonly commitPercent: number;
     readonly step: number;
     readonly hostStep: number;
+    /** Build programs the memory gate holds now. */
+    readonly held: number;
     readonly diskQueue: number | null;
     readonly top: readonly {
         readonly name: string;
@@ -57,6 +107,8 @@ export declare class GovernorCore {
     get snapshot(): GovernorSnapshot | null;
     get current(): GovernorState;
     onSample(sample: MemSample): void;
+    /** An event from the memory gate in memgov: goes to the memory log. */
+    onGate(event: GateEvent): void;
     private apply;
     private note;
 }

package/dist/guest/governor/core.js

@@ -1,6 +1,94 @@
 import { now } from '../../shared/channel/run-dir.js';
+import { z } from 'zod';
+import { BURST_GATE } from '../../shared/memory/index.js';
 import { errMsg } from '../../core/util/errors.js';
-import { decide, HOLD_MS, INITIAL_STATE } from './decide.js';
+import { decide, GATE_NAMES, HOLD_MS, INITIAL_STATE, } from './decide.js';
+/** memgov.exe's arguments: samples every 2 s and the memory gate for this profile. */
+export function memgovArgs(profile) {
+    const g = BURST_GATE[profile];
+    return [
+        'serve',
+        '--interval',
+        '2',
+        '--gate',
+        [g.growthMb, g.windowMs, g.releaseMs, g.maxHoldMs].join(':'),
+        '--gate-names',
+        GATE_NAMES.join(','),
+    ];
+}
+const GateBase = { event: z.literal('gate'), at: z.number() };
+const GateName = z.string().max(128);
+const GateCount = z.number().int().min(0);
+/** What the memory gate in memgov reports on its stdout (one JSON line each). */
+export const GateEventSchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        ...GateBase,
+        kind: z.literal('ready'),
+        mode: z.enum(['notify', 'poll']),
+        growthMb: GateCount,
+        windowMs: GateCount,
+    }),
+    z.strictObject({ ...GateBase, kind: z.literal('off'), reason: z.string().max(200) }),
+    z.strictObject({
+        ...GateBase,
+        kind: z.literal('trip'),
+        grewMb: GateCount,
+        ms: GateCount,
+        jobMb: GateCount,
+        held: z.array(z.strictObject({ pid: z.number().int(), name: GateName })).max(64),
+    }),
+    z.strictObject({ ...GateBase, kind: z.literal('hold'), pid: z.number().int(), name: GateName }),
+    z.strictObject({
+        ...GateBase,
+        kind: z.literal('release'),
+        pid: z.number().int(),
+        name: GateName,
+        heldMs: GateCount,
+        forced: z.boolean(),
+    }),
+]);
+/** One memory-log line for a gate event (names cut to 64 characters). */
+export function gateLine(e) {
+    const cut = (s) => s.slice(0, 64);
+    switch (e.kind) {
+        case 'ready':
+            return ('gate: on (' +
+                e.mode +
+                "): new compilers wait when the agents' programs grow by more than " +
+                e.growthMb +
+                ' MB within ' +
+                e.windowMs / 1000 +
+                ' s');
+        case 'off':
+            return 'gate: off (' + e.reason + '): builds are only slowed down by the dial';
+        case 'trip':
+            return ("gate: the agents' programs grew " +
+                e.grewMb +
+                ' MB in ' +
+                (e.ms / 1000).toFixed(1) +
+                ' s (now ' +
+                e.jobMb +
+                ' MB); holding ' +
+                e.held.length +
+                ': ' +
+                e.held
+                    .slice(0, 8)
+                    .map((p) => cut(p.name) + ' (' + p.pid + ')')
+                    .join(', ') +
+                (e.held.length > 8 ? ' …' : ''));
+        case 'hold':
+            return 'gate: ' + cut(e.name) + ' (' + e.pid + ') waits at start while a build burst goes through in turn';
+        case 'release':
+            return ('gate: ' +
+                cut(e.name) +
+                ' (' +
+                e.pid +
+                ') goes on after ' +
+                (e.heldMs / 1000).toFixed(1) +
+                ' s' +
+                (e.forced ? ' (the longest it may wait)' : ''));
+    }
+}
 const STEP_TEXT = [
     'builds back to normal',
     'build programs at lower priority',
@@ -55,6 +143,7 @@ export class GovernorCore {
             commitPercent: d.commitPercent,
             step: d.state.step,
             hostStep: nowMs < d.state.hostUntil ? d.state.hostStep : 0,
+            held: sample.gateHeld ?? 0,
             diskQueue: null,
             top: [...sample.procs]
                 .sort((a, b) => b.mb - a.mb)
@@ -89,6 +178,7 @@ export class GovernorCore {
             paused: [...this.held]
                 .slice(0, 8)
                 .map(([pid, name]) => ({ name: name.slice(0, 64), pid, seconds: HOLD_MS / 1000 })),
+            held: sample.gateHeld ?? 0,
             cpuPercent: d.state.cpuRate,
             pcLow: nowMs < d.state.hostUntil,
             lastAction: this.lastAction.slice(0, 300),
@@ -102,6 +192,10 @@ export class GovernorCore {
             this.deps.saveStatus(status);
         }
     }
+    /** An event from the memory gate in memgov: goes to the memory log. */
+    onGate(event) {
+        this.note(gateLine(event));
+    }
     apply(action) {
         const port = this.deps.port;
         try {

package/dist/guest/governor/decide.d.ts

@@ -16,6 +16,8 @@ export interface MemSample {
     readonly commitAvailMb: number;
     /** Only the processes in the agents' job. */
     readonly procs: readonly ProcSample[];
+    /** Build programs the memory gate holds now (memgov). */
+    readonly gateHeld?: number;
 }
 export declare const isNeverTouched: (name: string) => boolean;
 export declare const canLower: (name: string) => boolean;
@@ -24,6 +26,8 @@ export declare const isLinker: (name: string) => boolean;
 export declare function linkerSlots(totalMb: number, cpus: number): number;
 export declare const isHeavyCompiler: (name: string) => boolean;
 export declare const canPause: (name: string) => boolean;
+/** What the memory gate in memgov may freeze (compilers, linkers, Unreal's shader workers); passed as --gate-names. */
+export declare const GATE_NAMES: readonly string[];
 export type Level = 'ok' | 'throttled' | 'suspending';
 export interface GovernorState {
     /** The dial: 0 nothing wrong, 1 lower priority, 2 less CPU and fewer compilers, 3 and 4 harder. */

package/dist/guest/governor/decide.js

@@ -109,6 +109,8 @@ export function linkerSlots(totalMb, cpus) {
 }
 export const isHeavyCompiler = (name) => !isNeverTouched(name) && HEAVY.has(key(name));
 export const canPause = (name) => !isNeverTouched(name) && COMPILERS.has(key(name));
+/** What the memory gate in memgov may freeze (compilers, linkers, Unreal's shader workers); passed as --gate-names. */
+export const GATE_NAMES = [...COMPILERS, 'shadercompileworker'].filter((n) => !NEVER.has(n)).sort();
 export const INITIAL_STATE = {
     step: 0,
     calm: 0,

package/dist/guest/governor/governor.js

@@ -1,6 +1,7 @@
 // The memory governor: samples the sandbox's memory every 2 seconds (memgov.exe, sandbox/csharp/MemGov.cs) and turns
 // a dial as it fills: the build programs the agents started get lower priority, lower memory priority, less CPU, and
-// take turns (decide.ts). Builds slow down; nothing fails. What it does goes to the memory log and run\pressure.json.
+// take turns (decide.ts). A memory gate in memgov also holds new compilers when memory grows faster than a few GB in
+// seconds. Builds slow down; nothing fails. What it does goes to the memory log and run\pressure.json.
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -8,14 +9,14 @@ import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { z } from 'zod';
 import { writeJsonAtomic } from '../../shared/io/json.js';
-import { DIAL_STEPS, maxCompilers } from '../../shared/memory/index.js';
+import { BURST_GATE, DIAL_STEPS, maxCompilers } from '../../shared/memory/index.js';
 import { ensureCompiled } from '../runtime/csc.js';
 import { dataDir } from '../runtime/paths.js';
 import { warn } from '../runtime/log.js';
 import { run } from '../runtime/paths.js';
 import { session } from '../runtime/session.js';
 import { errMsg } from '../../core/util/errors.js';
-import { GovernorCore } from './core.js';
+import { GateEventSchema, GovernorCore, memgovArgs, } from './core.js';
 const SampleSchema = z.object({
     ramTotalMb: z.number(),
     ramAvailMb: z.number(),
@@ -29,27 +30,36 @@ const SampleSchema = z.object({
         prio: z.enum(['idle', 'below', 'normal']).catch('normal'),
     }))
         .max(1024),
+    gateHeld: z.number().int().min(0).max(1024).optional().catch(undefined),
 });
 /** memgov.exe as a child process: samples come out of its stdout, commands go into its stdin. */
 class MemGovProcess {
+    args;
     onSample;
+    onGate;
     child = null;
-    constructor(onSample) {
+    constructor(args, onSample, onGate) {
+        this.args = args;
         this.onSample = onSample;
+        this.onGate = onGate;
     }
     start() {
         try {
-            const child = spawn(ensureCompiled('memgov'), ['serve', '--interval', '2'], {
+            const child = spawn(ensureCompiled('memgov'), [...this.args], {
                 stdio: ['pipe', 'pipe', 'ignore'],
                 windowsHide: true,
             });
             this.child = child;
             createInterface({ input: child.stdout }).on('line', (line) => {
                 try {
-                    this.onSample(SampleSchema.parse(JSON.parse(line)));
+                    const raw = JSON.parse(line);
+                    if (typeof raw === 'object' && raw !== null && raw.event === 'gate')
+                        this.onGate(GateEventSchema.parse(raw));
+                    else
+                        this.onSample(SampleSchema.parse(raw));
                 }
                 catch (e) {
-                    warn('governor: bad sample: ' + errMsg(e));
+                    warn('governor: bad line from memgov: ' + errMsg(e));
                 }
             });
             child.stdin.on('error', () => undefined);
@@ -120,13 +130,17 @@ export class Governor {
                 first.availablePercent +
                 '% free RAM or ' +
                 first.commitPercent +
-                '% commit, in steps';
+                '% commit, in steps; holds new compilers when memory grows faster than ' +
+                BURST_GATE[profile].growthMb +
+                ' MB in ' +
+                BURST_GATE[profile].windowMs / 1000 +
+                ' s';
     }
     start() {
         if (session.pressureResponse === false)
             return;
         const profile = session.loadProfile === 'gentle' ? 'gentle' : 'normal';
-        const proc = new MemGovProcess((s) => this.core?.onSample(s));
+        const proc = new MemGovProcess(memgovArgs(profile), (s) => this.core?.onSample(s), (e) => this.core?.onGate(e));
         this.core = new GovernorCore({
             port: proc,
             profile,

package/dist/guest/toolchains/native/unreal.js

@@ -1,20 +1,23 @@
 // Unreal Engine development, machine-wide (toolchains.unreal, once per boot): the DirectX End-User Runtime the engine
 // lists and the Epic Games Launcher (real installers: they run every boot), the launcher pointed at the data disk for
-// engines and given back the engines it installed there, the Windows SDK debuggers for crash dumps, and a check that
-// UnrealBuildTool finds Visual Studio the way it looks (the Setup Configuration API). Visual Studio itself is its own
-// step (visual-studio.ts), which the plan runs first; each project's engine is set up by engines/unreal-engines.ts.
+// engines and given back the engines it installed there, the Windows SDK debuggers for crash dumps, a check that
+// UnrealBuildTool finds Visual Studio the way it looks (the Setup Configuration API), and its parallel compiles capped.
+// Visual Studio itself is its own step (visual-studio.ts), which the plan runs first; each project's engine is set up
+// by engines/unreal-engines.ts.
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { errMsg } from '../../../core/util/errors.js';
 import { readValid } from '../../../shared/io/json.js';
 import { safeRemove } from '../../../shared/io/safe-remove.js';
+import { buildJobs, ubtBuildConfiguration, usableCpus } from '../../../shared/memory/index.js';
 import { VsSetupReportSchema, vsVerdict } from '../../../shared/unreal/index.js';
 import { runInstaller } from '../../runtime/pools.js';
 import { dryRun } from '../../runtime/paths.js';
 import { exists, mkdirp } from '../../runtime/fs.js';
 import { log, warn } from '../../runtime/log.js';
 import { runScriptAsync } from '../../runtime/process.js';
+import { session } from '../../runtime/session.js';
 import { ensureLauncher, fetchLauncher, placeEngines, restoreLauncherItems } from '../engines/epic-launcher.js';
 import { resetUnrealStatus, updateUnrealStatus } from '../engines/unreal-status.js';
 import { SIGNERS, signedInstaller } from '../installers.js';
@@ -68,6 +71,18 @@ async function checkVisualStudio() {
         fs.rmSync(dir, { recursive: true, force: true });
     }
 }
+/**
+ * UnrealBuildTool's per-user BuildConfiguration.xml (%APPDATA%, wiped with the sandbox): compiles at once from the
+ * sandbox's build budget, so a build start cannot outrun the memory Windows backs the sandbox with. Returns the cap.
+ */
+function capUnrealBuilds() {
+    const cpus = usableCpus(os.cpus().length, session.cpuLimitPercent ?? null);
+    const jobs = buildJobs(cpus, os.totalmem() / 1024 ** 3);
+    const appData = process.env.APPDATA ?? 'C:\\Users\\WDAGUtilityAccount\\AppData\\Roaming';
+    const dir = mkdirp(path.join(appData, 'Unreal Engine', 'UnrealBuildTool'));
+    fs.writeFileSync(path.join(dir, 'BuildConfiguration.xml'), ubtBuildConfiguration(jobs), 'utf8');
+    return jobs;
+}
 /** Runs one part, warning (not failing the step) when it does not work. */
 async function part(what, work, fallback) {
     try {
@@ -86,6 +101,9 @@ export async function setupUnreal(env, config, _ctx) {
         return;
     }
     resetUnrealStatus();
+    const jobs = await part('capping parallel compiles', async () => capUnrealBuilds(), 0);
+    if (jobs)
+        log('Unreal: UnrealBuildTool runs at most ' + jobs + ' compiles at once (the build budget)');
     await part('the DirectX End-User Runtime', installDirectX, undefined);
     const launcher = await part('the Epic Games Launcher', ensureLauncher, null);
     // Before anyone opens the launcher: engines go to the data disk, and it knows the ones it installed there before.
@@ -131,6 +149,7 @@ export async function setupUnreal(env, config, _ctx) {
                 vs.version +
                 (check.ok ? ' (UnrealBuildTool finds it)' : ' (UnrealBuildTool would NOT find it)')
             : 'no Visual Studio') +
+        (jobs ? ', at most ' + jobs + ' compiles at once' : '') +
         ', DirectX End-User Runtime' +
         (launcher ? ', Epic Games Launcher' : '') +
         (debuggers ? ', cdb/windbg' : ''));

package/dist/guest/toolchains/runtimes.js

@@ -28,12 +28,13 @@ export async function setupSingleExe(env, name, repo, pattern, exeName, dir, opt
 }
 export async function setupBun(env) {
     await setupSingleExe(env, 'bun', 'oven-sh/bun', arch === 'arm64' ? /^bun-windows-aarch64\.zip$/ : /^bun-windows-x64\.zip$/, 'bun.exe', tool('bun', 'bin'), { size: '35 MB' });
-    // Bun cannot keep its cache or temp files on a mapped folder (EINVAL); they go to the sandbox's own disk.
-    Object.assign(env.vars, {
-        BUN_INSTALL: tool('bun'),
-        BUN_INSTALL_CACHE_DIR: path.join(localDir, 'bun-cache'),
-        BUN_TMPDIR: path.join(localDir, 'bun-tmp'),
-    });
+    // Bun cannot keep its cache or temp files on a mapped folder (EINVAL); they go to the sandbox's own disk. The temp
+    // folder must exist: programs compiled with Bun (opencode) unpack their DLLs there and fail when it is missing.
+    const cache = path.join(localDir, 'bun-cache');
+    const temp = path.join(localDir, 'bun-tmp');
+    if (!dryRun)
+        [cache, temp].forEach((dir) => mkdirp(dir));
+    Object.assign(env.vars, { BUN_INSTALL: tool('bun'), BUN_INSTALL_CACHE_DIR: cache, BUN_TMPDIR: temp });
 }
 export async function setupDeno(env) {
     await setupSingleExe(env, 'deno', 'denoland/deno', arch === 'arm64' ? /^deno-aarch64-pc-windows-msvc[.]zip$/ : /^deno-x86_64-pc-windows-msvc[.]zip$/, 'deno.exe', tool('deno', 'bin'), { size: '40 MB' });

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/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)."
@@ -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"])
 });