windows-development-sandbox 1.18.2 → 1.18.4

package/dist/bin/{chunk-M4OM632I.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-MQIA7GNB.js";
+} from "./chunk-FRPLQLSY.js";
 export {
   attach
 };

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

@@ -228,7 +228,7 @@ import {
   withOperationCommands,
   working,
   writeJson
-} from "./chunk-MQIA7GNB.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-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.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-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.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-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.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-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.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-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.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-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.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-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.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.d.ts

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

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

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

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

package/dist/core/schema/sandbox.js

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

package/dist/core/schema/toolchains.js

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

package/dist/guest/daemon/daemon.js

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

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

@@ -0,0 +1,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, 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(sessionCount: () => number): void;

package/dist/guest/daemon/heartbeat.js

@@ -0,0 +1,59 @@
+// The heartbeat: every 10 seconds the daemon writes run\heartbeat.json (memory, the governor's dial, the biggest
+// programs). When the whole sandbox vanishes, the host reads the last one to say what it was doing.
+import os from 'node:os';
+import { writeJsonAtomic } from '../../shared/io/json.js';
+import { now } from '../../shared/channel/run-dir.js';
+import { governor } from '../governor/index.js';
+import { run } from '../runtime/paths.js';
+import { warn } from '../runtime/log.js';
+import { errMsg } from '../../core/util/errors.js';
+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, ending = false) {
+    const ramFree = snapshot?.ramFreePercent ?? Math.round((freeBytes / Math.max(1, totalBytes)) * 100);
+    return {
+        at,
+        uptimeS: Math.max(0, Math.round(uptimeSeconds)),
+        ramFreePct: clamp(ramFree, 0, 100),
+        commitPct: clamp(snapshot?.commitPercent ?? 0, 0, 100),
+        step: clamp(snapshot?.step ?? 0, 0, 4),
+        hostStep: clamp(snapshot?.hostStep ?? 0, 0, 4),
+        topProcesses: (snapshot?.top ?? []).slice(0, 5).map((p) => ({ name: p.name.slice(0, 64), privateMb: p.mb })),
+        ...(snapshot?.diskQueue !== null && 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(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

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

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

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

package/dist/guest/governor/core.js

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

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

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