windows-development-sandbox 1.18.0 → 1.18.3

package/dist/selftest/heavy-load.test.js

@@ -8,12 +8,14 @@ import { DEFAULTS } from '../core/config/index.js';
 import { isWin } from '../core/util/index.js';
 import { SYSTEM } from '../shared/system.js';
 import { GuestRequestSchema, PressureStatusSchema } from '../shared/channel/index.js';
-import { compilersAllowed, DIAL_CALM_SAMPLES, DIAL_STEPS, HOST_THRESHOLDS, buildJobs, cargoJobs, linkSlotsFor, usableCpus, effectiveCpuLimit, gentleCpuLimit, maxCompilers, } from '../shared/memory/index.js';
+import { compilersAllowed, DIAL_CALM_SAMPLES, DIAL_STEPS, HOST_THRESHOLDS, buildJobs, cargoJobs, linkSlotsFor, usableCpus, effectiveCpuLimit, gentleCpuLimit, maxCompilers, chooseTargetDir, } from '../shared/memory/index.js';
+import { HeartbeatSchema } from '../shared/channel/index.js';
+import { heartbeatLine, lastEndOf } from '../host/life/index.js';
 import { cappedMemoryMb, decideMemory, memoryNote, residentCapMb, residentNote, resolveMemoryMb, } from '../host/launch/index.js';
 import { vgpuWarning, GENTLE_NOTE } from '../host/launch/risk-notes.js';
 import { bugcheckCode, cpuPercentBetween, explainStop, findDumps, findingLines, freezeLine, hostPressure, lowReason, severeHost, pageFileRisk, parseHostMemory, crashReportText, watchdogStep, WATCHDOG_START, } from '../host/life/index.js';
 // The pure governor files only: governor.ts loads the guest runtime (session.json), which exists only in a sandbox.
-import { canLower, canPause, decide, INITIAL_STATE, ROTATE_MS, } from '../guest/governor/decide.js';
+import { canLower, canPause, decide, INITIAL_STATE, isLinker, linkerSlots, ROTATE_MS, } from '../guest/governor/decide.js';
 import { GovernorCore } from '../guest/governor/core.js';
 const GB = 1024;
 const MB_SANDBOX = DEFAULTS.sandbox;
@@ -63,9 +65,9 @@ export const heavyLoadSuite = {
         t.check(refused.includes('RAM plus paging file'), 'too little commit refuses with the real reason', refused);
         t.check(resolveMemoryMb({ ...MB_SANDBOX, memoryMb: 5000 }, 1, 1, 1) === 5000, 'a fixed memoryMb is taken as asked (the resident cap below is the only limit on it)');
         t.check(residentCapMb({ ...MB_SANDBOX, vGpu: false }, 32768) === 24576 &&
-            residentCapMb({ ...MB_SANDBOX, vGpu: true }, 32768) === 22528 &&
-            residentCapMb({ ...MB_SANDBOX, vGpu: false }, 65536) === 49152, 'what this PC can keep in RAM for the sandbox: its RAM minus max(reserve, 25 %), 2 GB more with vGPU');
-        t.check(cappedMemoryMb(32768, { ...MB_SANDBOX, vGpu: true }, 32768) === 22528 &&
+            residentCapMb({ ...MB_SANDBOX, vGpu: true }, 32768) === 20480 &&
+            residentCapMb({ ...MB_SANDBOX, vGpu: false }, 65536) === 49152, 'what this PC can keep in RAM for the sandbox: its RAM minus max(reserve, 25 %), 4 GB more with vGPU');
+        t.check(cappedMemoryMb(32768, { ...MB_SANDBOX, vGpu: true }, 32768) === 20480 &&
             cappedMemoryMb(16384, { ...MB_SANDBOX, vGpu: true }, 32768) === 16384 &&
             cappedMemoryMb(8192, MB_SANDBOX, 6144) === 8192, 'a fixed memoryMb above it is lowered to it (never on a PC too small to keep 4 GB)');
         t.check(residentNote(32768, 22528)?.includes('gets 22528 MB') === true && residentNote(16384, 16384) === null, 'and the launch says so');
@@ -173,13 +175,22 @@ export const heavyLoadSuite = {
         t.section('the gentle profile (vGPU on)');
         t.check(DIAL_STEPS.gentle[0].availablePercent > DIAL_STEPS.normal[0].availablePercent &&
             DIAL_STEPS.gentle[0].commitPercent < DIAL_STEPS.normal[0].commitPercent, 'every step starts earlier');
-        const g = decide(INITIAL_STATE, sample(50, 50, procs), 0, 'gentle');
-        t.check(g.state.step === 0 &&
-            g.actions.length === 3 &&
-            g.actions.every((a) => a.kind === 'priority' && a.to === 'below' && a.pid !== 3), 'compilers rest below normal even with plenty of memory (the agent does not)');
-        t.check(decide(INITIAL_STATE, sample(19, 50, procs), 0, 'gentle').state.step === 1, '19 % free is step 1');
+        const idle = [proc(3, 'claude.exe', 900), proc(5, 'modern_mohaa.exe', 4400), proc(6, 'cargo.exe', 50)];
+        const g = decide(INITIAL_STATE, sample(50, 50, idle), 0, 'gentle');
+        t.check(g.state.step === 0, 'with vGPU on and no heavy compiler running the dial stays at 0 (a game alone is fine)');
+        const building = decide(INITIAL_STATE, sample(50, 50, [...procs, proc(5, 'modern_mohaa.exe', 4400)]), 0, 'gentle');
+        t.check(building.state.step === 2 &&
+            of(building, 'priority').length === 3 &&
+            of(building, 'priority').every((a) => a.kind === 'priority' && a.to === 'idle' && a.pid !== 3 && a.pid !== 5), 'vGPU on: while rustc or link runs the builds are at step 2 at least; the agent and the GPU game are never touched');
+        t.check(decide(INITIAL_STATE, sample(50, 50, procs), 0, 'normal').state.step === 0, 'without vGPU the same build leaves the dial at 0');
+        t.check(decide(INITIAL_STATE, sample(19, 50, procs), 0, 'gentle').state.step === 2, '19 % free is step 1, lifted to 2 by the build');
+        const done = decide(building.state, sample(50, 50, idle), 1000, 'gentle').state;
+        t.check(done.step === 2, 'when the build ends the dial turns down slowly, like any other');
         t.section('the compiler cap (vGPU on)');
-        t.check(maxCompilers(16, 'gentle') === 4 && maxCompilers(4, 'gentle') === 2 && maxCompilers(16, 'normal') === null, 'at most max(2, cores / 4) with vGPU, none otherwise');
+        t.check(maxCompilers(16, 'gentle') === 4 &&
+            maxCompilers(64, 'gentle') === 4 &&
+            maxCompilers(4, 'gentle') === 2 &&
+            maxCompilers(16, 'normal') === null, 'at most 4 (and at least 2: cores / 4) with vGPU, none otherwise');
         const many = [
             proc(10, 'rustc.exe', 800),
             proc(11, 'rustc.exe', 900),
@@ -188,21 +199,72 @@ export const heavyLoadSuite = {
             proc(3, 'claude.exe', 500),
             proc(14, 'node.exe', 400),
         ];
-        // The cap is a memory measure: with memory to spare no compiler waits (a waiting rustc stalls cargo's whole build).
+        // With vGPU on a build runs at step 2 at least, so the cap holds even with memory to spare.
         const free = decide(INITIAL_STATE, sample(60, 40, many), 0, 'gentle', 2);
-        t.check(of(free, 'hold').length === 0, 'with memory to spare, nothing waits even beyond the cap');
+        t.check(free.state.step === 2 && of(free, 'hold').length === 2, 'vGPU on: even with memory to spare compilers beyond the cap wait their turn');
+        t.check(of(decide(INITIAL_STATE, sample(60, 40, many), 0, 'normal', null), 'hold').length === 0, 'without vGPU, with memory to spare, nothing waits');
         const capped = decide(INITIAL_STATE, sample(14, 40, many), 0, 'gentle', 2);
         const holds = of(capped, 'hold').map((a) => ('pid' in a ? a.pid : 0));
         t.check(capped.state.step === 2 && holds.length === 2, 'under memory pressure (step 2), compilers beyond the cap wait their turn', holds.join(','));
         t.check(!holds.includes(3) && !holds.includes(14), 'agents (claude, and codex or gemini as node) are never held');
-        t.check(of(decide(INITIAL_STATE, sample(60, 40, many), 0, 'gentle', null), 'hold').length === 0, 'no cap, no pressure: nothing waits');
         t.check(of(decide(INITIAL_STATE, sample(60, 40, many.slice(0, 2)), 0, 'gentle', 2), 'hold').length === 0, 'under the cap nothing waits');
+        t.section('I/O priority and linkers');
+        const ioOf = (d) => d.actions.flatMap((a) => (a.kind === 'io' ? [a.pid + ' ' + a.to] : []));
+        const below = decide(INITIAL_STATE, sample(14, 50, procs), 0, 'normal');
+        t.check(below.state.step === 1 && ioOf(below).join() === '1 low,2 low,4 low', 'compilers and linkers at below-normal priority get low I/O (the agent does not)', ioOf(below).join());
+        const hard = decide(INITIAL_STATE, sample(5, 60, procs), 0, 'normal');
+        t.check(hard.state.step >= 3 && ioOf(hard).join() === '1 verylow,2 verylow,4 verylow', 'from step 3 (a disk-severe PC asks for 4) their I/O is very low', ioOf(hard).join());
+        const calmState = { ...hard.state, step: 0, calm: 0 };
+        t.check(ioOf(decide(calmState, sample(90, 10, procs), 2000, 'normal')).join() === '1 normal,2 normal,4 normal', 'released compilers get normal I/O again');
+        t.check(linkerSlots(32768, 16) === 4 &&
+            linkerSlots(8192, 16) === 1 &&
+            linkerSlots(65536, 2) === 2 &&
+            linkerSlots(2048, 8) === 1, 'link slots: one per 6 GB of RAM, 1 to 4, never more than the processors');
+        t.check(['ld.exe', 'ld.lld.exe', 'lld-link.exe', 'link.exe'].every(isLinker) &&
+            !isLinker('rustc.exe') &&
+            !isLinker('claude.exe'), 'ld, ld.lld, lld-link and link are linkers');
+        const links = [
+            proc(20, 'ld.exe', 1600),
+            proc(21, 'ld.exe', 1700),
+            proc(22, 'ld.lld.exe', 1500),
+            proc(3, 'claude.exe', 900),
+        ];
+        t.check(of(decide(INITIAL_STATE, sample(40, 40, links), 0, 'normal', null), 'hold').length === 0, 'at step 0 several links may run');
+        const linkHolds = of(decide(INITIAL_STATE, sample(8, 40, links), 0, 'normal', null), 'hold');
+        t.check(linkHolds.length === 2, 'at step 2 the linkers run one at a time', String(linkHolds.length));
+        t.section('where Rust builds, the heartbeat and how the last sandbox ended');
+        t.check(chooseTargetDir('auto', 30 * 1024 ** 3).targetDir === 'local' &&
+            chooseTargetDir('auto', 10 * 1024 ** 3).targetDir === 'separate' &&
+            Boolean(chooseTargetDir('auto', 10 * 1024 ** 3).warning) &&
+            chooseTargetDir('shared', 1).targetDir === 'shared', 'targetDir "auto": local with 25 GB free on C:, else separate with a warning; other values stay');
+        const beat = {
+            at: '2026-11-02T21:31:00.000Z',
+            uptimeS: 2800,
+            ramFreePct: 30,
+            commitPct: 40,
+            step: 2,
+            hostStep: 4,
+            topProcesses: [{ name: 'rustc.exe', privateMb: 1700 }],
+            diskQueueReported: 41,
+            phase: 'working',
+        };
+        t.check(HeartbeatSchema.safeParse(beat).success, 'a heartbeat matches its schema');
+        t.check(!HeartbeatSchema.safeParse({ ...beat, topProcesses: Array.from({ length: 6 }, () => beat.topProcesses[0]) })
+            .success &&
+            !HeartbeatSchema.safeParse({ ...beat, topProcesses: [{ name: 'x'.repeat(500), privateMb: 1 }] }).success, 'an oversize heartbeat is refused');
+        t.check(heartbeatLine({ ...beat, topProcesses: [{ name: 'ab', privateMb: 5 }] }).includes('') === false, 'guest text in the heartbeat line goes through safeText');
+        const life = { started: '2026-11-02T20:45:00.000Z', lastSeen: '2026-11-02T21:31:30.000Z', keepAwake: false };
+        t.check((lastEndOf(life, beat, false)?.text ?? '').includes('disks were overloaded') &&
+            lastEndOf(life, beat, true) === null &&
+            lastEndOf(null, beat, false) === null &&
+            lastEndOf({ ...life, ended: { at: life.lastSeen, cause: null } }, beat, false) === null, 'last end: an unexpected end names the disks; running, no record or a normal close say nothing');
         t.section('the governor over a port (fake Windows)');
         const calls = [];
         const port = {
             setPriority: (pid, to) => calls.push('prio ' + pid + ' ' + to),
             hold: (pid, ms) => calls.push('hold ' + pid + ' ' + ms),
             setMemoryPriority: (pid, low) => calls.push('mem ' + pid + ' ' + (low ? 'low' : 'normal')),
+            setIoPriority: (pid, to) => calls.push('io ' + pid + ' ' + to),
             throttle: (pid) => calls.push('throttle ' + pid),
             setCpuRate: (percent) => calls.push('cpu ' + percent),
             trim: (pid) => calls.push('trim ' + pid),
@@ -290,6 +352,25 @@ export const heavyLoadSuite = {
         }
         t.check(diskSent && disk.low, 'a disk queue of 32 or more for 40 s: asks the sandbox to slow down');
         t.check(!watchdogStep(WATCHDOG_START, input(pc({ diskQueue: 40 }), 0)).state.low, 'a short disk peak is nothing');
+        t.check(!disk.severe, 'a queue of 40 (1.25 times the limit) for 40 s is low but not yet severe');
+        let double = WATCHDOG_START;
+        let doubleSevere = false;
+        for (let i = 0; i < 4; i++) {
+            const st = watchdogStep(double, input(pc({ diskQueue: 70 }), i * 10000));
+            double = st.state;
+            doubleSevere = doubleSevere || (st.severe && st.send);
+        }
+        t.check(doubleSevere, 'a queue of twice the limit for 40 s is severe and sent at once');
+        let long = WATCHDOG_START;
+        let longReason = '';
+        for (let i = 0; i < 13; i++) {
+            const st = watchdogStep(long, input(pc({ diskQueue: 40 }), i * 10000));
+            long = st.state;
+            if (st.severe)
+                longReason = st.reason;
+        }
+        t.check(longReason.includes('overloaded'), 'the limit itself for three times as long is severe: "disks are overloaded"', longReason);
+        t.check(watchdogStep(long, input(pc({ diskQueue: 0 }), 200000)).state.low, 'calm still needs the queue gone and the calm samples: one good sample is not recovery');
         t.check(!watchdogStep(WATCHDOG_START, input(pc(), 0)).state.low, 'no disk counter: memory and CPU only');
         t.check(cpuPercentBetween([{ times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 } }], [{ times: { user: 90, nice: 0, sys: 0, idle: 10, irq: 0 } }]) === 90, 'CPU use from two readings');
         t.check(GuestRequestSchema.safeParse({ kind: 'pressure', id: 'p1', reason: 'low', seconds: 90, createdAt: 'now' })

package/dist/selftest/live-terminal.test.js

@@ -235,6 +235,10 @@ export const liveTerminalSuite = {
                 if (target) {
                     for (const command of [
                         'memprio ' + target.pid + ' low',
+                        'iopriority ' + target.pid + ' verylow',
+                        'iopriority ' + target.pid + ' low',
+                        'iopriority ' + target.pid + ' normal',
+                        'iopriority ' + target.pid + ' bogus',
                         'throttle ' + target.pid,
                         'cpurate 20',
                         'trim ' + target.pid,

package/dist/shared/channel/run-dir.d.ts

@@ -1,4 +1,4 @@
-import type { GuestRequest, GuestResponse, PressureStatus, ProjectStatus, SandboxStatus, SessionStatus, VpnStatus } from './schema.js';
+import type { GuestRequest, GuestResponse, Heartbeat, PressureStatus, ProjectStatus, SandboxStatus, SessionStatus, VpnStatus } from './schema.js';
 /** Ids become file names, so only a strict alphabet is allowed (no separators, no dots). */
 export declare function safeId(id: string): string;
 export declare function now(): string;
@@ -9,6 +9,8 @@ export declare class RunDir {
     readonly vpnFile: string;
     /** What the memory governor in the sandbox is doing (pressure.json). */
     readonly pressureFile: string;
+    /** The daemon's heartbeat every 10 seconds (heartbeat.json): what the sandbox did last. */
+    readonly heartbeatFile: string;
     /** What the sandbox's programs may really use (budget.json): processors, memory, build jobs, link slots. */
     readonly budgetFile: string;
     readonly requestsDir: string;
@@ -39,6 +41,7 @@ export declare class RunDir {
     readSandboxStatus(): SandboxStatus | null;
     readVpnStatus(): VpnStatus | null;
     readPressure(): PressureStatus | null;
+    readHeartbeat(): Heartbeat | null;
     readSession(id: string): SessionStatus | null;
     readResponse(id: string): GuestResponse | null;
     listSessions(): SessionStatus[];

package/dist/shared/channel/run-dir.js

@@ -3,7 +3,7 @@
 // written atomically and parsed with the channel schemas on read. Anything that does not parse is ignored.
 import fs from 'node:fs';
 import path from 'node:path';
-import { GuestRequestSchema, GuestResponseSchema, IdSchema, PressureStatusSchema, ProjectStatusSchema, SandboxStatusSchema, SessionStatusSchema, VpnStatusSchema, } from './schema.js';
+import { GuestRequestSchema, GuestResponseSchema, HeartbeatSchema, IdSchema, PressureStatusSchema, ProjectStatusSchema, SandboxStatusSchema, SessionStatusSchema, VpnStatusSchema, } from './schema.js';
 import { readValid } from '../io/index.js';
 /** Ids become file names, so only a strict alphabet is allowed (no separators, no dots). */
 export function safeId(id) {
@@ -36,6 +36,8 @@ export class RunDir {
     vpnFile;
     /** What the memory governor in the sandbox is doing (pressure.json). */
     pressureFile;
+    /** The daemon's heartbeat every 10 seconds (heartbeat.json): what the sandbox did last. */
+    heartbeatFile;
     /** What the sandbox's programs may really use (budget.json): processors, memory, build jobs, link slots. */
     budgetFile;
     requestsDir;
@@ -59,6 +61,7 @@ export class RunDir {
         this.sandboxFile = path.join(this.root, 'sandbox.json');
         this.vpnFile = path.join(this.root, 'vpn.json');
         this.pressureFile = path.join(this.root, 'pressure.json');
+        this.heartbeatFile = path.join(this.root, 'heartbeat.json');
         this.budgetFile = path.join(this.root, 'budget.json');
         this.requestsDir = path.join(this.root, 'requests');
         this.responsesDir = path.join(this.root, 'responses');
@@ -103,6 +106,9 @@ export class RunDir {
     readPressure() {
         return readValid(PressureStatusSchema, this.pressureFile);
     }
+    readHeartbeat() {
+        return readValid(HeartbeatSchema, this.heartbeatFile);
+    }
     readSession(id) {
         return readValid(SessionStatusSchema, this.sessionFile(id));
     }

package/dist/shared/channel/schema.d.ts

@@ -780,6 +780,7 @@ export declare const GuestRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         slow: "slow";
         severe: "severe";
     }>>;
+    diskQueue: z.ZodOptional<z.ZodNumber>;
     createdAt: z.ZodString;
 }, z.core.$strict>], "kind">;
 /** C:\AgentData\run\pressure.json: what the memory governor in the sandbox is doing (guest-written, capped). */
@@ -808,6 +809,28 @@ export declare const PressureStatusSchema: z.ZodObject<{
     updatedAt: z.ZodString;
 }, z.core.$strip>;
 export type PressureStatus = z.output<typeof PressureStatusSchema>;
+/**
+ * C:\AgentData\run\heartbeat.json: written by the daemon every 10 seconds, so that when the whole sandbox vanishes the
+ * host can say what it was doing in its last seconds (guest-written, every list and string capped).
+ */
+export declare const HeartbeatSchema: z.ZodObject<{
+    at: z.ZodString;
+    uptimeS: z.ZodNumber;
+    ramFreePct: z.ZodNumber;
+    commitPct: z.ZodNumber;
+    step: z.ZodNumber;
+    hostStep: z.ZodNumber;
+    topProcesses: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        privateMb: z.ZodNumber;
+    }, z.core.$strip>>;
+    diskQueueReported: z.ZodOptional<z.ZodNumber>;
+    phase: z.ZodEnum<{
+        ready: "ready";
+        working: "working";
+    }>;
+}, z.core.$strip>;
+export type Heartbeat = z.output<typeof HeartbeatSchema>;
 /** C:\AgentData\run\responses\<id>.json: the guest's reply. */
 export declare const GuestResponseSchema: z.ZodObject<{
     id: z.ZodString;

package/dist/shared/channel/schema.js

@@ -108,6 +108,8 @@ export const GuestRequestSchema = z.discriminatedUnion('kind', [
         seconds: z.number().int().min(10).max(300),
         /** "severe": the PC is nearly out of memory; builds go to the governor's last step at once. */
         level: z.enum(['slow', 'severe']).optional(),
+        /** The disk queue the PC reported (shown in the heartbeat). */
+        diskQueue: z.number().min(0).max(100000).optional(),
         createdAt: TimeSchema,
     }),
 ]);
@@ -131,6 +133,25 @@ export const PressureStatusSchema = z.object({
     lastAction: Text(300),
     updatedAt: TimeSchema,
 });
+/**
+ * C:\AgentData\run\heartbeat.json: written by the daemon every 10 seconds, so that when the whole sandbox vanishes the
+ * host can say what it was doing in its last seconds (guest-written, every list and string capped).
+ */
+export const HeartbeatSchema = z.object({
+    at: TimeSchema,
+    /** Seconds since the sandbox booted. */
+    uptimeS: z.number().int().min(0).max(1e9),
+    ramFreePct: z.number().min(0).max(100),
+    commitPct: z.number().min(0).max(100),
+    /** The governor's dial now, and the step this PC asked for. */
+    step: z.number().int().min(0).max(4),
+    hostStep: z.number().int().min(0).max(4),
+    /** The biggest programs in the agents' job. */
+    topProcesses: z.array(z.object({ name: Text(64), privateMb: z.number().int().min(0).max(1e7) })).max(5),
+    /** The disk queue this PC last reported while asking the sandbox to slow down. */
+    diskQueueReported: z.number().min(0).max(100000).optional(),
+    phase: z.enum(['ready', 'working']),
+});
 /** C:\AgentData\run\responses\<id>.json: the guest's reply. */
 export const GuestResponseSchema = z.object({
     id: IdSchema,

package/dist/shared/memory/policy.d.ts

@@ -55,5 +55,15 @@ export declare function linkSlotsFor(memoryGb: number): number;
 export declare function usableCpus(cpus: number, percent: number | null): number;
 /** Cargo jobs for one more agent session: what fits the memory and CPUs, shared with the sessions already building. */
 export declare function cargoJobs(cpus: number, memoryGb: number, sessions: number): number;
+/** C: needs this much free at boot for rust.targetDir "auto" to build on the sandbox's own disk. */
+export declare const LOCAL_TARGET_MIN_BYTES: number;
+/**
+ * rust.targetDir: "auto" becomes "local" when C: has 25 GB free, else "separate" with a warning (every object file is
+ * then written through the mapped workspace, which can overload this PC's disk). Other values stay as set.
+ */
+export declare function chooseTargetDir(targetDir: string, freeBytes: number): {
+    readonly targetDir: string;
+    readonly warning?: string;
+};
 /** The most heavy compilers (rustc, clippy-driver, link ...) that run at once in the agents' job: only with vGPU on. */
 export declare function maxCompilers(cpus: number, profile: LoadProfile): number | null;

package/dist/shared/memory/policy.js

@@ -88,7 +88,23 @@ export function cargoJobs(cpus, memoryGb, sessions) {
     const jobs = Math.min(byCpu, byMemory);
     return Math.max(1, Math.min(jobs, Math.floor(buildJobs(cpus, memoryGb) / Math.max(1, sessions))));
 }
+/** C: needs this much free at boot for rust.targetDir "auto" to build on the sandbox's own disk. */
+export const LOCAL_TARGET_MIN_BYTES = 25 * 1024 ** 3;
+/**
+ * rust.targetDir: "auto" becomes "local" when C: has 25 GB free, else "separate" with a warning (every object file is
+ * then written through the mapped workspace, which can overload this PC's disk). Other values stay as set.
+ */
+export function chooseTargetDir(targetDir, freeBytes) {
+    if (targetDir !== 'auto')
+        return { targetDir };
+    if (freeBytes >= LOCAL_TARGET_MIN_BYTES)
+        return { targetDir: 'local' };
+    return {
+        targetDir: 'separate',
+        warning: "Rust builds write through the mapped workspace; this can overload your PC's disk (C: has less than 25 GB free for a local build folder)",
+    };
+}
 /** The most heavy compilers (rustc, clippy-driver, link ...) that run at once in the agents' job: only with vGPU on. */
 export function maxCompilers(cpus, profile) {
-    return profile === 'gentle' ? Math.max(2, Math.floor(cpus / 4)) : null;
+    return profile === 'gentle' ? Math.min(4, Math.max(2, Math.floor(cpus / 4))) : null;
 }

package/dist/sync/watcher.js

@@ -256,7 +256,7 @@ export class Watcher {
                     ? 'this PC is low (' + step.reason + '): asking the sandbox to slow its builds down'
                     : 'this PC has recovered: no longer asking the sandbox to slow down');
             if (step.send)
-                new SandboxChannel(this.dataPath).pressure(step.reason, REQUEST_SECONDS, step.severe ? 'severe' : 'slow');
+                new SandboxChannel(this.dataPath).pressure(step.reason, REQUEST_SECONDS, step.severe ? 'severe' : 'slow', memory?.diskQueue);
         }
         catch (e) {
             this.note('host watchdog: ' + errMsg(e));

package/dist/web/index.html

@@ -6,7 +6,7 @@
     <title>Sandbox</title>
     <link rel="icon" href="data:," />
     <link rel="stylesheet" href="/main-XT7T6ODM.css" />
-    <script type="module" src="/main-CWIF4VQI.js"></script>
+    <script type="module" src="/main-6XYO5FZC.js"></script>
   </head>
   <body>
     <div id="root"></div>