windows-development-sandbox 1.18.2 → 1.18.4

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. */

package/dist/host/channel/channel.js

@@ -192,8 +192,16 @@ export class SandboxChannel {
         return this.waitForResponse(requestId, 30000);
     }
     /** The PC is low on memory or CPU: the sandbox slows its builds down for `seconds`. Never waits for an answer. */
-    pressure(reason, seconds, level = 'slow') {
-        this.send({ kind: 'pressure', id: newId(), reason, seconds, level, createdAt: now() });
+    pressure(reason, seconds, level = 'slow', diskQueue) {
+        this.send({
+            kind: 'pressure',
+            id: newId(),
+            reason,
+            seconds,
+            level,
+            ...(diskQueue === undefined ? {} : { diskQueue }),
+            createdAt: now(),
+        });
     }
     async ping() {
         const requestId = newId();

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

@@ -4,3 +4,4 @@ export * from './acl-read.js';
 export * from './stale.js';
 export * from './config-backup.js';
 export * from './path-copies.js';
+export * from './leftovers.js';

package/dist/host/health/index.js

@@ -5,3 +5,4 @@ export * from './acl-read.js';
 export * from './stale.js';
 export * from './config-backup.js';
 export * from './path-copies.js';
+export * from './leftovers.js';

package/dist/host/health/leftovers.d.ts

@@ -0,0 +1,3 @@
+import { type SandboxFacts } from './stale.js';
+/** The facts for judgeSandbox, from the process list, our heartbeat and our life record. `ping`: ask the daemon too. */
+export declare function readSandboxFacts(storageRoot: string, dataPath: string, ping: boolean): Promise<SandboxFacts>;

package/dist/host/health/leftovers.js

@@ -0,0 +1,40 @@
+// Reads what is needed to judge "are the Windows Sandbox programs ours, alive, or left over?" (see judgeSandbox).
+import { LifeRecord, readHeartbeat } from '../life/index.js';
+import { SandboxChannel } from '../channel/index.js';
+import { listProcesses, sessionOf } from '../sharing/index.js';
+import { judgeSandbox } from './stale.js';
+const PING_WAIT_MS = 5000;
+/** The facts for judgeSandbox, from the process list, our heartbeat and our life record. `ping`: ask the daemon too. */
+export async function readSandboxFacts(storageRoot, dataPath, ping) {
+    const rows = listProcesses();
+    const life = new LifeRecord(storageRoot, dataPath).read();
+    const heartbeat = readHeartbeat(dataPath);
+    const nowMs = Date.now();
+    // A heartbeat from before this launch belongs to an earlier sandbox.
+    const mine = heartbeat && (!life || Date.parse(heartbeat.at) >= Date.parse(life.started) - 60000) ? heartbeat : null;
+    const base = {
+        rows,
+        mySession: sessionOf(rows),
+        heartbeatAgeMs: mine ? Math.max(0, nowMs - Date.parse(mine.at)) : null,
+        lifeEnded: Boolean(life?.ended),
+        startedAgeMs: life ? Math.max(0, nowMs - Date.parse(life.started)) : null,
+        answers: null,
+    };
+    if (!ping || judgeSandbox(base).state !== 'leftover')
+        return base;
+    return { ...base, answers: await answers(dataPath) };
+}
+/** Does the sandbox's daemon answer a ping within a few seconds? */
+async function answers(dataPath) {
+    try {
+        const reply = await Promise.race([
+            new SandboxChannel(dataPath).ping().then((r) => r.ok),
+            new Promise((resolve) => setTimeout(() => resolve(false), PING_WAIT_MS).unref()),
+        ]);
+        return reply;
+    }
+    catch {
+        // No answer, or a channel that cannot be used: it does not answer.
+        return false;
+    }
+}

package/dist/host/health/stale.d.ts

@@ -43,3 +43,51 @@ export declare function orphanWatchers(infos: readonly WatcherInfo[], o: {
 }): WatcherInfo[];
 /** null when a small file can be created in the folder, else the reason (the file is removed again). */
 export declare function writeProblem(dir: string): string | null;
+/** The Windows Sandbox programs of the user that a dead sandbox leaves behind (never the VM's own vmwp.exe). */
+export declare const LEFTOVER_IMAGES: readonly ["windowssandbox.exe", "windowssandboxclient.exe", "windowssandboxremotesession.exe", "windowssandboxserver.exe"];
+/** A heartbeat this recent means the sandbox is alive (the sandbox writes one every 10 seconds). */
+export declare const ALIVE_MS: number;
+/** A heartbeat older than this, with the sandbox's programs still there, means the sandbox is gone. */
+export declare const GONE_MS: number;
+/** A sandbox started this recently may not have written a heartbeat yet (a first boot takes minutes). */
+export declare const STARTING_MS: number;
+/** What is known about the Windows Sandbox programs on this PC and our sandbox (read by the caller). */
+export interface SandboxFacts {
+    /** Every process of every session (tasklist). */
+    readonly rows: readonly TaskRow[];
+    /** The Windows session this program runs in; null when unknown (then nothing is ever ended). */
+    readonly mySession: number | null;
+    /** Age of our sandbox's last heartbeat from this run; null when there is none. */
+    readonly heartbeatAgeMs: number | null;
+    /** Our life record says the last sandbox ended (the watcher saw it go). */
+    readonly lifeEnded: boolean;
+    /** Age of our last launch; null when unknown. */
+    readonly startedAgeMs: number | null;
+    /** Did the sandbox answer a ping just now? null: not asked. */
+    readonly answers: boolean | null;
+}
+export type SandboxState = 
+/** No Windows Sandbox program runs. */
+'none'
+/** Ours, and alive (or not known to be gone). */
+ | 'running'
+/** Ours, started a moment ago. */
+ | 'starting'
+/** Programs of a sandbox that is gone: safe to end after asking. */
+ | 'leftover'
+/** Another Windows session's sandbox: never touched. */
+ | 'foreign';
+export interface SandboxJudgement {
+    readonly state: SandboxState;
+    /** The programs of this user's session that cleaning up would end. */
+    readonly pids: readonly number[];
+    readonly images: readonly string[];
+    /** Why, in plain words (for the question). */
+    readonly why: string;
+}
+/**
+ * Is the Windows Sandbox on this PC ours and alive, ours and gone, or someone else's? (pure) It is "leftover" only
+ * with positive evidence: our own programs in our own session, no answer, and either the watcher saw the sandbox end
+ * or its heartbeat stopped long ago. No heartbeat at all (an older sandbox) counts as running.
+ */
+export declare function judgeSandbox(f: SandboxFacts): SandboxJudgement;

package/dist/host/health/stale.js

@@ -118,3 +118,43 @@ export function writeProblem(dir) {
         fs.rmSync(probe, { force: true });
     }
 }
+/** The Windows Sandbox programs of the user that a dead sandbox leaves behind (never the VM's own vmwp.exe). */
+export const LEFTOVER_IMAGES = [
+    'windowssandbox.exe',
+    'windowssandboxclient.exe',
+    'windowssandboxremotesession.exe',
+    'windowssandboxserver.exe',
+];
+/** A heartbeat this recent means the sandbox is alive (the sandbox writes one every 10 seconds). */
+export const ALIVE_MS = 45 * 1000;
+/** A heartbeat older than this, with the sandbox's programs still there, means the sandbox is gone. */
+export const GONE_MS = 2 * 60 * 1000;
+/** A sandbox started this recently may not have written a heartbeat yet (a first boot takes minutes). */
+export const STARTING_MS = 10 * 60 * 1000;
+const isLeftoverImage = (image) => LEFTOVER_IMAGES.includes(image.toLowerCase());
+/**
+ * Is the Windows Sandbox on this PC ours and alive, ours and gone, or someone else's? (pure) It is "leftover" only
+ * with positive evidence: our own programs in our own session, no answer, and either the watcher saw the sandbox end
+ * or its heartbeat stopped long ago. No heartbeat at all (an older sandbox) counts as running.
+ */
+export function judgeSandbox(f) {
+    const sandbox = f.rows.filter((r) => isLeftoverImage(r.image));
+    const mine = f.mySession === null ? [] : sandbox.filter((r) => r.session === f.mySession);
+    const none = (state, why) => ({ state, pids: [], images: [], why });
+    if (sandbox.length === 0)
+        return none('none', 'No Windows Sandbox program is running.');
+    if (mine.length === 0)
+        return none('foreign', 'The Windows Sandbox that runs belongs to another Windows session.');
+    const pids = mine.map((r) => r.pid);
+    const images = [...new Set(mine.map((r) => r.image))];
+    const found = (state, why) => ({ state, pids, images, why });
+    if (f.answers === true || (f.heartbeatAgeMs !== null && f.heartbeatAgeMs <= ALIVE_MS))
+        return found('running', 'The sandbox is working.');
+    if (f.startedAgeMs !== null && f.startedAgeMs <= STARTING_MS && !f.lifeEnded)
+        return found('starting', 'The sandbox started a moment ago.');
+    if (f.lifeEnded)
+        return found('leftover', 'The last sandbox has ended, but its Windows programs are still there.');
+    if (f.heartbeatAgeMs !== null && f.heartbeatAgeMs > GONE_MS)
+        return found('leftover', 'The sandbox has not shown a sign of life for ' + Math.round(f.heartbeatAgeMs / 60000) + ' minutes.');
+    return found('running', 'A sandbox is running (there is no sign that it is gone).');
+}

package/dist/host/launch/wsb-file.d.ts

@@ -18,7 +18,12 @@ export interface MemoryDecision {
     readonly commitAvailableMb: number | null;
 }
 /**
- * The most memory this PC can keep in RAM for the sandbox (pure): its RAM minus max(reserveHostMb, 25 %), and 2 GB
+ * GPU-PV (vGPU) needs room of its own on this PC: the GPU's shared memory for the sandbox comes out of this PC's RAM,
+ * and a GPU game plus heavy builds with vGPU on has killed the VM when the PC had no RAM left for it.
+ */
+export declare const VGPU_RESERVE_MB = 4096;
+/**
+ * The most memory this PC can keep in RAM for the sandbox (pure): its RAM minus max(reserveHostMb, 25 %), and 4 GB
  * more with vGPU. Windows Sandbox's memory is this PC's memory taken as needed; beyond what the PC can keep resident it
  * is paged to this PC's disk while the sandbox pages to its own, and that is what can freeze the whole PC.
  */

package/dist/host/launch/wsb-file.js

@@ -11,10 +11,13 @@ export const GUEST = {
 const MB = 1048576;
 const MIN_AUTO_MEMORY_MB = 4096;
 const roundDown = (mb) => Math.floor(mb / 1024) * 1024;
-/** GPU-PV (vGPU) needs room of its own on this PC: memory the graphics driver pins for the sandbox. */
-const VGPU_RESERVE_MB = 2048;
 /**
- * The most memory this PC can keep in RAM for the sandbox (pure): its RAM minus max(reserveHostMb, 25 %), and 2 GB
+ * GPU-PV (vGPU) needs room of its own on this PC: the GPU's shared memory for the sandbox comes out of this PC's RAM,
+ * and a GPU game plus heavy builds with vGPU on has killed the VM when the PC had no RAM left for it.
+ */
+export const VGPU_RESERVE_MB = 4096;
+/**
+ * The most memory this PC can keep in RAM for the sandbox (pure): its RAM minus max(reserveHostMb, 25 %), and 4 GB
  * more with vGPU. Windows Sandbox's memory is this PC's memory taken as needed; beyond what the PC can keep resident it
  * is paged to this PC's disk while the sandbox pages to its own, and that is what can freeze the whole PC.
  */
@@ -46,8 +49,9 @@ export function residentNote(asked, given) {
  */
 export function decideMemory(sandbox, freeMb, totalMb, commitAvailableMb) {
     const shareMb = Math.floor((totalMb * sandbox.maxMemoryPercent) / 100);
-    const byFree = freeMb - sandbox.reserveHostMb;
-    const byCommit = commitAvailableMb === null ? Infinity : commitAvailableMb - sandbox.reserveHostMb;
+    const reserveMb = sandbox.reserveHostMb + (sandbox.vGpu ? VGPU_RESERVE_MB : 0);
+    const byFree = freeMb - reserveMb;
+    const byCommit = commitAvailableMb === null ? Infinity : commitAvailableMb - reserveMb;
     const candidates = [
         ['max', sandbox.maxMemoryMb],
         ['share', shareMb],

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

@@ -11,6 +11,8 @@ export interface CrashExtra {
     readonly hostMemoryNow?: string;
     /** The frozen sandbox's launch had vGPU on (read from its .wsb). */
     readonly vgpu?: boolean;
+    /** The sandbox's last heartbeat as a line (see heartbeatLine): what it was doing inside. */
+    readonly lastInside?: string;
 }
 /** "This PC stopped responding at X and was restarted at Y (n minutes later)", or null when there was no long gap. */
 export declare function freezeLine(cause: StopCause, lastSeen: string): string | null;
@@ -33,4 +35,4 @@ export declare function newestCrashReport(storageRoot: string): {
 /**
  * When the sandbox ended in a crash (its own, this PC's, power, low memory): writes the report and returns its path.
  */
-export declare function saveCrashReport(storageRoot: string, dataPath: string, lastSeen: string): string | null;
+export declare function saveCrashReport(storageRoot: string, dataPath: string, lastSeen: string, known?: StopCause | null): string | null;

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

@@ -6,11 +6,14 @@ import { assertNoLinks, safeText } from '../../core/util/index.js';
 import { vgpuWarning } from '../launch/risk-notes.js';
 import { hostMemoryLine, readHostMemory } from './host-memory.js';
 import { hostDataFolder, hostDataRoot } from '../storage/index.js';
+import { heartbeatLine, readHeartbeat } from './last-end.js';
 import { bugcheckCode, explainStop, readStopEvents } from './stop-events.js';
 const KEEP_REPORTS = 20;
 const MEMORY_TAIL_BYTES = 16 * 1024;
 /** A gap longer than this between "last seen running" and the restart means the PC stopped responding first. */
 const FREEZE_GAP_MS = 5 * 60 * 1000;
+/** The ends that get a crash report (not updates, restarts and sleep: those are plain). */
+const REPORTED = ['sandboxCrash', 'crash', 'memory', 'gpu', 'hyperv', 'vanished'];
 function crashDir(storageRoot) {
     return path.join(storageRoot, 'logs', 'crashes');
 }
@@ -170,6 +173,7 @@ export function crashReportText(cause, events, memoryLog, lastSeen, extra = {})
         ...(hostLines.length ? hostLines : ['  (none: the background sync was not running)']),
         ...(extra.hostMemoryNow ? ['  after the restart: ' + extra.hostMemoryNow] : []),
         '',
+        ...(extra.lastInside ? [safeText(extra.lastInside), ''] : []),
         "The sandbox's memory log, last lines (C:\\AgentData\\logs\\memory-*.log inside it):",
         ...memoryLines,
         '',
@@ -228,10 +232,10 @@ function memoryLogTail(dataPath) {
 /**
  * When the sandbox ended in a crash (its own, this PC's, power, low memory): writes the report and returns its path.
  */
-export function saveCrashReport(storageRoot, dataPath, lastSeen) {
+export function saveCrashReport(storageRoot, dataPath, lastSeen, known = null) {
     const events = readStopEvents(new Date(Date.parse(lastSeen) - 2 * 60 * 1000), storageRoot);
-    const cause = explainStop(events);
-    if (!cause || !['sandboxCrash', 'crash', 'memory'].includes(cause.kind))
+    const cause = explainStop(events) ?? known;
+    if (!cause || !REPORTED.includes(cause.kind))
         return null;
     const dir = crashDir(storageRoot);
     fs.mkdirSync(dir, { recursive: true });
@@ -239,9 +243,11 @@ export function saveCrashReport(storageRoot, dataPath, lastSeen) {
     const since = new Date(Date.parse(lastSeen) - 10 * 60 * 1000);
     const windir = process.env.SystemRoot ?? 'C:\\Windows';
     const memoryNow = readHostMemory(storageRoot);
+    const heartbeat = readHeartbeat(dataPath);
     fs.writeFileSync(file, crashReportText(cause, events, memoryLogTail(dataPath), lastSeen, {
         hostMemoryLog: hostMemoryTail(storageRoot, dataPath),
         vgpu: launchHadVgpu(storageRoot, lastSeen),
+        ...(heartbeat ? { lastInside: heartbeatLine(heartbeat) } : {}),
         dumps: findDumps([path.join(windir, 'Minidump'), windir], since),
         ...(memoryNow ? { hostMemoryNow: hostMemoryLine(memoryNow) } : {}),
     }));

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

@@ -4,6 +4,7 @@ export * from './stop-warning.js';
 export * from './keep-awake.js';
 export * from './windows-update.js';
 export * from './crash-report.js';
+export * from './last-end.js';
 export * from './session-ledger.js';
 export * from './host-memory.js';
 export * from './watchdog.js';

package/dist/host/life/index.js

@@ -4,6 +4,7 @@ export * from './stop-warning.js';
 export * from './keep-awake.js';
 export * from './windows-update.js';
 export * from './crash-report.js';
+export * from './last-end.js';
 export * from './session-ledger.js';
 export * from './host-memory.js';
 export * from './watchdog.js';

package/dist/host/life/last-end.d.ts

@@ -0,0 +1,28 @@
+import { type Heartbeat } from '../../shared/channel/index.js';
+import type { Life } from './life-record.js';
+import type { StopCause } from './stop-events.js';
+/** How the last sandbox ended, when nobody closed it. */
+export interface LastEnd {
+    /** "ended unexpectedly 21:31: this PC's disks were overloaded (queue 40)". */
+    readonly text: string;
+    readonly at: string;
+}
+/** The sandbox's last heartbeat, or null (none written, damaged, or reached through a link). */
+export declare function readHeartbeat(dataPath: string): Heartbeat | null;
+/** One line of what the sandbox was doing at its last heartbeat (pure; guest text goes through safeText). */
+export declare function heartbeatLine(hb: Heartbeat): string;
+/** The likeliest reason, from the last heartbeat (pure). */
+export declare function guessReason(hb: Heartbeat | null): string;
+/**
+ * The sandbox went and nothing was logged (pure): its last heartbeat is fresh, from this run, says it was working
+ * (a session running, or builds slowed down) and does not say it was shutting down in order, and nobody stopped it on
+ * purpose (`sandbox stop`, a restart). The guest cannot tell a closed window from a crash, so the wording says both.
+ */
+export declare function vanishedCause(hb: Heartbeat | null, startedIso: string, closedOnPurpose: boolean, endedAtMs: number): StopCause | null;
+/**
+ * How the last sandbox ended (pure): null when it was closed normally, or is still running. `heartbeat` only counts
+ * when it was written during that run.
+ */
+export declare function lastEndOf(life: Life | null, heartbeat: Heartbeat | null, running: boolean): LastEnd | null;
+/** The status page's "Last sandbox" fact for this data folder. */
+export declare function readLastEnd(lifeRead: () => Life | null, dataPath: string, running: boolean): LastEnd | null;