windows-development-sandbox 1.18.2 → 1.18.4

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,22 @@ 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(),
+  /** "ending": the sandbox is shutting down in order (idle shutdown, sandbox stop, Windows shutting down). */
+  phase: external_exports.enum(["ready", "working", "ending"])
+});
 var GuestResponseSchema = external_exports.object({
   id: IdSchema,
   ok: external_exports.boolean(),
@@ -27699,6 +27717,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 +27742,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 +27787,9 @@ var RunDir = class {
   readPressure() {
     return readValid(PressureStatusSchema, this.pressureFile);
   }
+  readHeartbeat() {
+    return readValid(HeartbeatSchema, this.heartbeatFile);
+  }
   readSession(id) {
     return readValid(SessionStatusSchema, this.sessionFile(id));
   }
@@ -27866,6 +27890,7 @@ var SYSTEM = {
   cmd: () => system32("cmd.exe"),
   powershell: () => system32("WindowsPowerShell\\v1.0\\powershell.exe"),
   tasklist: () => system32("tasklist.exe"),
+  taskkill: () => system32("taskkill.exe"),
   whoami: () => system32("whoami.exe"),
   icacls: () => system32("icacls.exe"),
   tar: () => system32("tar.exe"),
@@ -33038,11 +33063,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 +33355,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 +33467,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));
         }
       }
     },
@@ -33663,11 +33958,11 @@ function execCommand(req) {
 }
 
 // src/guest/daemon/sessions.ts
-import fs63 from "node:fs";
-import path80 from "node:path";
+import fs64 from "node:fs";
+import path81 from "node:path";
 import crypto5 from "node:crypto";
-import os13 from "node:os";
-import { spawn as spawn8 } from "node:child_process";
+import os15 from "node:os";
+import { spawn as spawn9 } from "node:child_process";
 
 // src/shared/pty/protocol.ts
 var FrameType = {
@@ -34249,21 +34544,318 @@ async function flushAccounts(final = false) {
   }
 }
 
-// src/guest/daemon/idle-shutdown.ts
-var GRACE_MS = 15e3;
-var IdleShutdown = class {
-  /** `busy`: a session runs or is starting. */
-  constructor(busy) {
-    this.busy = busy;
+// src/guest/daemon/heartbeat.ts
+import os14 from "node:os";
+
+// src/guest/governor/core.ts
+var STEP_TEXT = [
+  "builds back to normal",
+  "build programs at lower priority",
+  "builds get less CPU and take turns",
+  "builds take turns, waiting ones go to the paging file",
+  "one compiler at a time"
+];
+var GovernorCore = class {
+  constructor(deps) {
+    this.deps = deps;
   }
-  busy;
-  /** After a session ended or failed: shuts a headless sandbox down if it stays idle for a moment. */
-  check() {
+  deps;
+  state = INITIAL_STATE;
+  lastAction = "";
+  lastWrite = "";
+  lastWriteAt = 0;
+  /** Compilers waiting their turn now, by pid (name), to log a hold once. */
+  held = /* @__PURE__ */ new Map();
+  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;
+    const step = Math.max(level === "severe" ? 4 : 2, active ? this.state.hostStep : 0);
+    if (!active || step > this.state.hostStep)
+      this.deps.logLine(
+        "governor: this PC is " + (level === "severe" ? "nearly out of memory" : "low") + " (" + reason + "); builds to step " + 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;
+  }
+  onSample(sample) {
+    const nowMs = this.deps.now();
+    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);
+      this.apply(action);
+    }
+    for (const pid of [...this.held.keys()]) if (!holding.has(pid)) this.held.delete(pid);
+    if (d.state.step !== before)
+      this.deps.logLine(
+        "governor: step " + d.state.step + " (" + d.ramFreePercent + "% RAM free, commit " + d.commitPercent + "% used): " + STEP_TEXT[d.state.step]
+      );
+    const status = {
+      level: d.level,
+      step: d.state.step,
+      profile: this.deps.profile,
+      ramFreePercent: Math.max(0, Math.min(100, d.ramFreePercent)),
+      commitPercent: Math.max(0, Math.min(100, d.commitPercent)),
+      lowered: Object.keys(d.state.lowered).length,
+      paused: [...this.held].slice(0, 8).map(([pid, name]) => ({ name: name.slice(0, 64), pid, seconds: HOLD_MS / 1e3 })),
+      cpuPercent: d.state.cpuRate,
+      pcLow: nowMs < d.state.hostUntil,
+      lastAction: this.lastAction.slice(0, 300),
+      updatedAt: now()
+    };
+    const shape = JSON.stringify({ ...status, updatedAt: "", paused: status.paused.map((p) => p.pid) });
+    if (shape !== this.lastWrite || nowMs - this.lastWriteAt > 6e4) {
+      this.lastWrite = shape;
+      this.lastWriteAt = nowMs;
+      this.deps.saveStatus(status);
+    }
+  }
+  apply(action) {
+    const port = this.deps.port;
+    try {
+      switch (action.kind) {
+        case "hold":
+          port.hold(action.pid, action.ms);
+          if (!this.held.has(action.pid)) {
+            this.held.set(action.pid, action.name);
+            this.note(action.name + " (" + action.pid + ") waits its turn");
+          }
+          return;
+        case "priority":
+          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;
+        case "throttle":
+          port.throttle(action.pid);
+          return;
+        case "cpu":
+          port.setCpuRate(action.percent);
+          this.note(action.percent >= 100 ? "compilers: no CPU cap" : "compilers: at most " + action.percent + "% CPU");
+          return;
+        case "trim":
+          port.trim(action.pid);
+          return;
+      }
+    } catch (e) {
+      this.deps.warn("governor: " + errMsg(e));
+    }
+  }
+  note(text) {
+    this.lastAction = text;
+    this.deps.logLine("governor: " + text);
+  }
+};
+
+// src/guest/governor/governor.ts
+import fs63 from "node:fs";
+import os13 from "node:os";
+import path80 from "node:path";
+import { spawn as spawn8 } from "node:child_process";
+import { createInterface } from "node:readline";
+var SampleSchema = external_exports.object({
+  ramTotalMb: external_exports.number(),
+  ramAvailMb: external_exports.number(),
+  commitLimitMb: external_exports.number(),
+  commitAvailMb: external_exports.number(),
+  procs: external_exports.array(
+    external_exports.object({
+      pid: external_exports.number().int(),
+      name: external_exports.string().max(128),
+      mb: external_exports.number(),
+      prio: external_exports.enum(["idle", "below", "normal"]).catch("normal")
+    })
+  ).max(1024)
+});
+var MemGovProcess = class {
+  constructor(onSample) {
+    this.onSample = onSample;
+  }
+  onSample;
+  child = null;
+  start() {
+    try {
+      const child = spawn8(ensureCompiled("memgov"), ["serve", "--interval", "2"], {
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      });
+      this.child = child;
+      createInterface({ input: child.stdout }).on("line", (line) => {
+        try {
+          this.onSample(SampleSchema.parse(JSON.parse(line)));
+        } catch (e) {
+          warn("governor: bad sample: " + errMsg(e));
+        }
+      });
+      child.stdin.on("error", () => void 0);
+      child.once("exit", () => {
+        this.child = null;
+        setTimeout(() => this.start(), 3e4).unref();
+      });
+    } catch (e) {
+      warn("governor: could not start memgov.exe (no memory governor): " + errMsg(e));
+    }
+  }
+  setPriority(pid, to) {
+    this.send("priority " + pid + " " + to);
+  }
+  hold(pid, ms) {
+    this.send("suspend " + pid + " " + ms);
+  }
+  setMemoryPriority(pid, low) {
+    this.send("memprio " + pid + " " + (low ? "low" : "normal"));
+  }
+  setIoPriority(pid, to) {
+    this.send("iopriority " + pid + " " + to);
+  }
+  throttle(pid) {
+    this.send("throttle " + pid);
+  }
+  setCpuRate(percent) {
+    this.send("cpurate " + Math.round(percent));
+  }
+  trim(pid) {
+    this.send("trim " + pid);
+  }
+  send(line) {
+    this.child?.stdin?.write(line + "\n");
+  }
+};
+function appendToMemoryLog(line) {
+  try {
+    const logs = path80.join(dataDir, "logs");
+    const newest = fs63.readdirSync(logs).filter((f) => /^memory-\d{8}-\d{6}\.log$/.test(f)).sort().pop();
+    if (!newest) return;
+    const t = /* @__PURE__ */ new Date();
+    const stamp = [t.getHours(), t.getMinutes(), t.getSeconds()].map((n) => String(n).padStart(2, "0")).join(":");
+    fs63.appendFileSync(path80.join(logs, newest), stamp + " | " + line + "\r\n");
+  } catch {
+  }
+}
+var Governor = class {
+  core = null;
+  describe() {
+    const profile = session.loadProfile === "gentle" ? "gentle" : "normal";
+    const first = DIAL_STEPS[profile][0];
+    return session.pressureResponse === false ? "off (sandbox.pressureResponse)" : profile + " profile: slows builds down from " + first.availablePercent + "% free RAM or " + first.commitPercent + "% commit, in steps";
+  }
+  start() {
+    if (session.pressureResponse === false) return;
+    const profile = session.loadProfile === "gentle" ? "gentle" : "normal";
+    const proc = new MemGovProcess((s) => this.core?.onSample(s));
+    this.core = new GovernorCore({
+      port: proc,
+      profile,
+      maxCompilers: maxCompilers(os13.cpus().length, profile),
+      now: () => Date.now(),
+      logLine: appendToMemoryLog,
+      warn,
+      saveStatus: (status) => {
+        try {
+          writeJsonAtomic(run.pressureFile, status);
+        } catch (e) {
+          warn("governor: could not write its status: " + errMsg(e));
+        }
+      }
+    });
+    proc.start();
+  }
+  /** The host's watchdog: this PC is low (or nearly out of memory) for a while. */
+  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();
+
+// src/guest/daemon/heartbeat.ts
+var BEAT_MS = 1e4;
+var clamp = (n, low, high) => Math.max(low, Math.min(high, n));
+function buildHeartbeat(snapshot2, sessionCount, uptimeSeconds, freeBytes2, totalBytes, at, ending = false) {
+  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 && snapshot2?.diskQueue !== void 0 ? { diskQueueReported: snapshot2.diskQueue } : {},
+    phase: ending ? "ending" : sessionCount > 0 ? "working" : "ready"
+  };
+}
+var countSessions = () => 0;
+function writeBeat(ending) {
+  try {
+    writeJsonAtomic(
+      run.heartbeatFile,
+      buildHeartbeat(governor.snapshot(), countSessions(), os14.uptime(), os14.freemem(), os14.totalmem(), now(), ending)
+    );
+  } catch (e) {
+    warn("heartbeat: " + errMsg(e));
+  }
+}
+function markEnding() {
+  writeBeat(true);
+}
+function startHeartbeat(sessionCount) {
+  countSessions = sessionCount;
+  writeBeat(false);
+  const timer = setInterval(() => writeBeat(false), BEAT_MS);
+  timer.unref();
+  for (const signal of ["SIGHUP", "SIGBREAK", "SIGTERM"])
+    process.on(signal, () => {
+      clearInterval(timer);
+      markEnding();
+      process.exit(0);
+    });
+}
+
+// src/guest/daemon/idle-shutdown.ts
+var GRACE_MS = 15e3;
+var IdleShutdown = class {
+  /** `busy`: a session runs or is starting. */
+  constructor(busy) {
+    this.busy = busy;
+  }
+  busy;
+  /** After a session ended or failed: shuts a headless sandbox down if it stays idle for a moment. */
+  check() {
     if (!session.headless || !isWin) return;
     if (!this.idle()) return;
     setTimeout(() => {
       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);
       void flushAccounts(true).finally(() => spawnSync6(SYSTEM.shutdown(), ["/s", "/t", "5"], { windowsHide: true }));
@@ -34278,11 +34870,11 @@ var IdleShutdown = class {
 var CLOSE_WAIT_MS = 8e3;
 var ROOTS_KEPT_MS = 10 * 60 * 1e3;
 function terminalTab(id, title, cwd) {
-  const view = [process.execPath, path80.join(path80.dirname(process.argv[1]), "view.js"), id];
-  const wt = path80.join(toolsDir, "terminal", "wt.exe");
+  const view = [process.execPath, path81.join(path81.dirname(process.argv[1]), "view.js"), id];
+  const wt = path81.join(toolsDir, "terminal", "wt.exe");
   if (exists(wt))
-    spawn8(wt, ["-w", "0", "nt", "--title", title, "-d", cwd, ...view], { detached: true, stdio: "ignore" }).unref();
-  else spawn8(SYSTEM.cmd(), ["/d", "/c", "start", title, ...view], { detached: true, stdio: "ignore", cwd }).unref();
+    spawn9(wt, ["-w", "0", "nt", "--title", title, "-d", cwd, ...view], { detached: true, stdio: "ignore" }).unref();
+  else spawn9(SYSTEM.cmd(), ["/d", "/c", "start", title, ...view], { detached: true, stdio: "ignore", cwd }).unref();
 }
 var harnessFor = (req) => {
   if (req.harness === session.harnessName && session.harness) return session.harness;
@@ -34295,8 +34887,8 @@ var harnessFor = (req) => {
 function memoryEnv(env, sessions2) {
   const out = {};
   out.PTYHOST_BACKSTOP_MB = String(session.agentBackstop ?? "auto");
-  const cpus = usableCpus(os13.cpus().length, session.cpuLimitPercent ?? null);
-  const memoryGb = os13.totalmem() / 1024 ** 3;
+  const cpus = usableCpus(os15.cpus().length, session.cpuLimitPercent ?? null);
+  const memoryGb = os15.totalmem() / 1024 ** 3;
   const jobs = cargoJobs(cpus, memoryGb, sessions2);
   out.NUMBER_OF_PROCESSORS = String(cpus);
   if (!env.CARGO_BUILD_JOBS) out.CARGO_BUILD_JOBS = String(jobs);
@@ -34335,10 +34927,10 @@ var agentProgram = async (req, env, say) => {
 };
 function shellPaths() {
   const candidates = [
-    path80.join(pwshDir(), "pwsh.exe"),
-    path80.join(process.env.ProgramFiles ?? "C:\\Program Files", "PowerShell", "7", "pwsh.exe")
+    path81.join(pwshDir(), "pwsh.exe"),
+    path81.join(process.env.ProgramFiles ?? "C:\\Program Files", "PowerShell", "7", "pwsh.exe")
   ];
-  return { pwsh: candidates.find((f) => fs63.existsSync(f)) ?? null, powershell: SYSTEM.powershell(), cmd: SYSTEM.cmd() };
+  return { pwsh: candidates.find((f) => fs64.existsSync(f)) ?? null, powershell: SYSTEM.powershell(), cmd: SYSTEM.cmd() };
 }
 var shellProgram = (shell) => {
   const line = commandLine(shell.file, shell.args);
@@ -34372,7 +34964,7 @@ var launchPtyHost = async (req, program, remote, env, sessions2, onSpawn) => {
   } catch (e) {
     const tail = ptyHostLogTail(req.id);
     throw new Error(
-      errMsg(e) + (tail ? ". From its log:\n" + tail : "") + "\nLog: " + path80.join(dataDir, "logs", "ptyhost-" + req.id + ".log")
+      errMsg(e) + (tail ? ". From its log:\n" + tail : "") + "\nLog: " + path81.join(dataDir, "logs", "ptyhost-" + req.id + ".log")
     );
   }
   return { child, port, token };
@@ -34486,7 +35078,7 @@ var SessionManager = class {
     };
     this.starting++;
     if (req.id !== session.launchId && process.env.AGENT_NO_TABS !== "1")
-      safely("terminal tab", () => terminalTab(req.id, name + " " + path80.basename(req.cwd), req.cwd));
+      safely("terminal tab", () => terminalTab(req.id, name + " " + path81.basename(req.cwd), req.cwd));
     try {
       if (problem) throw new Error(problem);
       const place = await placeFor(req, say);
@@ -34654,449 +35246,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",
-  "build programs at lower priority",
-  "builds get less CPU and take turns",
-  "builds take turns, waiting ones go to the paging file",
-  "one compiler at a time"
-];
-var GovernorCore = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  deps;
-  state = INITIAL_STATE;
-  lastAction = "";
-  lastWrite = "";
-  lastWriteAt = 0;
-  /** Compilers waiting their turn now, by pid (name), to log a hold once. */
-  held = /* @__PURE__ */ new Map();
-  hostPressure(seconds, reason, level = "slow") {
-    const nowMs = this.deps.now();
-    const until = nowMs + seconds * 1e3;
-    const active = this.state.hostUntil > nowMs;
-    const step = Math.max(level === "severe" ? 4 : 2, active ? this.state.hostStep : 0);
-    if (!active || step > this.state.hostStep)
-      this.deps.logLine(
-        "governor: this PC is " + (level === "severe" ? "nearly out of memory" : "low") + " (" + reason + "); builds to step " + step
-      );
-    this.state = { ...this.state, hostUntil: Math.max(until, this.state.hostUntil), hostStep: step };
-  }
-  get current() {
-    return this.state;
-  }
-  onSample(sample) {
-    const nowMs = this.deps.now();
-    const before = this.state.step;
-    const d = decide(this.state, sample, nowMs, this.deps.profile, this.deps.maxCompilers ?? null);
-    this.state = d.state;
-    const holding = /* @__PURE__ */ new Set();
-    for (const action of d.actions) {
-      if (action.kind === "hold") holding.add(action.pid);
-      this.apply(action);
-    }
-    for (const pid of [...this.held.keys()]) if (!holding.has(pid)) this.held.delete(pid);
-    if (d.state.step !== before)
-      this.deps.logLine(
-        "governor: step " + d.state.step + " (" + d.ramFreePercent + "% RAM free, commit " + d.commitPercent + "% used): " + STEP_TEXT[d.state.step]
-      );
-    const status = {
-      level: d.level,
-      step: d.state.step,
-      profile: this.deps.profile,
-      ramFreePercent: Math.max(0, Math.min(100, d.ramFreePercent)),
-      commitPercent: Math.max(0, Math.min(100, d.commitPercent)),
-      lowered: Object.keys(d.state.lowered).length,
-      paused: [...this.held].slice(0, 8).map(([pid, name]) => ({ name: name.slice(0, 64), pid, seconds: HOLD_MS / 1e3 })),
-      cpuPercent: d.state.cpuRate,
-      pcLow: nowMs < d.state.hostUntil,
-      lastAction: this.lastAction.slice(0, 300),
-      updatedAt: now()
-    };
-    const shape = JSON.stringify({ ...status, updatedAt: "", paused: status.paused.map((p) => p.pid) });
-    if (shape !== this.lastWrite || nowMs - this.lastWriteAt > 6e4) {
-      this.lastWrite = shape;
-      this.lastWriteAt = nowMs;
-      this.deps.saveStatus(status);
-    }
-  }
-  apply(action) {
-    const port = this.deps.port;
-    try {
-      switch (action.kind) {
-        case "hold":
-          port.hold(action.pid, action.ms);
-          if (!this.held.has(action.pid)) {
-            this.held.set(action.pid, action.name);
-            this.note(action.name + " (" + action.pid + ") waits its turn");
-          }
-          return;
-        case "priority":
-          port.setPriority(action.pid, action.to);
-          this.note(action.name + " (" + action.pid + ") priority " + action.to);
-          return;
-        case "memory":
-          port.setMemoryPriority(action.pid, action.low);
-          return;
-        case "throttle":
-          port.throttle(action.pid);
-          return;
-        case "cpu":
-          port.setCpuRate(action.percent);
-          this.note(action.percent >= 100 ? "compilers: no CPU cap" : "compilers: at most " + action.percent + "% CPU");
-          return;
-        case "trim":
-          port.trim(action.pid);
-          return;
-      }
-    } catch (e) {
-      this.deps.warn("governor: " + errMsg(e));
-    }
-  }
-  note(text) {
-    this.lastAction = text;
-    this.deps.logLine("governor: " + text);
-  }
-};
-
-// src/guest/governor/governor.ts
-import fs64 from "node:fs";
-import os14 from "node:os";
-import path81 from "node:path";
-import { spawn as spawn9 } from "node:child_process";
-import { createInterface } from "node:readline";
-var SampleSchema = external_exports.object({
-  ramTotalMb: external_exports.number(),
-  ramAvailMb: external_exports.number(),
-  commitLimitMb: external_exports.number(),
-  commitAvailMb: external_exports.number(),
-  procs: external_exports.array(
-    external_exports.object({
-      pid: external_exports.number().int(),
-      name: external_exports.string().max(128),
-      mb: external_exports.number(),
-      prio: external_exports.enum(["idle", "below", "normal"]).catch("normal")
-    })
-  ).max(1024)
-});
-var MemGovProcess = class {
-  constructor(onSample) {
-    this.onSample = onSample;
-  }
-  onSample;
-  child = null;
-  start() {
-    try {
-      const child = spawn9(ensureCompiled("memgov"), ["serve", "--interval", "2"], {
-        stdio: ["pipe", "pipe", "ignore"],
-        windowsHide: true
-      });
-      this.child = child;
-      createInterface({ input: child.stdout }).on("line", (line) => {
-        try {
-          this.onSample(SampleSchema.parse(JSON.parse(line)));
-        } catch (e) {
-          warn("governor: bad sample: " + errMsg(e));
-        }
-      });
-      child.stdin.on("error", () => void 0);
-      child.once("exit", () => {
-        this.child = null;
-        setTimeout(() => this.start(), 3e4).unref();
-      });
-    } catch (e) {
-      warn("governor: could not start memgov.exe (no memory governor): " + errMsg(e));
-    }
-  }
-  setPriority(pid, to) {
-    this.send("priority " + pid + " " + to);
-  }
-  hold(pid, ms) {
-    this.send("suspend " + pid + " " + ms);
-  }
-  setMemoryPriority(pid, low) {
-    this.send("memprio " + pid + " " + (low ? "low" : "normal"));
-  }
-  throttle(pid) {
-    this.send("throttle " + pid);
-  }
-  setCpuRate(percent) {
-    this.send("cpurate " + Math.round(percent));
-  }
-  trim(pid) {
-    this.send("trim " + pid);
-  }
-  send(line) {
-    this.child?.stdin?.write(line + "\n");
-  }
-};
-function appendToMemoryLog(line) {
-  try {
-    const logs = path81.join(dataDir, "logs");
-    const newest = fs64.readdirSync(logs).filter((f) => /^memory-\d{8}-\d{6}\.log$/.test(f)).sort().pop();
-    if (!newest) return;
-    const t = /* @__PURE__ */ new Date();
-    const stamp = [t.getHours(), t.getMinutes(), t.getSeconds()].map((n) => String(n).padStart(2, "0")).join(":");
-    fs64.appendFileSync(path81.join(logs, newest), stamp + " | " + line + "\r\n");
-  } catch {
-  }
-}
-var Governor = class {
-  core = null;
-  describe() {
-    const profile = session.loadProfile === "gentle" ? "gentle" : "normal";
-    const first = DIAL_STEPS[profile][0];
-    return session.pressureResponse === false ? "off (sandbox.pressureResponse)" : profile + " profile: slows builds down from " + first.availablePercent + "% free RAM or " + first.commitPercent + "% commit, in steps";
-  }
-  start() {
-    if (session.pressureResponse === false) return;
-    const profile = session.loadProfile === "gentle" ? "gentle" : "normal";
-    const proc = new MemGovProcess((s) => this.core?.onSample(s));
-    this.core = new GovernorCore({
-      port: proc,
-      profile,
-      maxCompilers: maxCompilers(os14.cpus().length, profile),
-      now: () => Date.now(),
-      logLine: appendToMemoryLog,
-      warn,
-      saveStatus: (status) => {
-        try {
-          writeJsonAtomic(run.pressureFile, status);
-        } catch (e) {
-          warn("governor: could not write its status: " + errMsg(e));
-        }
-      }
-    });
-    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);
-  }
-};
-var governor = new Governor();
-
 // src/guest/daemon/live.ts
 import fs66 from "node:fs";
 import path83 from "node:path";
@@ -35453,7 +35602,7 @@ 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)" });
     }
@@ -35472,4 +35621,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();