windows-development-sandbox 1.18.2 → 1.18.3

package/dist/bin/{chunk-M4OM632I.js → chunk-M6XUQK53.js}

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

package/dist/bin/claude-host.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.js";
+} from "./chunk-3G53NNZP.js";
+import "./chunk-FQWYCF6L.js";
 
 // src/bin/claude-host.ts
 var args = process.argv.slice(2);

package/dist/bin/claude-sbx.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.js";
+} from "./chunk-3G53NNZP.js";
+import "./chunk-FQWYCF6L.js";
 
 // src/bin/claude-sbx.ts
 run(process.argv.slice(2), { harness: "claude" });

package/dist/bin/codex-sbx.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.js";
+} from "./chunk-3G53NNZP.js";
+import "./chunk-FQWYCF6L.js";
 
 // src/bin/codex-sbx.ts
 run(process.argv.slice(2), { harness: "codex" });

package/dist/bin/gemini-sbx.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.js";
+} from "./chunk-3G53NNZP.js";
+import "./chunk-FQWYCF6L.js";
 
 // src/bin/gemini-sbx.ts
 run(process.argv.slice(2), { harness: "gemini" });

package/dist/bin/sandbox.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.js";
+} from "./chunk-3G53NNZP.js";
+import "./chunk-FQWYCF6L.js";
 
 // src/bin/sandbox.ts
 run(process.argv.slice(2));

package/dist/bin/sbx-hide.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.js";
+} from "./chunk-3G53NNZP.js";
+import "./chunk-FQWYCF6L.js";
 
 // src/bin/sbx-hide.ts
 run(process.argv.slice(2), { command: "hide" });

package/dist/bin/sbx-show.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.js";
+} from "./chunk-3G53NNZP.js";
+import "./chunk-FQWYCF6L.js";
 
 // src/bin/sbx-show.ts
 run(process.argv.slice(2), { command: "show" });

package/dist/cli/commands/repair/checks/sandbox.d.ts

@@ -1,2 +1,4 @@
-import type { Check } from '../types.js';
+import type { Check, Finding } from '../types.js';
+/** A warning when the sandbox's paging file takes more than 40 % of the drive (pure); null when it is fine. */
+export declare function pageFileFinding(pageFileMb: number, driveBytes: number): Finding | null;
 export declare const SANDBOX_CHECKS: Check[];

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

@@ -3,6 +3,7 @@
 // on the PC.
 import fs from 'node:fs';
 import path from 'node:path';
+import { diskUsage, humanBytes } from '../../../../core/disk.js';
 import { dirExists, fileExists, isLink } from '../../../../core/util/index.js';
 import { SandboxChannel } from '../../../../host/channel/index.js';
 import { orphanWatchers, runStateProblems, staleLaunchFolders, watcherRecords } from '../../../../host/health/index.js';
@@ -18,6 +19,19 @@ import { deadPidFiles } from '../finders.js';
 import { fromFacts } from './pc.js';
 import { ok, plural, rel } from './common.js';
 const LAUNCH_DAYS = 7;
+/** The paging file may take at most this share of the disk it sits on. */
+const PAGE_FILE_MAX_SHARE = 0.4;
+/** A warning when the sandbox's paging file takes more than 40 % of the drive (pure); null when it is fine. */
+export function pageFileFinding(pageFileMb, driveBytes) {
+    if (pageFileMb <= 0 || driveBytes <= 0 || pageFileMb * 1024 * 1024 <= PAGE_FILE_MAX_SHARE * driveBytes)
+        return null;
+    return {
+        status: 'warn',
+        detail: 'the paging file is ' + pageFileMb + ' MB on a ' + humanBytes(driveBytes) + ' drive',
+        means: 'sandbox.pageFileMb takes more than 40% of the drive, so builds and installs have little room left and the disk fills up (a full disk can freeze the sandbox).',
+        fix: 'Run: sandbox config set sandbox.pageFileMb 8192 (or 0 to let Windows decide).',
+    };
+}
 const hiddenWindowsFile = (env) => path.join(env.storageRoot, 'run', 'hidden-windows.json');
 export const SANDBOX_CHECKS = [
     {
@@ -33,6 +47,16 @@ export const SANDBOX_CHECKS = [
             }
             : ok('off'),
     },
+    {
+        id: 'sandbox-pagefile',
+        group: 'Sandbox',
+        name: 'Paging file size',
+        run: (env) => {
+            const mb = env.ctx.loaded.config.sandbox.pageFileMb;
+            const drive = diskUsage(env.storageRoot).find((d) => d.drive.toUpperCase() === 'C:\\');
+            return pageFileFinding(mb, drive?.totalBytes ?? 0) ?? ok(mb > 0 ? mb + ' MB' : "Windows' own");
+        },
+    },
     {
         id: 'sandbox-exe',
         group: 'Sandbox',

package/dist/core/config/defaults.js

@@ -68,7 +68,7 @@ export const DEFAULTS = {
             components: [],
             targets: [],
             crates: [],
-            targetDir: 'separate',
+            targetDir: 'auto',
             linker: 'lld',
             linkSlots: 'auto',
         },

package/dist/core/schema/sandbox.js

@@ -21,7 +21,7 @@ export const SandboxSchema = z.strictObject({
         .describe('(alpha) What runs the sandbox. "windows-sandbox" = Windows Sandbox (the default: desktop, Windows Terminal, GPU, clipboard, audio, printers). "hcs" = a headless Hyper-V isolated Server Core container for agents (no desktop, GPU or clipboard); it needs Windows features and an image on this PC (sandbox engine check hcs lists what is missing), and starting it is not enabled yet in this alpha. sandbox engine shows what each engine can do. Yours only: a project file (.sandbox-config.json) cannot set it.'),
     memoryMb: z
         .union([z.literal('auto'), z.number().int().min(2048)])
-        .describe('Sandbox RAM in MB (>= 2048), or "auto": free RAM minus reserveHostMb, capped at maxMemoryMb. Never more than this PC can keep in RAM for it (its RAM minus the larger of reserveHostMb and 25 %, 2 GB more with vGPU): a bigger value is lowered.'),
+        .describe('Sandbox RAM in MB (>= 2048), or "auto": free RAM minus reserveHostMb, capped at maxMemoryMb. Never more than this PC can keep in RAM for it (its RAM minus the larger of reserveHostMb and 25 %, 4 GB more with vGPU): a bigger value is lowered.'),
     maxMemoryMb: z.number().int().positive().describe('Upper limit for memoryMb "auto".'),
     maxMemoryPercent: z
         .number()

package/dist/core/schema/toolchains.js

@@ -37,13 +37,13 @@ export const ToolchainsSchema = z.strictObject({
         targetDir: z
             .string()
             .min(1)
-            .describe('"shared": cargo\'s default target\\ (shared with builds on this PC, so builds on either side invalidate the other), "separate": <workspace>\\target\\sandbox (kept, no cross-talk), "local": on the sandbox\'s own disk (fastest, lost every boot), or a guest path.'),
+            .describe('"auto" (default): on the sandbox\'s own disk when C: has 25 GB free at boot, else "separate" (builds then write through the mapped workspace, which can overload this PC\'s disk). "shared": cargo\'s default target\\ (shared with builds on this PC, so builds on either side invalidate the other), "separate": <workspace>\\target\\sandbox (kept, no cross-talk), "local": on the sandbox\'s own disk (fastest, lost every boot), or a guest path.'),
         linker: z
             .enum(['lld', 'gnu'])
             .describe('GNU host: "lld" links with Rust\'s own lld through MinGW\'s gcc (much less memory than GNU ld), "gnu" with GNU ld.'),
         linkSlots: z
             .union([z.literal('auto'), z.number().int().min(1).max(32)])
-            .describe('GNU host: how many programs may link at the same time in the whole sandbox (other links wait). "auto" = one per 3 GB of sandbox memory after 6 GB, 2 to 8 (the memory governor slows links down too when memory runs short).'),
+            .describe('GNU host: how many programs may link at the same time in the whole sandbox (other links wait). "auto" = one per 6 GB of sandbox memory, 1 to 4 (the memory governor slows links down too when memory runs short).'),
     }),
     msvc: z.strictObject({
         enabled: enabled("MSVC (cl, link) and the Windows SDK, portable from Microsoft's Visual Studio manifest (~1-2 GB once), with vcvars64.bat and vswhere.", 'a .vcxproj, CMakePresets.json, a script calling vcvars/vswhere, or a Rust project when this PC builds Rust with MSVC'),

package/dist/guest/daemon/daemon.js

@@ -63,7 +63,7 @@ export class Daemon {
                 return sessions.close(req);
             case 'pressure':
                 // No response: the host repeats it every few seconds while its memory stays low.
-                return governor.hostPressure(req.seconds, req.reason, req.level ?? 'slow');
+                return governor.hostPressure(req.seconds, req.reason, req.level ?? 'slow', req.diskQueue);
             case 'ping':
                 return respond(req.id, { ok: true, message: 'pong (' + sessions.count + ' session(s) running)' });
         }

package/dist/guest/daemon/heartbeat.d.ts

@@ -0,0 +1,6 @@
+import type { Heartbeat } from '../../shared/channel/schema.js';
+import { type GovernorSnapshot } from '../governor/index.js';
+/** The heartbeat for these numbers (the governor's snapshot when it has one, else Windows' own free memory). */
+export declare function buildHeartbeat(snapshot: GovernorSnapshot | null, sessionCount: number, uptimeSeconds: number, freeBytes: number, totalBytes: number, at: string): Heartbeat;
+/** Writes the heartbeat now and every 10 seconds; a failed write is only a warning. */
+export declare function startHeartbeat(): void;

package/dist/guest/daemon/heartbeat.js

@@ -0,0 +1,40 @@
+// The heartbeat: every 10 seconds the daemon writes run\heartbeat.json (memory, the governor's dial, the biggest
+// programs). When the whole sandbox vanishes, the host reads the last one to say what it was doing.
+import os from 'node:os';
+import { writeJsonAtomic } from '../../shared/io/json.js';
+import { now } from '../../shared/channel/run-dir.js';
+import { governor } from '../governor/index.js';
+import { run } from '../runtime/paths.js';
+import { warn } from '../runtime/log.js';
+import { errMsg } from '../../core/util/errors.js';
+import { sessions } from './sessions.js';
+const BEAT_MS = 10000;
+const clamp = (n, low, high) => Math.max(low, Math.min(high, n));
+/** The heartbeat for these numbers (the governor's snapshot when it has one, else Windows' own free memory). */
+export function buildHeartbeat(snapshot, sessionCount, uptimeSeconds, freeBytes, totalBytes, at) {
+    const ramFree = snapshot?.ramFreePercent ?? Math.round((freeBytes / Math.max(1, totalBytes)) * 100);
+    return {
+        at,
+        uptimeS: Math.max(0, Math.round(uptimeSeconds)),
+        ramFreePct: clamp(ramFree, 0, 100),
+        commitPct: clamp(snapshot?.commitPercent ?? 0, 0, 100),
+        step: clamp(snapshot?.step ?? 0, 0, 4),
+        hostStep: clamp(snapshot?.hostStep ?? 0, 0, 4),
+        topProcesses: (snapshot?.top ?? []).slice(0, 5).map((p) => ({ name: p.name.slice(0, 64), privateMb: p.mb })),
+        ...(snapshot?.diskQueue != null ? { diskQueueReported: snapshot.diskQueue } : {}),
+        phase: sessionCount > 0 ? 'working' : 'ready',
+    };
+}
+/** Writes the heartbeat now and every 10 seconds; a failed write is only a warning. */
+export function startHeartbeat() {
+    const beat = () => {
+        try {
+            writeJsonAtomic(run.heartbeatFile, buildHeartbeat(governor.snapshot(), sessions.count, os.uptime(), os.freemem(), os.totalmem(), now()));
+        }
+        catch (e) {
+            warn('heartbeat: ' + errMsg(e));
+        }
+    };
+    beat();
+    setInterval(beat, BEAT_MS).unref();
+}

package/dist/guest/entries/daemon.js

@@ -13,6 +13,7 @@ import { startLiveFolders } from '../daemon/live.js';
 import { sessions } from '../daemon/sessions.js';
 import { governor } from '../governor/index.js';
 import { startAccountWatch } from '../daemon/accounts.js';
+import { startHeartbeat } from '../daemon/heartbeat.js';
 process.on('uncaughtException', (e) => warn('daemon: unexpected error (continuing): ' + (e.stack ?? errMsg(e))));
 process.on('unhandledRejection', (e) => warn('daemon: unexpected error (continuing): ' + errMsg(e)));
 const liveKey = adoptBootSecrets();
@@ -24,4 +25,5 @@ safely('leftover processes', () => sessions.sweepLeftovers());
 safely('memory governor', () => governor.start());
 log('Memory governor: ' + governor.describe());
 safely('service sign-ins', startAccountWatch);
+safely('heartbeat', startHeartbeat);
 new Daemon().start();

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

@@ -1,12 +1,26 @@
 import type { PressureStatus } from '../../shared/channel/schema.js';
 import type { LoadProfile } from '../../shared/memory/index.js';
 import { type GovernorState, type MemSample } from './decide.js';
+/** 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;
+    readonly diskQueue: number | null;
+    readonly top: readonly {
+        readonly name: string;
+        readonly mb: number;
+    }[];
+}
 /** What the governor needs from Windows (injectable: the tests use a fake). */
 export interface GovernorPort {
     setPriority(pid: number, to: 'idle' | 'below' | 'normal'): void;
     /** Suspends for `ms`, then resumes (memgov resumes it even if the daemon goes away). */
     hold(pid: number, ms: number): void;
     setMemoryPriority(pid: number, low: boolean): void;
+    /** The disk queue priority (very low, low, normal). */
+    setIoPriority(pid: number, to: 'verylow' | 'low' | 'normal'): void;
     /** Into the throttle job (whose CPU cap setCpuRate sets). */
     throttle(pid: number): void;
     setCpuRate(percent: number): void;
@@ -35,8 +49,12 @@ export declare class GovernorCore {
     private lastWriteAt;
     /** Compilers waiting their turn now, by pid (name), to log a hold once. */
     private held;
+    private latest;
+    private diskQueue;
     constructor(deps: GovernorDeps);
-    hostPressure(seconds: number, reason: string, level?: 'slow' | 'severe'): void;
+    hostPressure(seconds: number, reason: string, level?: 'slow' | 'severe', diskQueue?: number): void;
+    /** The newest numbers, null before the first sample. */
+    get snapshot(): GovernorSnapshot | null;
     get current(): GovernorState;
     onSample(sample: MemSample): void;
     private apply;

package/dist/guest/governor/core.js

@@ -17,10 +17,14 @@ export class GovernorCore {
     lastWriteAt = 0;
     /** Compilers waiting their turn now, by pid (name), to log a hold once. */
     held = new Map();
+    latest = null;
+    diskQueue = null;
     constructor(deps) {
         this.deps = deps;
     }
-    hostPressure(seconds, reason, level = 'slow') {
+    hostPressure(seconds, reason, level = 'slow', diskQueue) {
+        if (diskQueue !== undefined)
+            this.diskQueue = diskQueue;
         const nowMs = this.deps.now();
         const until = nowMs + seconds * 1000;
         const active = this.state.hostUntil > nowMs;
@@ -34,6 +38,10 @@ export class GovernorCore {
                 step);
         this.state = { ...this.state, hostUntil: Math.max(until, this.state.hostUntil), hostStep: step };
     }
+    /** The newest numbers, null before the first sample. */
+    get snapshot() {
+        return this.latest ? { ...this.latest, diskQueue: this.diskQueue } : null;
+    }
     get current() {
         return this.state;
     }
@@ -42,6 +50,17 @@ export class GovernorCore {
         const before = this.state.step;
         const d = decide(this.state, sample, nowMs, this.deps.profile, this.deps.maxCompilers ?? null);
         this.state = d.state;
+        this.latest = {
+            ramFreePercent: d.ramFreePercent,
+            commitPercent: d.commitPercent,
+            step: d.state.step,
+            hostStep: nowMs < d.state.hostUntil ? d.state.hostStep : 0,
+            diskQueue: null,
+            top: [...sample.procs]
+                .sort((a, b) => b.mb - a.mb)
+                .slice(0, 5)
+                .map((p) => ({ name: p.name.slice(0, 64), mb: Math.round(p.mb) })),
+        };
         const holding = new Set();
         for (const action of d.actions) {
             if (action.kind === 'hold')
@@ -98,6 +117,9 @@ export class GovernorCore {
                     port.setPriority(action.pid, action.to);
                     this.note(action.name + ' (' + action.pid + ') priority ' + action.to);
                     return;
+                case 'io':
+                    port.setIoPriority(action.pid, action.to);
+                    return;
                 case 'memory':
                     port.setMemoryPriority(action.pid, action.low);
                     return;

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

@@ -1,5 +1,7 @@
 import { type LoadProfile } from '../../shared/memory/index.js';
 export type Priority = 'idle' | 'below' | 'normal';
+/** I/O priority of a process (NtSetInformationProcess ProcessIoPriority): its disk requests queue behind the rest. */
+export type IoPriority = 'verylow' | 'low' | 'normal';
 export interface ProcSample {
     readonly pid: number;
     readonly name: string;
@@ -17,6 +19,9 @@ export interface MemSample {
 }
 export declare const isNeverTouched: (name: string) => boolean;
 export declare const canLower: (name: string) => boolean;
+export declare const isLinker: (name: string) => boolean;
+/** Links that may run at once ("auto"): one per 6 GB of RAM, 1 to 4 (never more than the processors). */
+export declare function linkerSlots(totalMb: number, cpus: number): number;
 export declare const isHeavyCompiler: (name: string) => boolean;
 export declare const canPause: (name: string) => boolean;
 export type Level = 'ok' | 'throttled' | 'suspending';
@@ -33,6 +38,8 @@ export interface GovernorState {
     readonly throttled: readonly number[];
     /** Pids whose working set was trimmed while they waited. */
     readonly trimmed: readonly number[];
+    /** Pids whose I/O priority was lowered, and to what. */
+    readonly ioLowered: Readonly<Record<number, IoPriority>>;
     /** The CPU cap last set on the throttle job (percent; 100 = none). */
     readonly cpuRate: number;
     /** Used commit (MB) and when, at the last sample: how fast it grows. */
@@ -51,6 +58,13 @@ export type Action = {
     readonly pid: number;
     readonly name: string;
     readonly to: Priority;
+}
+/** Disk requests of a compiler or linker queue behind everything else (the PC's disks are the scarce thing). */
+ | {
+    readonly kind: 'io';
+    readonly pid: number;
+    readonly name: string;
+    readonly to: IoPriority;
 } | {
     readonly kind: 'memory';
     readonly pid: number;

package/dist/guest/governor/decide.js

@@ -100,6 +100,13 @@ const HEAVY = new Set([
     'ld',
     'ld.lld',
 ]);
+/** Linkers: the biggest memory and disk users of a build, so they run one at a time from step 2. */
+const LINKERS = new Set(['link', 'lld', 'lld-link', 'ld', 'ld.lld']);
+export const isLinker = (name) => !isNeverTouched(name) && LINKERS.has(key(name));
+/** Links that may run at once ("auto"): one per 6 GB of RAM, 1 to 4 (never more than the processors). */
+export function linkerSlots(totalMb, cpus) {
+    return Math.max(1, Math.min(4, Math.max(1, Math.floor(cpus)), Math.floor(totalMb / 6144)));
+}
 export const isHeavyCompiler = (name) => !isNeverTouched(name) && HEAVY.has(key(name));
 export const canPause = (name) => !isNeverTouched(name) && COMPILERS.has(key(name));
 export const INITIAL_STATE = {
@@ -109,6 +116,7 @@ export const INITIAL_STATE = {
     memLow: [],
     throttled: [],
     trimmed: [],
+    ioLowered: {},
     cpuRate: 100,
     lastCommitMb: 0,
     lastAt: 0,
@@ -172,6 +180,10 @@ export function decide(prev, sample, nowMs, profile, maxCompilers = null) {
             calm = 0;
         }
     }
+    // vGPU on (the gentle profile): a GPU game and a build together have killed the whole VM, so while any heavy compiler
+    // or linker runs the dial is at step 2 at least. The game itself is never touched (only build programs are).
+    if (profile === 'gentle' && step < 2 && sample.procs.some((p) => isHeavyCompiler(p.name)))
+        step = 2;
     const actions = [];
     const present = new Set(sample.procs.map((p) => p.pid));
     const keep = (pids) => pids.filter((pid) => present.has(pid));
@@ -198,6 +210,25 @@ export function decide(prev, sample, nowMs, profile, maxCompilers = null) {
         else
             lowered[p.pid] = target;
     }
+    // I/O priority of compilers and linkers: low while their CPU priority is below normal, very low from step 3 (a PC
+    // whose disks are overloaded asks for step 4). Restored to normal when they are released.
+    const ioLowered = {};
+    for (const [pid, to] of Object.entries(prev.ioLowered))
+        if (present.has(Number(pid)))
+            ioLowered[Number(pid)] = to;
+    for (const p of sample.procs) {
+        if (!canPause(p.name))
+            continue;
+        const cpu = lowered[p.pid] ?? 'normal';
+        const target = step >= 3 ? 'verylow' : cpu !== 'normal' ? 'low' : 'normal';
+        const was = ioLowered[p.pid] ?? 'normal';
+        if (was !== target)
+            actions.push({ kind: 'io', pid: p.pid, name: p.name, to: target });
+        if (target === 'normal')
+            delete ioLowered[p.pid];
+        else
+            ioLowered[p.pid] = target;
+    }
     // Memory priority: low from step 1, so Windows trims the builds' pages before the agents'.
     const lowMemory = step >= 1;
     for (const p of sample.procs) {
@@ -224,20 +255,33 @@ export function decide(prev, sample, nowMs, profile, maxCompilers = null) {
     let allowed = compilersAllowed(step, heavy.length);
     // The cap is a memory measure: with memory to spare, Windows shares the CPU (the priorities above) and no compiler
     // waits. A waiting rustc also holds cargo's job tokens, which stalls the whole build.
-    if (maxCompilers !== null && step >= 2)
+    if (maxCompilers !== null && step >= 1)
         allowed = Math.min(allowed, Math.max(1, maxCompilers));
-    if (allowed < heavy.length) {
-        const turn = Math.floor(nowMs / ROTATE_MS) % heavy.length;
-        const order = [...heavy.slice(turn), ...heavy.slice(0, turn)];
-        for (const p of order.slice(allowed)) {
+    const turn = heavy.length > 0 ? Math.floor(nowMs / ROTATE_MS) % heavy.length : 0;
+    const order = [...heavy.slice(turn), ...heavy.slice(0, turn)];
+    let waiting = order.slice(Math.min(allowed, order.length));
+    // From step 2 the linkers that would run go one at a time, whatever the cap: a link reads and writes the most.
+    if (step >= 2) {
+        const waitingPids = new Set(waiting.map((p) => p.pid));
+        let linking = 0;
+        for (const p of order)
+            if (isLinker(p.name) && !waitingPids.has(p.pid) && ++linking > 1) {
+                waiting = [...waiting, p];
+                waitingPids.add(p.pid);
+            }
+    }
+    if (waiting.length > 0) {
+        const waitingPids = new Set(waiting.map((p) => p.pid));
+        for (const p of waiting) {
             actions.push({ kind: 'hold', pid: p.pid, name: p.name, ms: HOLD_MS });
             if (step >= 3 && !trimmed.has(p.pid)) {
                 actions.push({ kind: 'trim', pid: p.pid, name: p.name });
                 trimmed.add(p.pid);
             }
         }
-        for (const p of order.slice(0, allowed))
-            trimmed.delete(p.pid);
+        for (const p of order)
+            if (!waitingPids.has(p.pid))
+                trimmed.delete(p.pid);
     }
     else
         trimmed.clear();
@@ -250,6 +294,7 @@ export function decide(prev, sample, nowMs, profile, maxCompilers = null) {
             memLow: [...memLow],
             throttled: [...throttled],
             trimmed: [...trimmed],
+            ioLowered,
             cpuRate,
             lastCommitMb: usedMb,
             lastAt: nowMs,

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

@@ -1,9 +1,12 @@
+import { type GovernorSnapshot } from './core.js';
 /** The daemon's governor: on unless sandbox.pressureResponse is off. */
 export declare class Governor {
     private core;
     describe(): string;
     start(): void;
     /** The host's watchdog: this PC is low (or nearly out of memory) for a while. */
-    hostPressure(seconds: number, reason: string, level?: 'slow' | 'severe'): void;
+    hostPressure(seconds: number, reason: string, level?: 'slow' | 'severe', diskQueue?: number): void;
+    /** The newest numbers, for the heartbeat (null when the governor is off or has not sampled yet). */
+    snapshot(): GovernorSnapshot | null;
 }
 export declare const governor: Governor;

package/dist/guest/governor/governor.js

@@ -72,6 +72,9 @@ class MemGovProcess {
     setMemoryPriority(pid, low) {
         this.send('memprio ' + pid + ' ' + (low ? 'low' : 'normal'));
     }
+    setIoPriority(pid, to) {
+        this.send('iopriority ' + pid + ' ' + to);
+    }
     throttle(pid) {
         this.send('throttle ' + pid);
     }
@@ -143,8 +146,12 @@ export class Governor {
         proc.start();
     }
     /** The host's watchdog: this PC is low (or nearly out of memory) for a while. */
-    hostPressure(seconds, reason, level = 'slow') {
-        this.core?.hostPressure(seconds, reason, level);
+    hostPressure(seconds, reason, level = 'slow', diskQueue) {
+        this.core?.hostPressure(seconds, reason, level, diskQueue);
+    }
+    /** The newest numbers, for the heartbeat (null when the governor is off or has not sampled yet). */
+    snapshot() {
+        return this.core?.snapshot ?? null;
     }
 }
 export const governor = new Governor();

package/dist/guest/toolchains/native/rust-extras.d.ts

@@ -1,5 +1,12 @@
 import type { Toolchains } from '../../../core/types.js';
 import { type ToolEnv } from '../tool-env.js';
+/**
+ * "auto" (the default): build on the sandbox's own disk when C: has 25 GB free, else keep the target next to the
+ * project, which writes every object file through the mapped workspace to this PC's disk. Other values stay as set.
+ */
+export declare function resolveTargetDir(rust: Toolchains['rust'], free?: number, note?: (text: string) => void): Toolchains['rust'];
+/** One summary line for the agent: where cargo builds. */
+export declare function targetSummary(rust: Toolchains['rust']): string;
 /** "separate": tools\shims\cargo\cargo.exe in front of the real cargo, which it runs with the checkout's target dir. */
 export declare function cargoShim(env: ToolEnv, rust: Toolchains['rust']): void;
 /**

package/dist/guest/toolchains/native/rust-extras.js

@@ -7,7 +7,31 @@ import { execOutput } from '../../runtime/process.js';
 import { ensureCompiled } from '../../runtime/csc.js';
 import { arch, tool } from '../tool-env.js';
 import { wanted } from '../detect.js';
-import { cargoJobs, linkSlotsFor } from '../../../shared/memory/index.js';
+import { cargoJobs, chooseTargetDir } from '../../../shared/memory/index.js';
+import { linkerSlots } from '../../governor/decide.js';
+import { warn } from '../../runtime/log.js';
+import { freeBytes } from '../persisted.js';
+/**
+ * "auto" (the default): build on the sandbox's own disk when C: has 25 GB free, else keep the target next to the
+ * project, which writes every object file through the mapped workspace to this PC's disk. Other values stay as set.
+ */
+export function resolveTargetDir(rust, free = freeBytes((process.env.SystemDrive ?? 'C:') + '\\'), note = warn) {
+    if (rust.targetDir !== 'auto')
+        return rust;
+    const chosen = chooseTargetDir(rust.targetDir, free);
+    if (chosen.warning)
+        note(chosen.warning);
+    return { ...rust, targetDir: chosen.targetDir };
+}
+/** One summary line for the agent: where cargo builds. */
+export function targetSummary(rust) {
+    const target = cargoTarget(rust.targetDir);
+    if (target)
+        return 'rust builds: ' + target + ' (CARGO_TARGET_DIR)';
+    return rust.targetDir === 'shared'
+        ? 'rust builds: target\\ in each project (shared with this PC)'
+        : 'rust builds: target\\sandbox in each project (on the mapped workspace)';
+}
 /**
  * Where cargo builds: shared with the PC's target\, one on the sandbox's disk, or a path. "separate" sets no variable:
  * the cargo shim (sandbox/csharp/CargoShim.cs) gives every checkout its own target\sandbox, so git worktrees of several
@@ -40,8 +64,7 @@ export function linkGate(env, rust, host) {
         return;
     const gate = path.join(mkdirp(tool('shims')), 'linkgate.exe');
     fs.copyFileSync(ensureCompiled('linkgate'), gate);
-    const memoryGb = os.totalmem() / 1024 ** 3;
-    const slots = rust.linkSlots === 'auto' ? linkSlotsFor(memoryGb) : rust.linkSlots;
+    const slots = rust.linkSlots === 'auto' ? linkerSlots(os.totalmem() / 1024 ** 2, os.cpus().length) : rust.linkSlots;
     env.vars.AGENT_LINK_SLOTS = String(slots);
     env.vars.AGENT_REAL_LINKER = gcc;
     env.vars.CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER = gate;

package/dist/guest/toolchains/plan.js

@@ -32,7 +32,7 @@ import { setupFlutter } from './mobile/flutter.js';
 import { setupDart } from './mobile/dart.js';
 import { setupReactNative } from './mobile/react-native.js';
 import { setupKotlin } from './languages/kotlin.js';
-import { rustHost, rustCaches, cargoDefaults, cargoShim, linkGate } from './native/rust-extras.js';
+import { rustHost, rustCaches, cargoDefaults, cargoShim, linkGate, resolveTargetDir, targetSummary, } from './native/rust-extras.js';
 import { setupPythonTools } from './languages/python-tools.js';
 export function plan(config, versions, o) {
     const apps = Boolean(o.apps && (o.apps.install.length || Object.keys(o.apps.custom).length));
@@ -92,11 +92,13 @@ export function plan(config, versions, o) {
             after: ['C/C++', 'MSVC', 'Visual Studio', 'Unreal'],
             install: async (env) => {
                 await setupRust(env, { ...config.rust, host: rustHost(config) }, o.refresh);
-                Object.assign(env.vars, rustCaches(config.rust));
+                const rust = resolveTargetDir(config.rust);
+                Object.assign(env.vars, rustCaches(rust));
+                env.summary.push(targetSummary(rust));
                 if (!dryRun) {
                     cargoDefaults(rustHost(config));
-                    cargoShim(env, config.rust);
-                    linkGate(env, config.rust, rustHost(config));
+                    cargoShim(env, rust);
+                    linkGate(env, rust, rustHost(config));
                 }
             },
         },

package/dist/host/channel/channel.d.ts

@@ -51,7 +51,7 @@ export declare class SandboxChannel {
     /** Ends a running session (agent or shell) and everything it started; waits for the sandbox's answer. */
     closeSession(sessionId: string): Promise<GuestResponse>;
     /** The PC is low on memory or CPU: the sandbox slows its builds down for `seconds`. Never waits for an answer. */
-    pressure(reason: string, seconds: number, level?: 'slow' | 'severe'): void;
+    pressure(reason: string, seconds: number, level?: 'slow' | 'severe', diskQueue?: number): void;
     ping(): Promise<GuestResponse>;
     runningSessions(): SessionStatus[];
     /** Running sessions of the sandbox that is running now (its launch id), newest last, capped. */