windows-development-sandbox 1.18.0 → 1.18.3

package/dist/runtime/daemon.js

@@ -4517,7 +4517,7 @@ var require_lodash = __commonJS({
         function valuesIn(object2) {
           return object2 == null ? [] : baseValues(object2, keysIn(object2));
         }
-        function clamp(number4, lower, upper) {
+        function clamp2(number4, lower, upper) {
           if (upper === undefined2) {
             upper = lower;
             lower = undefined2;
@@ -5199,7 +5199,7 @@ var require_lodash = __commonJS({
         lodash.camelCase = camelCase;
         lodash.capitalize = capitalize;
         lodash.ceil = ceil;
-        lodash.clamp = clamp;
+        lodash.clamp = clamp2;
         lodash.clone = clone2;
         lodash.cloneDeep = cloneDeep;
         lodash.cloneDeepWith = cloneDeepWith;
@@ -25485,7 +25485,7 @@ var SandboxSchema = external_exports.strictObject({
     '(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: external_exports.union([external_exports.literal("auto"), external_exports.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.'
+    '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: external_exports.number().int().positive().describe('Upper limit for memoryMb "auto".'),
   maxMemoryPercent: external_exports.number().int().min(10).max(100).describe(`memoryMb "auto" never takes more than this share of this PC's total RAM (percent).`),
@@ -25647,13 +25647,13 @@ var ToolchainsSchema = external_exports.strictObject({
       '["sccache", "cargo-nextest", "cargo-deny"]'
     ),
     targetDir: external_exports.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.`
+      `"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: external_exports.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: external_exports.union([external_exports.literal("auto"), external_exports.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).'
+      '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: external_exports.strictObject({
@@ -27367,6 +27367,8 @@ var GuestRequestSchema = external_exports.discriminatedUnion("kind", [
     seconds: external_exports.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: external_exports.enum(["slow", "severe"]).optional(),
+    /** The disk queue the PC reported (shown in the heartbeat). */
+    diskQueue: external_exports.number().min(0).max(1e5).optional(),
     createdAt: TimeSchema
   })
 ]);
@@ -27389,6 +27391,21 @@ var PressureStatusSchema = external_exports.object({
   lastAction: Text(300),
   updatedAt: TimeSchema
 });
+var HeartbeatSchema = external_exports.object({
+  at: TimeSchema,
+  /** Seconds since the sandbox booted. */
+  uptimeS: external_exports.number().int().min(0).max(1e9),
+  ramFreePct: external_exports.number().min(0).max(100),
+  commitPct: external_exports.number().min(0).max(100),
+  /** The governor's dial now, and the step this PC asked for. */
+  step: external_exports.number().int().min(0).max(4),
+  hostStep: external_exports.number().int().min(0).max(4),
+  /** The biggest programs in the agents' job. */
+  topProcesses: external_exports.array(external_exports.object({ name: Text(64), privateMb: external_exports.number().int().min(0).max(1e7) })).max(5),
+  /** The disk queue this PC last reported while asking the sandbox to slow down. */
+  diskQueueReported: external_exports.number().min(0).max(1e5).optional(),
+  phase: external_exports.enum(["ready", "working"])
+});
 var GuestResponseSchema = external_exports.object({
   id: IdSchema,
   ok: external_exports.boolean(),
@@ -27699,6 +27716,8 @@ var RunDir = class {
   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;
@@ -27722,6 +27741,7 @@ var RunDir = class {
     this.sandboxFile = path7.join(this.root, "sandbox.json");
     this.vpnFile = path7.join(this.root, "vpn.json");
     this.pressureFile = path7.join(this.root, "pressure.json");
+    this.heartbeatFile = path7.join(this.root, "heartbeat.json");
     this.budgetFile = path7.join(this.root, "budget.json");
     this.requestsDir = path7.join(this.root, "requests");
     this.responsesDir = path7.join(this.root, "responses");
@@ -27766,6 +27786,9 @@ var RunDir = class {
   readPressure() {
     return readValid(PressureStatusSchema, this.pressureFile);
   }
+  readHeartbeat() {
+    return readValid(HeartbeatSchema, this.heartbeatFile);
+  }
   readSession(id) {
     return readValid(SessionStatusSchema, this.sessionFile(id));
   }
@@ -33038,11 +33061,280 @@ function cargoJobs(cpus, memoryGb, sessions2) {
   const jobs = Math.min(byCpu, byMemory);
   return Math.max(1, Math.min(jobs, Math.floor(buildJobs(cpus, memoryGb) / Math.max(1, sessions2))));
 }
+var LOCAL_TARGET_MIN_BYTES = 25 * 1024 ** 3;
+function chooseTargetDir(targetDir, freeBytes2) {
+  if (targetDir !== "auto") return { targetDir };
+  if (freeBytes2 >= 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)"
+  };
+}
 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;
+}
+
+// src/guest/governor/decide.ts
+var COMPILERS = /* @__PURE__ */ new Set([
+  "rustc",
+  "clippy-driver",
+  "rustdoc",
+  "cc1",
+  "cc1plus",
+  "cc1obj",
+  "collect2",
+  "gcc",
+  "g++",
+  "c++",
+  "cc",
+  "clang",
+  "clang++",
+  "clang-cl",
+  "cl",
+  "link",
+  "lld",
+  "lld-link",
+  "ld",
+  "ld.lld",
+  "as",
+  "tsc",
+  "javac"
+]);
+var BUILD_TOOLS = /* @__PURE__ */ new Set([
+  "dotnet",
+  "msbuild",
+  "vbcscompiler",
+  "ninja",
+  "make",
+  "mingw32-make",
+  "cmake",
+  "cargo",
+  "go",
+  "java",
+  "gradle",
+  "python"
+]);
+var NEVER2 = /* @__PURE__ */ new Set([
+  "claude",
+  "codex",
+  "gemini",
+  "opencode",
+  "aider",
+  "cursor-agent",
+  "cmd",
+  "powershell",
+  "pwsh",
+  "bash",
+  "sh",
+  "zsh",
+  "git",
+  "conhost",
+  "openconsole",
+  "windowsterminal",
+  "wt",
+  "ptyhost",
+  "memgov",
+  "sandboxtools",
+  "sbx-db",
+  "explorer",
+  "csrss",
+  "wininit",
+  "winlogon",
+  "services",
+  "svchost",
+  "lsass",
+  "system",
+  "smss",
+  "dwm"
+]);
+var key = (name) => name.toLowerCase().replace(/\.exe$/, "");
+var isNeverTouched = (name) => NEVER2.has(key(name));
+var canLower = (name) => !isNeverTouched(name) && (COMPILERS.has(key(name)) || BUILD_TOOLS.has(key(name)));
+var HEAVY = /* @__PURE__ */ new Set([
+  "rustc",
+  "clippy-driver",
+  "rustdoc",
+  "cc1",
+  "cc1plus",
+  "clang",
+  "clang++",
+  "clang-cl",
+  "cl",
+  "link",
+  "lld",
+  "lld-link",
+  "ld",
+  "ld.lld"
+]);
+var LINKERS = /* @__PURE__ */ new Set(["link", "lld", "lld-link", "ld", "ld.lld"]);
+var isLinker = (name) => !isNeverTouched(name) && LINKERS.has(key(name));
+function linkerSlots(totalMb, cpus) {
+  return Math.max(1, Math.min(4, Math.max(1, Math.floor(cpus)), Math.floor(totalMb / 6144)));
+}
+var isHeavyCompiler = (name) => !isNeverTouched(name) && HEAVY.has(key(name));
+var canPause = (name) => !isNeverTouched(name) && COMPILERS.has(key(name));
+var INITIAL_STATE = {
+  step: 0,
+  calm: 0,
+  lowered: {},
+  memLow: [],
+  throttled: [],
+  trimmed: [],
+  ioLowered: {},
+  cpuRate: 100,
+  lastCommitMb: 0,
+  lastAt: 0,
+  growth: 0,
+  hostUntil: 0,
+  hostStep: 0
+};
+var GROWTH_WEIGHT = 0.3;
+var HOLD_MS = 3e3;
+var ROTATE_MS = 2e4;
+var SOON_WITHIN_PERCENT = 12;
+function stepFor(ramFree, commit, secondsToLimit, profile) {
+  let step = 0;
+  DIAL_STEPS[profile].forEach((t, i) => {
+    const near = commit > t.commitPercent - SOON_WITHIN_PERCENT;
+    const soon = near && t.secondsToLimit !== void 0 && secondsToLimit < t.secondsToLimit;
+    if (ramFree < t.availablePercent || commit > t.commitPercent || soon) step = i + 1;
+  });
+  return step;
+}
+function clearOf(step, ramFree, commit, profile) {
+  if (step === 0) return true;
+  const t = DIAL_STEPS[profile][step - 1];
+  return ramFree > t.availablePercent + DIAL_EXIT_MARGIN.availablePercent && commit < t.commitPercent - DIAL_EXIT_MARGIN.commitPercent;
+}
+function decide(prev, sample, nowMs, profile, maxCompilers2 = null) {
+  const ramFree = sample.ramAvailMb / Math.max(1, sample.ramTotalMb) * 100;
+  const usedMb = sample.commitLimitMb - sample.commitAvailMb;
+  const commit = usedMb / Math.max(1, sample.commitLimitMb) * 100;
+  const seconds = (nowMs - prev.lastAt) / 1e3;
+  const instant = prev.lastAt > 0 && seconds > 0 ? (usedMb - prev.lastCommitMb) / seconds : 0;
+  const growth = prev.lastAt > 0 ? prev.growth * (1 - GROWTH_WEIGHT) + instant * GROWTH_WEIGHT : 0;
+  const secondsToLimit = growth > 0 ? sample.commitAvailMb / growth : Number.POSITIVE_INFINITY;
+  const pcLow = nowMs < prev.hostUntil;
+  const wanted2 = Math.max(stepFor(ramFree, commit, secondsToLimit, profile), pcLow ? prev.hostStep : 0);
+  let step = prev.step;
+  let calm = 0;
+  if (wanted2 > prev.step) step = wanted2;
+  else if (prev.step > 0 && wanted2 < prev.step && clearOf(prev.step, ramFree, commit, profile)) {
+    calm = prev.calm + 1;
+    if (calm >= DIAL_CALM_SAMPLES) {
+      step = prev.step - 1;
+      calm = 0;
+    }
+  }
+  if (profile === "gentle" && step < 2 && sample.procs.some((p) => isHeavyCompiler(p.name))) step = 2;
+  const actions = [];
+  const present2 = new Set(sample.procs.map((p) => p.pid));
+  const keep = (pids) => pids.filter((pid) => present2.has(pid));
+  const lowered = {};
+  for (const [pid, to] of Object.entries(prev.lowered)) if (present2.has(Number(pid))) lowered[Number(pid)] = to;
+  const memLow = new Set(keep(prev.memLow));
+  const throttled = new Set(keep(prev.throttled));
+  const trimmed = new Set(keep(prev.trimmed));
+  for (const p of sample.procs) {
+    if (!canLower(p.name)) continue;
+    const rest = profile === "gentle" && canPause(p.name) ? "below" : "normal";
+    const target = step >= 2 ? "idle" : step === 1 ? "below" : rest;
+    const was = lowered[p.pid];
+    const touched = was !== void 0 || target !== "normal";
+    if (touched && was !== target && p.prio !== target)
+      actions.push({ kind: "priority", pid: p.pid, name: p.name, to: target });
+    if (target === "normal") delete lowered[p.pid];
+    else lowered[p.pid] = target;
+  }
+  const ioLowered = {};
+  for (const [pid, to] of Object.entries(prev.ioLowered)) if (present2.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;
+  }
+  const lowMemory = step >= 1;
+  for (const p of sample.procs) {
+    if (!canLower(p.name) || lowMemory === memLow.has(p.pid)) continue;
+    actions.push({ kind: "memory", pid: p.pid, name: p.name, low: lowMemory });
+    if (lowMemory) memLow.add(p.pid);
+    else memLow.delete(p.pid);
+  }
+  if (step >= 2) {
+    for (const p of sample.procs)
+      if (canPause(p.name) && !throttled.has(p.pid)) {
+        actions.push({ kind: "throttle", pid: p.pid, name: p.name });
+        throttled.add(p.pid);
+      }
+  }
+  const cpuRate = DIAL_CPU_RATE[step] ?? 100;
+  if (cpuRate !== prev.cpuRate) actions.push({ kind: "cpu", percent: cpuRate });
+  const heavy = sample.procs.filter((p) => isHeavyCompiler(p.name)).sort((a, b) => a.pid - b.pid);
+  let allowed = compilersAllowed(step, heavy.length);
+  if (maxCompilers2 !== null && step >= 1) allowed = Math.min(allowed, Math.max(1, maxCompilers2));
+  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));
+  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) if (!waitingPids.has(p.pid)) trimmed.delete(p.pid);
+  } else trimmed.clear();
+  const level = step >= 3 ? "suspending" : step >= 1 ? "throttled" : "ok";
+  return {
+    state: {
+      step,
+      calm,
+      lowered,
+      memLow: [...memLow],
+      throttled: [...throttled],
+      trimmed: [...trimmed],
+      ioLowered,
+      cpuRate,
+      lastCommitMb: usedMb,
+      lastAt: nowMs,
+      growth,
+      hostUntil: prev.hostUntil,
+      hostStep: prev.hostStep
+    },
+    actions,
+    level,
+    ramFreePercent: Math.round(ramFree),
+    commitPercent: Math.round(commit)
+  };
 }
 
 // src/guest/toolchains/native/rust-extras.ts
+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 };
+}
+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)";
+}
 var cargoTarget = (targetDir) => {
   if (targetDir === "shared" || targetDir === "separate") return null;
   if (targetDir === "local") return path70.join(localDir, "cargo-target");
@@ -33061,8 +33353,7 @@ function linkGate(env, rust, host) {
   if (!host.endsWith("-pc-windows-gnu") || !exists(gcc)) return;
   const gate = path70.join(mkdirp(tool("shims")), "linkgate.exe");
   fs56.copyFileSync(ensureCompiled("linkgate"), gate);
-  const memoryGb = os10.totalmem() / 1024 ** 3;
-  const slots = rust.linkSlots === "auto" ? linkSlotsFor(memoryGb) : rust.linkSlots;
+  const slots = rust.linkSlots === "auto" ? linkerSlots(os10.totalmem() / 1024 ** 2, os10.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;
@@ -33174,11 +33465,13 @@ function plan(config2, versions, o) {
       after: ["C/C++", "MSVC", "Visual Studio", "Unreal"],
       install: async (env) => {
         await setupRust(env, { ...config2.rust, host: rustHost(config2) }, o.refresh);
-        Object.assign(env.vars, rustCaches(config2.rust));
+        const rust = resolveTargetDir(config2.rust);
+        Object.assign(env.vars, rustCaches(rust));
+        env.summary.push(targetSummary(rust));
         if (!dryRun) {
           cargoDefaults(rustHost(config2));
-          cargoShim(env, config2.rust);
-          linkGate(env, config2.rust, rustHost(config2));
+          cargoShim(env, rust);
+          linkGate(env, rust, rustHost(config2));
         }
       }
     },
@@ -34654,225 +34947,6 @@ var SessionManager = class {
 };
 var sessions = new SessionManager();
 
-// src/guest/governor/decide.ts
-var COMPILERS = /* @__PURE__ */ new Set([
-  "rustc",
-  "clippy-driver",
-  "rustdoc",
-  "cc1",
-  "cc1plus",
-  "cc1obj",
-  "collect2",
-  "gcc",
-  "g++",
-  "c++",
-  "cc",
-  "clang",
-  "clang++",
-  "clang-cl",
-  "cl",
-  "link",
-  "lld",
-  "lld-link",
-  "ld",
-  "ld.lld",
-  "as",
-  "tsc",
-  "javac"
-]);
-var BUILD_TOOLS = /* @__PURE__ */ new Set([
-  "dotnet",
-  "msbuild",
-  "vbcscompiler",
-  "ninja",
-  "make",
-  "mingw32-make",
-  "cmake",
-  "cargo",
-  "go",
-  "java",
-  "gradle",
-  "python"
-]);
-var NEVER2 = /* @__PURE__ */ new Set([
-  "claude",
-  "codex",
-  "gemini",
-  "opencode",
-  "aider",
-  "cursor-agent",
-  "cmd",
-  "powershell",
-  "pwsh",
-  "bash",
-  "sh",
-  "zsh",
-  "git",
-  "conhost",
-  "openconsole",
-  "windowsterminal",
-  "wt",
-  "ptyhost",
-  "memgov",
-  "sandboxtools",
-  "sbx-db",
-  "explorer",
-  "csrss",
-  "wininit",
-  "winlogon",
-  "services",
-  "svchost",
-  "lsass",
-  "system",
-  "smss",
-  "dwm"
-]);
-var key = (name) => name.toLowerCase().replace(/\.exe$/, "");
-var isNeverTouched = (name) => NEVER2.has(key(name));
-var canLower = (name) => !isNeverTouched(name) && (COMPILERS.has(key(name)) || BUILD_TOOLS.has(key(name)));
-var HEAVY = /* @__PURE__ */ new Set([
-  "rustc",
-  "clippy-driver",
-  "rustdoc",
-  "cc1",
-  "cc1plus",
-  "clang",
-  "clang++",
-  "clang-cl",
-  "cl",
-  "link",
-  "lld",
-  "lld-link",
-  "ld",
-  "ld.lld"
-]);
-var isHeavyCompiler = (name) => !isNeverTouched(name) && HEAVY.has(key(name));
-var canPause = (name) => !isNeverTouched(name) && COMPILERS.has(key(name));
-var INITIAL_STATE = {
-  step: 0,
-  calm: 0,
-  lowered: {},
-  memLow: [],
-  throttled: [],
-  trimmed: [],
-  cpuRate: 100,
-  lastCommitMb: 0,
-  lastAt: 0,
-  growth: 0,
-  hostUntil: 0,
-  hostStep: 0
-};
-var GROWTH_WEIGHT = 0.3;
-var HOLD_MS = 3e3;
-var ROTATE_MS = 2e4;
-var SOON_WITHIN_PERCENT = 12;
-function stepFor(ramFree, commit, secondsToLimit, profile) {
-  let step = 0;
-  DIAL_STEPS[profile].forEach((t, i) => {
-    const near = commit > t.commitPercent - SOON_WITHIN_PERCENT;
-    const soon = near && t.secondsToLimit !== void 0 && secondsToLimit < t.secondsToLimit;
-    if (ramFree < t.availablePercent || commit > t.commitPercent || soon) step = i + 1;
-  });
-  return step;
-}
-function clearOf(step, ramFree, commit, profile) {
-  if (step === 0) return true;
-  const t = DIAL_STEPS[profile][step - 1];
-  return ramFree > t.availablePercent + DIAL_EXIT_MARGIN.availablePercent && commit < t.commitPercent - DIAL_EXIT_MARGIN.commitPercent;
-}
-function decide(prev, sample, nowMs, profile, maxCompilers2 = null) {
-  const ramFree = sample.ramAvailMb / Math.max(1, sample.ramTotalMb) * 100;
-  const usedMb = sample.commitLimitMb - sample.commitAvailMb;
-  const commit = usedMb / Math.max(1, sample.commitLimitMb) * 100;
-  const seconds = (nowMs - prev.lastAt) / 1e3;
-  const instant = prev.lastAt > 0 && seconds > 0 ? (usedMb - prev.lastCommitMb) / seconds : 0;
-  const growth = prev.lastAt > 0 ? prev.growth * (1 - GROWTH_WEIGHT) + instant * GROWTH_WEIGHT : 0;
-  const secondsToLimit = growth > 0 ? sample.commitAvailMb / growth : Number.POSITIVE_INFINITY;
-  const pcLow = nowMs < prev.hostUntil;
-  const wanted2 = Math.max(stepFor(ramFree, commit, secondsToLimit, profile), pcLow ? prev.hostStep : 0);
-  let step = prev.step;
-  let calm = 0;
-  if (wanted2 > prev.step) step = wanted2;
-  else if (prev.step > 0 && wanted2 < prev.step && clearOf(prev.step, ramFree, commit, profile)) {
-    calm = prev.calm + 1;
-    if (calm >= DIAL_CALM_SAMPLES) {
-      step = prev.step - 1;
-      calm = 0;
-    }
-  }
-  const actions = [];
-  const present2 = new Set(sample.procs.map((p) => p.pid));
-  const keep = (pids) => pids.filter((pid) => present2.has(pid));
-  const lowered = {};
-  for (const [pid, to] of Object.entries(prev.lowered)) if (present2.has(Number(pid))) lowered[Number(pid)] = to;
-  const memLow = new Set(keep(prev.memLow));
-  const throttled = new Set(keep(prev.throttled));
-  const trimmed = new Set(keep(prev.trimmed));
-  for (const p of sample.procs) {
-    if (!canLower(p.name)) continue;
-    const rest = profile === "gentle" && canPause(p.name) ? "below" : "normal";
-    const target = step >= 2 ? "idle" : step === 1 ? "below" : rest;
-    const was = lowered[p.pid];
-    const touched = was !== void 0 || target !== "normal";
-    if (touched && was !== target && p.prio !== target)
-      actions.push({ kind: "priority", pid: p.pid, name: p.name, to: target });
-    if (target === "normal") delete lowered[p.pid];
-    else lowered[p.pid] = target;
-  }
-  const lowMemory = step >= 1;
-  for (const p of sample.procs) {
-    if (!canLower(p.name) || lowMemory === memLow.has(p.pid)) continue;
-    actions.push({ kind: "memory", pid: p.pid, name: p.name, low: lowMemory });
-    if (lowMemory) memLow.add(p.pid);
-    else memLow.delete(p.pid);
-  }
-  if (step >= 2) {
-    for (const p of sample.procs)
-      if (canPause(p.name) && !throttled.has(p.pid)) {
-        actions.push({ kind: "throttle", pid: p.pid, name: p.name });
-        throttled.add(p.pid);
-      }
-  }
-  const cpuRate = DIAL_CPU_RATE[step] ?? 100;
-  if (cpuRate !== prev.cpuRate) actions.push({ kind: "cpu", percent: cpuRate });
-  const heavy = sample.procs.filter((p) => isHeavyCompiler(p.name)).sort((a, b) => a.pid - b.pid);
-  let allowed = compilersAllowed(step, heavy.length);
-  if (maxCompilers2 !== null && step >= 2) allowed = Math.min(allowed, Math.max(1, maxCompilers2));
-  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)) {
-      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);
-  } else trimmed.clear();
-  const level = step >= 3 ? "suspending" : step >= 1 ? "throttled" : "ok";
-  return {
-    state: {
-      step,
-      calm,
-      lowered,
-      memLow: [...memLow],
-      throttled: [...throttled],
-      trimmed: [...trimmed],
-      cpuRate,
-      lastCommitMb: usedMb,
-      lastAt: nowMs,
-      growth,
-      hostUntil: prev.hostUntil,
-      hostStep: prev.hostStep
-    },
-    actions,
-    level,
-    ramFreePercent: Math.round(ramFree),
-    commitPercent: Math.round(commit)
-  };
-}
-
 // src/guest/governor/core.ts
 var STEP_TEXT = [
   "builds back to normal",
@@ -34892,7 +34966,10 @@ var GovernorCore = class {
   lastWriteAt = 0;
   /** Compilers waiting their turn now, by pid (name), to log a hold once. */
   held = /* @__PURE__ */ new Map();
-  hostPressure(seconds, reason, level = "slow") {
+  latest = null;
+  diskQueue = null;
+  hostPressure(seconds, reason, level = "slow", diskQueue) {
+    if (diskQueue !== void 0) this.diskQueue = diskQueue;
     const nowMs = this.deps.now();
     const until = nowMs + seconds * 1e3;
     const active = this.state.hostUntil > nowMs;
@@ -34903,6 +34980,10 @@ var GovernorCore = class {
       );
     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;
   }
@@ -34911,6 +34992,14 @@ var GovernorCore = class {
     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 = /* @__PURE__ */ new Set();
     for (const action of d.actions) {
       if (action.kind === "hold") holding.add(action.pid);
@@ -34956,6 +35045,9 @@ var GovernorCore = class {
           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;
@@ -35038,6 +35130,9 @@ var MemGovProcess = class {
   setMemoryPriority(pid, low) {
     this.send("memprio " + pid + " " + (low ? "low" : "normal"));
   }
+  setIoPriority(pid, to) {
+    this.send("iopriority " + pid + " " + to);
+  }
   throttle(pid) {
     this.send("throttle " + pid);
   }
@@ -35091,8 +35186,12 @@ var Governor = class {
     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;
   }
 };
 var governor = new Governor();
@@ -35453,13 +35552,46 @@ var Daemon = class {
       case "close":
         return sessions.close(req);
       case "pressure":
-        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)" });
     }
   }
 };
 
+// src/guest/daemon/heartbeat.ts
+import os15 from "node:os";
+var BEAT_MS = 1e4;
+var clamp = (n, low, high) => Math.max(low, Math.min(high, n));
+function buildHeartbeat(snapshot2, sessionCount, uptimeSeconds, freeBytes2, totalBytes, at) {
+  const ramFree = snapshot2?.ramFreePercent ?? Math.round(freeBytes2 / Math.max(1, totalBytes) * 100);
+  return {
+    at,
+    uptimeS: Math.max(0, Math.round(uptimeSeconds)),
+    ramFreePct: clamp(ramFree, 0, 100),
+    commitPct: clamp(snapshot2?.commitPercent ?? 0, 0, 100),
+    step: clamp(snapshot2?.step ?? 0, 0, 4),
+    hostStep: clamp(snapshot2?.hostStep ?? 0, 0, 4),
+    topProcesses: (snapshot2?.top ?? []).slice(0, 5).map((p) => ({ name: p.name.slice(0, 64), privateMb: p.mb })),
+    ...snapshot2?.diskQueue != null ? { diskQueueReported: snapshot2.diskQueue } : {},
+    phase: sessionCount > 0 ? "working" : "ready"
+  };
+}
+function startHeartbeat() {
+  const beat = () => {
+    try {
+      writeJsonAtomic(
+        run.heartbeatFile,
+        buildHeartbeat(governor.snapshot(), sessions.count, os15.uptime(), os15.freemem(), os15.totalmem(), now())
+      );
+    } catch (e) {
+      warn("heartbeat: " + errMsg(e));
+    }
+  };
+  beat();
+  setInterval(beat, BEAT_MS).unref();
+}
+
 // src/guest/entries/daemon.ts
 process.on("uncaughtException", (e) => warn("daemon: unexpected error (continuing): " + (e.stack ?? errMsg(e))));
 process.on("unhandledRejection", (e) => warn("daemon: unexpected error (continuing): " + errMsg(e)));
@@ -35472,4 +35604,5 @@ safely("leftover processes", () => sessions.sweepLeftovers());
 safely("memory governor", () => governor.start());
 log("Memory governor: " + governor.describe());
 safely("service sign-ins", startAccountWatch);
+safely("heartbeat", startHeartbeat);
 new Daemon().start();