windows-development-sandbox 1.18.3 → 1.18.4

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

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

package/dist/bin/{chunk-3G53NNZP.js → chunk-N4GXYTLV.js}

@@ -228,7 +228,7 @@ import {
   withOperationCommands,
   working,
   writeJson
-} from "./chunk-FQWYCF6L.js";
+} from "./chunk-FRPLQLSY.js";
 
 // node_modules/commander/lib/error.js
 var require_error = __commonJS({

package/dist/bin/claude-host.js

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

package/dist/bin/claude-sbx.js

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

package/dist/bin/codex-sbx.js

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

package/dist/bin/gemini-sbx.js

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

package/dist/bin/sandbox.js

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

package/dist/bin/sbx-hide.js

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

package/dist/bin/sbx-show.js

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

package/dist/cli/commands/launch/launch.js

@@ -21,6 +21,7 @@ import { watcherRunning } from '../../../sync/index.js';
 import { protectionsOf } from '../../../core/local-config/index.js';
 import { errMsg } from '../../../core/util/index.js';
 import { askYesNo } from '../../../core/prompt.js';
+import { offerLeftoverCleanup } from './leftover-offer.js';
 import { resolveRun } from '../../../core/run/index.js';
 import { c, table } from '../../output/index.js';
 import { syncAgentCommands } from '../agent-commands.js';
@@ -133,8 +134,10 @@ class Launcher {
         const provider = providerFor(config, config.storage.contained === 'off'
             ? {}
             : { contained: realContainedDeps(ctx.storageRoot, config.storage.containedMaxGb, Boolean(ctx.options.config)) });
-        if (!generateOnly)
+        if (!generateOnly) {
+            await offerLeftoverCleanup(ctx);
             assertCanLaunch(isSandboxRunning() ? runningOwner() : undefined);
+        }
         // Contained storage: the image is mounted now (before anything reads or writes the data set), and let go of again
         // when the launch fails before the sandbox starts. The background watcher holds it from then on.
         const dataMappings = await this.prepareStorage(provider, run);

package/dist/cli/commands/launch/leftover-offer.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from '../context.js';
+/** Does nothing unless leftovers are found; then asks (needs a terminal) and fails with the way out when declined. */
+export declare function offerLeftoverCleanup(ctx: Context): Promise<void>;

package/dist/cli/commands/launch/leftover-offer.js

@@ -0,0 +1,26 @@
+// A launch that finds Windows Sandbox programs left behind by a sandbox that is gone (a crash, a kill from outside):
+// Windows then says "already running" or that the sandbox was signed out. Asks to close them and goes on.
+import { askYesNo } from '../../../core/prompt.js';
+import { fail } from '../../../core/util/index.js';
+import { readSandboxFacts } from '../../../host/health/index.js';
+import { cleanUpLeftovers, endSandboxPrograms, isSandboxRunning, restartSandboxService, } from '../../../host/sandbox/index.js';
+import { c } from '../../output/index.js';
+/** Does nothing unless leftovers are found; then asks (needs a terminal) and fails with the way out when declined. */
+export async function offerLeftoverCleanup(ctx) {
+    if (!isSandboxRunning())
+        return;
+    const { storageRoot, dataPath } = ctx;
+    const outcome = await cleanUpLeftovers({
+        facts: () => readSandboxFacts(storageRoot, dataPath, true),
+        end: endSandboxPrograms,
+        restartService: restartSandboxService,
+        confirm: (q) => {
+            for (const line of q.lines)
+                console.log(c.yellow(line));
+            return askYesNo(q.title, true);
+        },
+        say: (line) => console.log(line),
+    });
+    if (outcome === 'declined' || outcome === 'failed')
+        fail('Windows Sandbox programs from a sandbox that is gone are still there, so a new one cannot start.', 'Run sandbox cleanup (it asks first), or end the WindowsSandbox programs in Task Manager.');
+}

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

@@ -6,10 +6,10 @@ import path from 'node:path';
 import { diskUsage, humanBytes } from '../../../../core/disk.js';
 import { dirExists, fileExists, isLink } from '../../../../core/util/index.js';
 import { SandboxChannel } from '../../../../host/channel/index.js';
-import { orphanWatchers, runStateProblems, staleLaunchFolders, watcherRecords } from '../../../../host/health/index.js';
+import { judgeSandbox, orphanWatchers, readSandboxFacts, runStateProblems, staleLaunchFolders, watcherRecords, } from '../../../../host/health/index.js';
 import { vgpuSource, vgpuWarning } from '../../../../host/launch/index.js';
 import { hostToolsExe } from '../../../../host/native.js';
-import { sandboxFeatureInstalled } from '../../../../host/sandbox/index.js';
+import { endSandboxPrograms, sandboxFeatureInstalled } from '../../../../host/sandbox/index.js';
 import { assertTestWritable, refuseInSelfTest } from '../../../../host/test-guard.js';
 import { conptyDir, terminalDir, terminalExe } from '../../../../host/tools/index.js';
 import { RunDir } from '../../../../shared/channel/index.js';
@@ -90,6 +90,33 @@ export const SANDBOX_CHECKS = [
             };
         },
     },
+    {
+        id: 'sandbox-leftover',
+        group: 'Sandbox',
+        name: 'Leftover Windows Sandbox programs',
+        run: async (env) => {
+            if (!env.running)
+                return ok('none');
+            const found = judgeSandbox(await readSandboxFacts(env.storageRoot, env.dataPath, false));
+            if (found.state !== 'leftover')
+                return ok(found.state === 'none' ? 'none' : 'the sandbox is working');
+            return {
+                status: 'needs-you',
+                detail: found.why,
+                means: 'A sandbox that died leaves its Windows programs behind, and Windows then refuses to start a new one ("the sandbox was signed out" or "already running").',
+                plan: 'close ' + found.images.join(', ') + ' (only the ones in your Windows session)',
+                data: found.pids,
+            };
+        },
+        fix: (_env, finding) => {
+            const pids = Array.isArray(finding.data) ? finding.data : [];
+            return endSandboxPrograms(pids)
+                ? { done: 'closed the leftover Windows Sandbox programs' }
+                : {
+                    done: 'Windows would not close some of them; sandbox cleanup can also restart the Windows Sandbox service',
+                };
+        },
+    },
     {
         id: 'sandbox-run-state',
         group: 'Sandbox',

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

@@ -1,6 +1,11 @@
 import type { Heartbeat } from '../../shared/channel/schema.js';
 import { type GovernorSnapshot } from '../governor/index.js';
 /** The heartbeat for these numbers (the governor's snapshot when it has one, else Windows' own free memory). */
-export declare function buildHeartbeat(snapshot: GovernorSnapshot | null, sessionCount: number, uptimeSeconds: number, freeBytes: number, totalBytes: number, at: string): Heartbeat;
+export declare function buildHeartbeat(snapshot: GovernorSnapshot | null, sessionCount: number, uptimeSeconds: number, freeBytes: number, totalBytes: number, at: string, ending?: boolean): Heartbeat;
+/**
+ * The last heartbeat of an orderly end (idle shutdown, `sandbox stop`, Windows shutting down): the host then knows the
+ * sandbox was not lost. A sandbox that just vanishes leaves a busy heartbeat instead.
+ */
+export declare function markEnding(): void;
 /** Writes the heartbeat now and every 10 seconds; a failed write is only a warning. */
-export declare function startHeartbeat(): void;
+export declare function startHeartbeat(sessionCount: () => number): void;

package/dist/guest/daemon/heartbeat.js

@@ -7,11 +7,10 @@ import { governor } from '../governor/index.js';
 import { run } from '../runtime/paths.js';
 import { warn } from '../runtime/log.js';
 import { errMsg } from '../../core/util/errors.js';
-import { sessions } from './sessions.js';
 const BEAT_MS = 10000;
 const clamp = (n, low, high) => Math.max(low, Math.min(high, n));
 /** The heartbeat for these numbers (the governor's snapshot when it has one, else Windows' own free memory). */
-export function buildHeartbeat(snapshot, sessionCount, uptimeSeconds, freeBytes, totalBytes, at) {
+export function buildHeartbeat(snapshot, sessionCount, uptimeSeconds, freeBytes, totalBytes, at, ending = false) {
     const ramFree = snapshot?.ramFreePercent ?? Math.round((freeBytes / Math.max(1, totalBytes)) * 100);
     return {
         at,
@@ -21,20 +20,40 @@ export function buildHeartbeat(snapshot, sessionCount, uptimeSeconds, freeBytes,
         step: clamp(snapshot?.step ?? 0, 0, 4),
         hostStep: clamp(snapshot?.hostStep ?? 0, 0, 4),
         topProcesses: (snapshot?.top ?? []).slice(0, 5).map((p) => ({ name: p.name.slice(0, 64), privateMb: p.mb })),
-        ...(snapshot?.diskQueue != null ? { diskQueueReported: snapshot.diskQueue } : {}),
-        phase: sessionCount > 0 ? 'working' : 'ready',
+        ...(snapshot?.diskQueue !== null && snapshot?.diskQueue !== undefined
+            ? { diskQueueReported: snapshot.diskQueue }
+            : {}),
+        phase: ending ? 'ending' : sessionCount > 0 ? 'working' : 'ready',
     };
 }
+/** How many sessions run (set by startHeartbeat; this file must not import the sessions, which end through it). */
+let countSessions = () => 0;
+function writeBeat(ending) {
+    try {
+        writeJsonAtomic(run.heartbeatFile, buildHeartbeat(governor.snapshot(), countSessions(), os.uptime(), os.freemem(), os.totalmem(), now(), ending));
+    }
+    catch (e) {
+        warn('heartbeat: ' + errMsg(e));
+    }
+}
+/**
+ * The last heartbeat of an orderly end (idle shutdown, `sandbox stop`, Windows shutting down): the host then knows the
+ * sandbox was not lost. A sandbox that just vanishes leaves a busy heartbeat instead.
+ */
+export function markEnding() {
+    writeBeat(true);
+}
 /** Writes the heartbeat now and every 10 seconds; a failed write is only a warning. */
-export function startHeartbeat() {
-    const beat = () => {
-        try {
-            writeJsonAtomic(run.heartbeatFile, buildHeartbeat(governor.snapshot(), sessions.count, os.uptime(), os.freemem(), os.totalmem(), now()));
-        }
-        catch (e) {
-            warn('heartbeat: ' + errMsg(e));
-        }
-    };
-    beat();
-    setInterval(beat, BEAT_MS).unref();
+export function startHeartbeat(sessionCount) {
+    countSessions = sessionCount;
+    writeBeat(false);
+    const timer = setInterval(() => writeBeat(false), BEAT_MS);
+    timer.unref();
+    // Windows shutting down or the console closing: say so, then end (the default for these signals).
+    for (const signal of ['SIGHUP', 'SIGBREAK', 'SIGTERM'])
+        process.on(signal, () => {
+            clearInterval(timer);
+            markEnding();
+            process.exit(0);
+        });
 }

package/dist/guest/daemon/idle-shutdown.js

@@ -9,6 +9,7 @@ import { log } from '../runtime/log.js';
 import { session } from '../runtime/session.js';
 import { safely } from './state.js';
 import { flushAccounts } from './accounts.js';
+import { markEnding } from './heartbeat.js';
 /** How long the sandbox must stay idle before it shuts down. */
 const GRACE_MS = 15000;
 export class IdleShutdown {
@@ -27,6 +28,7 @@ export class IdleShutdown {
             if (!this.idle())
                 return;
             log('Headless sandbox has no sessions left; shutting down.');
+            safely('heartbeat', markEnding);
             safely('claude-mem save', saveClaudeMem);
             safely('agent databases save', saveLocalState);
             // Renewed sign-ins go to the PC, and a held one (a Unity seat) is let go, before Windows stops.

package/dist/guest/entries/daemon.js

@@ -25,5 +25,5 @@ safely('leftover processes', () => sessions.sweepLeftovers());
 safely('memory governor', () => governor.start());
 log('Memory governor: ' + governor.describe());
 safely('service sign-ins', startAccountWatch);
-safely('heartbeat', startHeartbeat);
+safely('heartbeat', () => startHeartbeat(() => sessions.count));
 new Daemon().start();

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/life/crash-report.d.ts

@@ -35,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

@@ -12,6 +12,8 @@ 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');
 }
@@ -230,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 });

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

@@ -1,5 +1,6 @@
 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)". */
@@ -12,6 +13,12 @@ export declare function readHeartbeat(dataPath: string): Heartbeat | null;
 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.

package/dist/host/life/last-end.js

@@ -49,6 +49,27 @@ export function guessReason(hb) {
         return 'the sandbox was running out of memory';
     return 'Windows stopped it (no reason was logged)';
 }
+/** A heartbeat older than this before the end is not "it was working when it went". */
+const FRESH_MS = 2 * 60 * 1000;
+/**
+ * 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 function vanishedCause(hb, startedIso, closedOnPurpose, endedAtMs) {
+    if (!hb || closedOnPurpose || hb.phase === 'ending')
+        return null;
+    const seen = Date.parse(hb.at);
+    if (!Number.isFinite(seen) || seen < Date.parse(startedIso) - 60000 || endedAtMs - seen > FRESH_MS)
+        return null;
+    if (hb.phase !== 'working' && hb.step === 0 && hb.hostStep === 0)
+        return null;
+    return {
+        kind: 'vanished',
+        at: new Date(endedAtMs).toISOString(),
+        text: 'the sandbox ended suddenly while it was working (its window was closed, or it crashed: Windows logged nothing)',
+    };
+}
 /**
  * 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.

package/dist/host/life/life-record.d.ts

@@ -14,6 +14,9 @@ declare const LifeSchema: z.ZodObject<{
                 sleep: "sleep";
                 memory: "memory";
                 sandboxCrash: "sandboxCrash";
+                gpu: "gpu";
+                hyperv: "hyperv";
+                vanished: "vanished";
             }>;
             at: z.ZodString;
             text: z.ZodString;

package/dist/host/life/life-record.js

@@ -5,7 +5,7 @@
 import { z } from 'zod';
 import { JsonFile } from '../../shared/io/index.js';
 import { hostStateFile } from '../storage/index.js';
-import { causeSince, IsoSchema } from './stop-events.js';
+import { causeSince, IsoSchema, STOP_KINDS } from './stop-events.js';
 import { stopWarning } from './stop-warning.js';
 import { saveCrashReport } from './crash-report.js';
 const LifeSchema = z.object({
@@ -17,7 +17,7 @@ const LifeSchema = z.object({
         at: IsoSchema,
         cause: z
             .object({
-            kind: z.enum(['updates', 'restart', 'crash', 'sleep', 'memory', 'sandboxCrash']),
+            kind: z.enum(STOP_KINDS),
             at: IsoSchema,
             text: z.string().max(400),
         })

package/dist/host/life/stop-events.d.ts

@@ -6,7 +6,9 @@ export interface StopEvent {
     provider: string;
     process: string;
 }
-export type StopKind = 'updates' | 'restart' | 'crash' | 'sleep' | 'memory' | 'sandboxCrash';
+/** The ways a sandbox can end that nobody asked for (the life record stores one of these). */
+export declare const STOP_KINDS: readonly ["updates", "restart", "crash", "sleep", "memory", "sandboxCrash", "gpu", "hyperv", "vanished"];
+export type StopKind = (typeof STOP_KINDS)[number];
 export interface StopCause {
     kind: StopKind;
     at: string;