windows-development-sandbox 1.18.2 → 1.18.4

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

@@ -8,12 +8,17 @@ 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, vanishedCause, stopWarning } 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 { judgeSandbox } from '../host/health/index.js';
+import { cleanUpLeftovers, cleanupQuestion, killArgs } from '../host/sandbox/index.js';
+import { parseTasklist } from '../host/sharing/index.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 +68,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 +178,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 +202,139 @@ 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: 'a\u0007b', privateMb: 5 }] }).includes('\u0007') === 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('Windows Sandbox programs left behind by a dead sandbox');
+        const list = [
+            '"explorer.exe","1200","Console","1","90,000 K"',
+            '"WindowsSandboxClient.exe","4100","Console","1","30,000 K"',
+            '"WindowsSandboxRemoteSession.exe","4200","Console","1","40,000 K"',
+            '"vmwp.exe","4300","Services","0","50,000 K"',
+            '"WindowsSandboxServer.exe","4400","Console","2","30,000 K"',
+        ].join('\n');
+        const baseFacts = {
+            rows: parseTasklist(list),
+            mySession: 1,
+            heartbeatAgeMs: null,
+            lifeEnded: false,
+            startedAgeMs: 3_600_000,
+            answers: null,
+        };
+        const judged = (patch) => judgeSandbox({ ...baseFacts, ...patch });
+        t.check(judged({ rows: parseTasklist('"explorer.exe","1200","Console","1","1 K"') }).state === 'none', 'no Windows Sandbox program: none');
+        t.check(judged({ heartbeatAgeMs: 10_000 }).state === 'running' &&
+            judged({ answers: true, lifeEnded: true }).state === 'running', 'a fresh heartbeat, or a ping answered: the sandbox is ours and running');
+        t.check(judged({ startedAgeMs: 60_000 }).state === 'starting', 'started a minute ago, no heartbeat yet: starting');
+        const leftoverJudged = judged({ lifeEnded: true });
+        t.check(leftoverJudged.state === 'leftover' &&
+            leftoverJudged.pids.join() === '4100,4200' &&
+            leftoverJudged.images.join() === 'WindowsSandboxClient.exe,WindowsSandboxRemoteSession.exe', 'the watcher saw it end but the programs remain: leftover; only this session, only the user programs (not vmwp.exe, not session 2)', leftoverJudged.pids.join());
+        t.check(judged({ heartbeatAgeMs: 600_000 }).state === 'leftover', 'a heartbeat that stopped ten minutes ago: leftover');
+        t.check(judged({ heartbeatAgeMs: 100_000 }).state === 'running', 'a heartbeat 100 seconds old is not yet "gone"');
+        t.check(judged({}).state === 'running', 'no heartbeat at all (an older sandbox) and no end: treated as running, never ended');
+        t.check(judged({ mySession: null, lifeEnded: true }).state === 'foreign' &&
+            judged({ mySession: 3, lifeEnded: true }).pids.length === 0, "another session's sandbox is never touched");
+        t.check(killArgs([4100, 4200, 0, 2, -5, 1.5]).join(' ') === '/F /PID 4100 /PID 4200' &&
+            cleanupQuestion(leftoverJudged).lines.join(' ').includes('Nothing else'), 'taskkill gets only real process ids; the question names what is closed');
+        const run = async (facts, answers, over = {}) => {
+            const did = [];
+            let n = 0;
+            let asked = 0;
+            const outcome = await cleanUpLeftovers({
+                facts: () => Promise.resolve(facts[Math.min(n++, facts.length - 1)]),
+                end: (pids) => {
+                    did.push('end ' + pids.join(','));
+                    return true;
+                },
+                restartService: () => {
+                    did.push('service');
+                    return true;
+                },
+                confirm: () => Promise.resolve(answers[asked++] ?? false),
+                say: (line) => did.push('say ' + line),
+                ...over,
+            });
+            return { outcome, did };
+        };
+        const noneLeft = { ...baseFacts, rows: [] };
+        const asked = await run([{ ...baseFacts, lifeEnded: true }, noneLeft], [true]);
+        t.check(asked.outcome === 'cleaned' && asked.did[0] === 'end 4100,4200' && !asked.did.includes('service'), 'leftover, yes: they are closed and nothing else happens');
+        const declinedRun = await run([{ ...baseFacts, lifeEnded: true }], [false]);
+        t.check(declinedRun.outcome === 'declined' && declinedRun.did.length === 0, 'leftover, no: nothing is closed');
+        const live = await run([{ ...baseFacts, heartbeatAgeMs: 5000 }], [true]);
+        t.check(live.outcome === 'alive' && !live.did.some((d) => d.startsWith('end')), 'a sandbox that is alive is never closed, whatever the answer');
+        t.check((await run([noneLeft], [true])).outcome === 'nothing', 'nothing left: nothing to do');
+        const stuck = { ...baseFacts, lifeEnded: true };
+        const serviceYes = await run([stuck, stuck], [true, true]);
+        t.check(serviceYes.outcome === 'service-restarted' && serviceYes.did.includes('service'), 'programs that will not go: asks, then restarts the service (elevated)');
+        const serviceNo = await run([stuck, stuck], [true, false]);
+        t.check(serviceNo.outcome === 'declined' && !serviceNo.did.includes('service'), 'the service is only restarted when you say yes');
+        const forced = await run([stuck, noneLeft], [true], { alsoService: true });
+        t.check(forced.outcome === 'service-restarted', 'asked to restart the service as well: it does, without a second question');
         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 +422,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' })
@@ -322,6 +473,53 @@ export const heavyLoadSuite = {
         t.check(pageFileRisk(pc({ pageFile: 'fixed', commitLimitMb: 90000, commitAvailableMb: 80000 }), 20000) === null, 'a fixed but large one is fine');
         t.section('the crash report');
         const ev = (id, provider, at, process = '') => ({ id, provider, at, process });
+        t.section('a sandbox that vanishes');
+        const kindOf = (events) => explainStop(events)?.kind ?? 'none';
+        t.check(kindOf([
+            ev(4101, 'Display', '2026-11-02T21:31:00Z', 'Display driver nvlddmkm stopped responding and has successfully recovered.'),
+        ]) === 'gpu' && explainStop([ev(4101, 'Display', '2026-11-02T21:31:00Z')]).text.includes('graphics driver'), 'Display 4101: the graphics driver reset (gpu)');
+        t.check(kindOf([
+            ev(1001, 'Windows Error Reporting', '2026-11-02T21:31:00Z', 'Fault bucket 1, type 5' + ' Event Name: LiveKernelEvent' + ' P1: 141' + ' P2: ffff'),
+        ]) === 'gpu' &&
+            kindOf([
+                ev(1001, 'Windows Error Reporting', '2026-11-02T21:31:00Z', 'Event Name: LiveKernelEvent P1: 1a8 P2: 0'),
+            ]) === 'gpu' &&
+            kindOf([
+                ev(1001, 'Windows Error Reporting', '2026-11-02T21:31:00Z', 'Event Name: LiveKernelEvent P1: 999 P2: 0'),
+            ]) === 'none', 'LiveKernelEvent 117, 141 and 1a8 are GPU resets; other codes are not a cause');
+        t.check(explainStop([ev(1000, 'Application Error', '2026-11-02T21:31:00Z', 'Faulting application name: vmwp.exe')])
+            ?.kind === 'hyperv' &&
+            kindOf([ev(1001, 'Windows Error Reporting', '2026-11-02T21:31:00Z', 'vmmemWindowsSandbox crashed')]) ===
+                'hyperv' &&
+            kindOf([ev(1000, 'Application Error', '2026-11-02T21:31:00Z', 'Faulting application name: notepad.exe')]) ===
+                'none', 'a crash report of vmwp.exe or vmmem is a cause; another program is not');
+        t.check(kindOf([ev(12010, 'Microsoft-Windows-Hyper-V-VmSwitch', '2026-11-02T21:31:00Z')]) === 'hyperv' &&
+            kindOf([ev(40001, 'Microsoft-Windows-Hyper-V-Worker', '2026-11-02T21:31:00Z')]) === 'none' &&
+            kindOf([ev(18590, 'Microsoft-Windows-Hyper-V-Worker', '2026-11-02T21:31:00Z', 'ErrorCode0: 0x50')]) ===
+                'sandboxCrash', 'Hyper-V worker, switch and compute errors are a cause; the sandbox crashing inside is still its own kind');
+        const started = '2026-11-02T20:45:00.000Z';
+        const endMs = Date.parse('2026-11-02T21:32:00.000Z');
+        const working = {
+            at: '2026-11-02T21:31:50.000Z',
+            uptimeS: 2800,
+            ramFreePct: 60,
+            commitPct: 30,
+            step: 0,
+            hostStep: 0,
+            topProcesses: [],
+            phase: 'working',
+        };
+        t.check(vanishedCause(working, started, false, endMs)?.kind === 'vanished', 'busy, fresh heartbeat, no word of leaving: vanished');
+        t.check(vanishedCause({ ...working, phase: 'ending' }, started, false, endMs) === null &&
+            vanishedCause(working, started, true, endMs) === null &&
+            vanishedCause(null, started, false, endMs) === null, 'an orderly end, a stop on purpose, or no heartbeat is not a vanishing');
+        t.check(vanishedCause({ ...working, phase: 'ready' }, started, false, endMs) === null &&
+            vanishedCause({ ...working, phase: 'ready', step: 2 }, started, false, endMs)?.kind === 'vanished', 'an idle sandbox (window closed by hand) is on purpose; one that was slowing builds down is not');
+        t.check(vanishedCause({ ...working, at: '2026-11-02T21:20:00.000Z' }, started, false, endMs) === null &&
+            vanishedCause({ ...working, at: '2026-11-01T21:31:50.000Z' }, started, false, endMs) === null, 'a stale heartbeat, or one from an earlier run, says nothing about this end');
+        const gone = vanishedCause(working, started, false, endMs);
+        const warning = stopWarning({ started, lastSeen: '2026-11-02T21:31:30.000Z', keepAwake: false, ended: { at: gone.at, cause: gone } }, () => null);
+        t.check((warning ?? '').includes('ended suddenly') && (warning ?? '').includes('vGPU'), 'the next launch warns about a vanished sandbox, and says what usually causes it');
         t.check(bugcheckCode('BugcheckCode 209') === '0xD1' && bugcheckCode('BugcheckCode 0') === null, 'Kernel-Power 41 stop code');
         const cause = explainStop([ev(41, 'Microsoft-Windows-Kernel-Power', '2026-10-15T20:53:47Z', 'BugcheckCode 0')]);
         t.check(cause?.kind === 'crash' && cause.text.includes('freeze'), 'no stop code: a freeze, crash or power cut');

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,29 @@ 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";
+        ending: "ending";
+    }>;
+}, 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,26 @@ 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(),
+    /** "ending": the sandbox is shutting down in order (idle shutdown, sandbox stop, Windows shutting down). */
+    phase: z.enum(['ready', 'working', 'ending']),
+});
 /** 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/shared/system.d.ts

@@ -3,6 +3,7 @@ export declare const SYSTEM: {
     readonly cmd: () => string;
     readonly powershell: () => string;
     readonly tasklist: () => string;
+    readonly taskkill: () => string;
     readonly whoami: () => string;
     readonly icacls: () => string;
     readonly tar: () => string;

package/dist/shared/system.js

@@ -9,6 +9,7 @@ export const SYSTEM = {
     cmd: () => system32('cmd.exe'),
     powershell: () => system32('WindowsPowerShell\\v1.0\\powershell.exe'),
     tasklist: () => system32('tasklist.exe'),
+    taskkill: () => system32('taskkill.exe'),
     whoami: () => system32('whoami.exe'),
     icacls: () => system32('icacls.exe'),
     tar: () => system32('tar.exe'),

package/dist/sync/watcher.js

@@ -13,7 +13,7 @@ import { readForwards, sandboxAddress, startPortForwards } from '../host/network
 import { AuditCollector, AuditLog, readAuditSettings } from '../host/audit/index.js';
 import { readMarkedProjects, saveDataSize, watchAndMark } from '../host/guard/index.js';
 import { sizeWithin } from '../core/disk.js';
-import { autoRestartAllowed, causeSince, appendHostMemory, cpuPercentBetween, KeepAwake, LifeRecord, HostMemoryStream, readHostMemoryAsync, readLoadSettings, REQUEST_SECONDS, WATCHDOG_START, watchdogStep, saveCrashReport, SessionLedger, } from '../host/life/index.js';
+import { autoRestartAllowed, causeSince, readHeartbeat, vanishedCause, appendHostMemory, cpuPercentBetween, KeepAwake, LifeRecord, HostMemoryStream, readHostMemoryAsync, readLoadSettings, REQUEST_SECONDS, WATCHDOG_START, watchdogStep, saveCrashReport, SessionLedger, } from '../host/life/index.js';
 import { SandboxChannel } from '../host/channel/index.js';
 import { ProjectRegistry } from '../host/projects/registry.js';
 import { ContainedStorage, setNameOf, storageOf } from '../host/storage/index.js';
@@ -67,7 +67,7 @@ export function watcherRunning(dataPath) {
     }
 }
 /** The ways the sandbox itself ends badly (the PC going down takes the watcher with it, so it never gets here). */
-const RESTARTABLE = ['sandboxCrash', 'memory'];
+const RESTARTABLE = ['sandboxCrash', 'memory', 'gpu', 'hyperv', 'vanished'];
 /**
  * The background watcher of one data folder: while the sandbox runs it syncs history back every minute, guards the
  * projects' git folders, keeps filtered workspaces in step, forwards ports, marks downloaded files, records the audit
@@ -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));
@@ -318,8 +318,13 @@ export class Watcher {
     recordEnd() {
         try {
             const last = this.life.read();
-            const cause = last ? causeSince(last.lastSeen, this.storageRoot) : null;
-            const report = last && cause ? saveCrashReport(this.storageRoot, this.dataPath, last.lastSeen) : null;
+            // Windows' own log first; when it says nothing, a sandbox that was busy and left no word of leaving "vanished".
+            const logged = last ? causeSince(last.lastSeen, this.storageRoot) : null;
+            const cause = logged ??
+                (last
+                    ? vanishedCause(readHeartbeat(this.dataPath), last.started, this.ledger.read()?.closedOnPurpose === true, Date.now())
+                    : null);
+            const report = last && cause ? saveCrashReport(this.storageRoot, this.dataPath, last.lastSeen, cause) : null;
             this.life.end(cause, new Date(), report);
             this.cause = cause;
             // Ended with nothing wrong (its window closed, or it shut itself down idle): on purpose.

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-GVZWWP4I.js"></script>
   </head>
   <body>
     <div id="root"></div>