windows-development-sandbox 1.10.0 → 1.11.3

package/dist/runtime/daemon.js

@@ -25437,6 +25437,9 @@ var AttachSchema = external_exports.strictObject({
   ),
   autoHide: external_exports.boolean().describe(
     "Hide the Windows Sandbox window whenever this terminal attaches; it keeps running (sandbox show brings it back)."
+  ),
+  confirmCtrlC: external_exports.boolean().describe(
+    'In an attached terminal and the sandbox window, a single Ctrl+C is held back (the title says so) and only a second one within 1.5 seconds reaches the agent: a Ctrl+C meant as "copy" no longer stops it. Esc still stops an agent.'
   )
 });
 var AgentCommandsSchema = external_exports.strictObject({
@@ -25481,7 +25484,9 @@ var SandboxSchema = external_exports.strictObject({
   engine: external_exports.enum(["windows-sandbox", "hcs"]).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: 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.'),
+  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.'
+  ),
   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).`),
   cpuLimit: external_exports.union([external_exports.literal("none"), external_exports.number().int().min(5).max(100)]).describe(
@@ -25494,10 +25499,10 @@ var SandboxSchema = external_exports.strictObject({
     'Memory always left for this PC when memoryMb is "auto": the sandbox gets at most (free RAM, and RAM plus paging file still unused) minus this.'
   ),
   agentMemoryHeadroomMb: external_exports.union([external_exports.literal("auto"), external_exports.literal("none"), external_exports.number().int().min(0)]).describe(
-    'Memory kept out of the agents reach inside the sandbox, in MB: everything the agents start (their builds, tests, tools) together may use at most the sandbox memory minus this; a runaway parallel build then gets out-of-memory errors in its own session instead of freezing or crashing the whole sandbox. "auto" = the larger of 2048 MB and 10 % of the sandbox memory; "none" = no limit. Yours only: a project file cannot change it.'
+    'The last resort that keeps the sandbox up, in MB below its commit limit (RAM plus paging file): builds are slowed down long before (sandbox.pressureResponse); only if everything the agents start together would take the sandbox to the very edge of its memory, where Windows inside it would start failing, is a build refused memory instead of Windows. "auto" = the larger of 1536 MB and 3 % of the commit limit; "none" = no backstop. Yours only: a project file cannot change it.'
   ),
   pressureResponse: external_exports.boolean().describe(
-    "When the sandbox (or this PC) runs low on memory, slow the heaviest build programs down (lower priority) and, if that is not enough, pause the biggest compiler for a few seconds at a time, so heavy parallel builds slow down instead of closing the sandbox. Never touches the agents themselves. Yours only: a project file cannot change it."
+    "When the sandbox (or this PC) runs low on memory, slow builds down in steps, like a PC that gets slower instead of failing: build programs get lower CPU and memory priority, then less CPU, then compilers take turns (the waiting ones briefly suspended and trimmed to the paging file). Nothing is stopped or killed, and the agents themselves are never touched. Yours only: a project file cannot change it."
   ),
   vGpu: external_exports.boolean().describe(
     "Virtual GPU. Off by default: Microsoft notes it widens the sandbox attack surface. The sandbox then uses this PC's graphics card, and with some graphics drivers heavy use can freeze the whole PC: turn it on only when a program in the sandbox needs the GPU (the mesa toolchain gives software OpenGL without it)."
@@ -25643,7 +25648,7 @@ var ToolchainsSchema = external_exports.strictObject({
       `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 8 GB of sandbox memory, 2 to 4. Several agents linking big programs at once can take Windows down.'
+      '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).'
     )
   }),
   msvc: external_exports.strictObject({
@@ -25718,7 +25723,7 @@ var ToolchainsSchema = external_exports.strictObject({
   }),
   cli: external_exports.strictObject({
     gh: EnabledSchema.describe(
-      'GitHub CLI (gh). Only with provisioning.git.access "full": gh can push and merge through the GitHub API, past a read-only git. Your PC\'s gh login is never copied; `gh auth login` inside persists (GH_CONFIG_DIR). "auto" = when the project has a .github folder.'
+      'GitHub CLI (gh). Only with provisioning.git.access "full": gh can push and merge through the GitHub API, past a read-only git. Your PC\'s gh login is never copied; `gh auth login` inside persists (GH_CONFIG_DIR), unless a token you saved for sandboxes is handed over (github.shareToken). "auto" = when the project has a .github folder.'
     ),
     zstd: EnabledSchema.describe('Zstandard (zstd). "auto" = off; set true to get it.'),
     openssl: EnabledSchema.describe(
@@ -26646,6 +26651,13 @@ var VpnSchema = external_exports.strictObject({
   )
 });
 
+// src/core/schema/github.ts
+var GithubSchema = external_exports.strictObject({
+  shareToken: external_exports.boolean().describe(
+    'Give each sandbox the GitHub token you saved with `sandbox github login` (best a fine-grained token limited to some repositories and permissions), so gh and https git work there without logging in. Only with provisioning.git.access "full". The agent in the sandbox can read the token and use it for whatever it allows. A project file (.sandbox-config.json) cannot turn this on.'
+  )
+});
+
 // src/core/schema/config.ts
 var ConfigSchema = external_exports.strictObject({
   $schema: SchemaRefSchema.optional(),
@@ -26676,6 +26688,7 @@ var ConfigSchema = external_exports.strictObject({
   }),
   network: NetworkSchema,
   vpn: VpnSchema,
+  github: GithubSchema,
   provisioning: ProvisioningSchema,
   downloads: DownloadsSchema,
   toolchains: ToolchainsSchema,
@@ -26838,19 +26851,25 @@ var GuestRequestSchema = external_exports.discriminatedUnion("kind", [
     id: IdSchema,
     reason: Text(300),
     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(),
     createdAt: TimeSchema
   })
 ]);
 var PressureStatusSchema = external_exports.object({
   level: external_exports.enum(["ok", "throttled", "suspending"]),
+  /** The governor's dial, 0 (nothing wrong) to 4 (one compiler at a time). */
+  step: external_exports.number().int().min(0).max(4).optional(),
   profile: external_exports.enum(["normal", "gentle"]),
   /** Share of the sandbox's RAM still free and of its commit limit in use (percent). */
   ramFreePercent: external_exports.number().int().min(0).max(100),
   commitPercent: external_exports.number().int().min(0).max(100),
   /** Programs running at lower priority because of it. */
   lowered: external_exports.number().int().min(0).max(1024),
-  /** Programs paused right now (name, process id, seconds left). */
+  /** Compilers waiting their turn right now (name, process id, seconds until they may go on). */
   paused: external_exports.array(external_exports.object({ name: Text(64), pid: external_exports.number().int(), seconds: external_exports.number().int().min(0).max(60) })).max(8),
+  /** The CPU share the compilers get together (percent; 100 = no cap). */
+  cpuPercent: external_exports.number().int().min(0).max(100).optional(),
   /** The PC itself asked for slowing down (its memory or CPU is low). */
   pcLow: external_exports.boolean(),
   lastAction: Text(300),
@@ -26894,6 +26913,8 @@ var VpnStatusSchema = external_exports.object({
   state: external_exports.enum(["off", "starting", "up", "failed"]),
   message: Text(2e3),
   killSwitch: external_exports.boolean(),
+  /** A direct connection was tried after the kill switch was applied: false = it still got out. */
+  killSwitchHeld: external_exports.boolean().optional(),
   /** The server's name, e.g. uk2201.nordvpn.com. */
   server: Text(128).optional(),
   /** What the sandbox's traffic looks like from outside, once the tunnel is up. */
@@ -27119,6 +27140,8 @@ var RunDir = class {
   vpnFile;
   /** What the memory governor in the sandbox is doing (pressure.json). */
   pressureFile;
+  /** What the sandbox's programs may really use (budget.json): processors, memory, build jobs, link slots. */
+  budgetFile;
   requestsDir;
   responsesDir;
   sessionsDir;
@@ -27132,6 +27155,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.budgetFile = path7.join(this.root, "budget.json");
     this.requestsDir = path7.join(this.root, "requests");
     this.responsesDir = path7.join(this.root, "responses");
     this.sessionsDir = path7.join(this.root, "sessions");
@@ -27685,6 +27709,12 @@ function safely(what, work) {
 // src/guest/runtime/secrets.ts
 import fs13 from "node:fs";
 
+// src/shared/github/token.ts
+var MIN_LENGTH = 20;
+var MAX_LENGTH = 255;
+var PRINTABLE = /^[\x21-\x7e]+$/;
+var GithubTokenSchema = external_exports.string().min(MIN_LENGTH).max(MAX_LENGTH).regex(PRINTABLE);
+
 // src/shared/channel/secrets.ts
 var Environment = external_exports.record(external_exports.string().max(256), external_exports.string().max(65536));
 var SecretsFileSchema = external_exports.strictObject({
@@ -27699,7 +27729,9 @@ var SecretsFileSchema = external_exports.strictObject({
   /** VPN service credentials (vpn.provider's login), only for the launch's own sandbox. */
   vpn: external_exports.strictObject({ username: external_exports.string().min(1).max(256), password: external_exports.string().min(1).max(1024) }).optional(),
   /** The checked WireGuard config of vpn.provider wireguard-file (holds the private key). */
-  wireguardConfig: external_exports.string().min(1).max(32 * 1024).optional()
+  wireguardConfig: external_exports.string().min(1).max(32 * 1024).optional(),
+  /** The GitHub token you saved for sandboxes (github.shareToken), only with git access "full". */
+  githubToken: GithubTokenSchema.optional()
 });
 var withEnvironment = (harness, environment) => environment ? { ...harness, environment: { ...harness.environment, ...environment } } : harness;
 function mergeRequestSecrets(request, secrets) {
@@ -29943,9 +29975,12 @@ async function setupUv(env) {
 function ghConfigDir() {
   return path45.join(stateDir, "gh");
 }
+function deliveredGhConfigDir() {
+  return path45.join(localDir, "gh-token");
+}
 var toolVars = {
   gh: () => ({
-    GH_CONFIG_DIR: mkdirp(ghConfigDir()),
+    GH_CONFIG_DIR: exists(deliveredGhConfigDir()) ? deliveredGhConfigDir() : mkdirp(ghConfigDir()),
     GH_NO_UPDATE_NOTIFIER: "1",
     GH_NO_EXTENSION_UPDATE_NOTIFIER: "1"
   })
@@ -30791,6 +30826,10 @@ var activate = async (version2) => {
   fs43.rmSync(NVM_SYMLINK, { recursive: true, force: true });
   fs43.symlinkSync(path56.join(NVM_HOME, "v" + version2), NVM_SYMLINK, "junction");
 };
+var PLAYWRIGHT_VARS = () => ({
+  PLAYWRIGHT_BROWSERS_PATH: tool("ms-playwright"),
+  PLAYWRIGHT_MCP_BROWSER: "msedge"
+});
 async function setupNode(env, versions, config2) {
   if (dryRun) {
     log("(dry run) would provision nvm and Node " + versions.node.spec + " (from " + versions.node.source + ")");
@@ -30824,13 +30863,14 @@ async function setupNode(env, versions, config2) {
       warn("Node " + version2 + " from this PC: " + errMsg(e));
     }
   }
-  Object.assign(env.vars, { NVM_HOME, NVM_SYMLINK });
+  Object.assign(env.vars, { NVM_HOME, NVM_SYMLINK, ...PLAYWRIGHT_VARS() });
   if (duringSession()) env.prepend.push(path56.join(NVM_HOME, "v" + main), NVM_HOME, NVM_SYMLINK);
   else {
     await activate(main);
     env.prepend.push(NVM_HOME, NVM_SYMLINK);
   }
   env.summary.push("node: " + main + " (from " + versions.node.source + ", switch with nvm use)");
+  env.summary.push("playwright: ready (Edge; browsers it downloads are kept; in tests use channel: 'msedge')");
   await packageManagers(env, config2, main);
 }
 var packageManagers = async (env, config2, version2) => {
@@ -31377,27 +31417,44 @@ import os8 from "node:os";
 import path62 from "node:path";
 
 // src/shared/memory/policy.ts
-var GUEST_THRESHOLDS = {
-  normal: {
-    enterAvailablePercent: 8,
-    enterCommitPercent: 92,
-    exitAvailablePercent: 12,
-    exitCommitPercent: 88,
-    calmSamples: 3
-  },
-  gentle: {
-    enterAvailablePercent: 15,
-    enterCommitPercent: 85,
-    exitAvailablePercent: 20,
-    exitCommitPercent: 80,
-    calmSamples: 3
-  }
+var DIAL_STEPS = {
+  normal: [
+    { availablePercent: 15, commitPercent: 80 },
+    { availablePercent: 10, commitPercent: 88 },
+    { availablePercent: 6, commitPercent: 94, secondsToLimit: 20 },
+    { availablePercent: 4, commitPercent: 97, secondsToLimit: 8 }
+  ],
+  gentle: [
+    { availablePercent: 20, commitPercent: 75 },
+    { availablePercent: 15, commitPercent: 85 },
+    { availablePercent: 8, commitPercent: 92, secondsToLimit: 25 },
+    { availablePercent: 5, commitPercent: 96, secondsToLimit: 10 }
+  ]
 };
+var DIAL_EXIT_MARGIN = { availablePercent: 5, commitPercent: 4 };
+var DIAL_CALM_SAMPLES = 3;
+var DIAL_CPU_RATE = [100, 100, 60, 35, 15];
+function compilersAllowed(step, running) {
+  if (step <= 1 || running <= 1) return running;
+  if (step === 2) return Math.max(1, Math.ceil(running * 0.6));
+  if (step === 3) return Math.max(1, Math.ceil(running / 3));
+  return 1;
+}
+function buildJobs(cpus, memoryGb) {
+  return Math.max(2, Math.min(cpus, Math.floor((memoryGb - 6) / 3)));
+}
+function linkSlotsFor(memoryGb) {
+  return Math.max(2, Math.min(8, Math.floor((memoryGb - 6) / 3)));
+}
+function usableCpus(cpus, percent) {
+  if (percent === null || percent >= 100) return cpus;
+  return Math.max(2, Math.min(cpus, Math.floor(cpus * percent / 100)));
+}
 function cargoJobs(cpus, memoryGb, sessions2) {
-  const byCpu = Math.max(2, Math.min(4, Math.floor(cpus / 4)));
+  const byCpu = Math.max(2, Math.min(8, Math.floor(cpus / 4)));
   const byMemory = Math.max(1, Math.floor(memoryGb / 4));
   const jobs = Math.min(byCpu, byMemory);
-  return Math.max(1, Math.min(jobs, Math.floor(8 / Math.max(1, sessions2))));
+  return Math.max(1, Math.min(jobs, Math.floor(buildJobs(cpus, memoryGb) / Math.max(1, sessions2))));
 }
 function maxCompilers(cpus, profile) {
   return profile === "gentle" ? Math.max(2, Math.floor(cpus / 4)) : null;
@@ -31423,7 +31480,7 @@ function linkGate(env, rust, host) {
   const gate = path62.join(mkdirp(tool("shims")), "linkgate.exe");
   fs48.copyFileSync(ensureCompiled("linkgate"), gate);
   const memoryGb = os8.totalmem() / 1024 ** 3;
-  const slots = rust.linkSlots === "auto" ? Math.max(2, Math.min(4, Math.floor(memoryGb / 8))) : rust.linkSlots;
+  const slots = rust.linkSlots === "auto" ? linkSlotsFor(memoryGb) : 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;
@@ -32275,11 +32332,33 @@ var harnessFor = (req) => {
 };
 function memoryEnv(env, sessions2) {
   const out = {};
-  if (session.agentMemoryLimitMb) out.PTYHOST_JOB_MB = String(session.agentMemoryLimitMb);
-  if (!env.CARGO_BUILD_JOBS)
-    out.CARGO_BUILD_JOBS = String(cargoJobs(os11.cpus().length, os11.totalmem() / 1024 ** 3, sessions2));
+  out.PTYHOST_BACKSTOP_MB = String(session.agentBackstop ?? "auto");
+  const cpus = usableCpus(os11.cpus().length, session.cpuLimitPercent ?? null);
+  const memoryGb = os11.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);
+  if (!env.CMAKE_BUILD_PARALLEL_LEVEL) out.CMAKE_BUILD_PARALLEL_LEVEL = String(jobs);
+  out.SANDBOX_BUDGET_FILE = run.budgetFile;
+  writeBudget(cpus, memoryGb, jobs, env);
   return out;
 }
+function writeBudget(cpus, memoryGb, jobs, env) {
+  try {
+    writeJsonAtomic(run.budgetFile, {
+      processors: cpus,
+      memoryMb: Math.round(memoryGb * 1024),
+      buildJobs: buildJobs(cpus, memoryGb),
+      cargoJobsPerSession: jobs,
+      linkSlots: Number(env.AGENT_LINK_SLOTS) || linkSlotsFor(memoryGb),
+      cpuLimitPercent: session.cpuLimitPercent ?? null,
+      governor: run.pressureFile,
+      note: "Plan builds with these numbers. When memory runs short the sandbox slows builds down in steps (governor); nothing fails."
+    });
+  } catch (e) {
+    warn("budget.json could not be written: " + errMsg(e));
+  }
+}
 var launchPtyHost = async (req, remote, env, say, sessions2) => {
   const harness = harnessFor(req);
   say("Preparing " + req.harness);
@@ -32504,7 +32583,6 @@ var COMPILERS = /* @__PURE__ */ new Set([
   "javac"
 ]);
 var BUILD_TOOLS = /* @__PURE__ */ new Set([
-  "node",
   "dotnet",
   "msbuild",
   "vbcscompiler",
@@ -32573,88 +32651,123 @@ var HEAVY = /* @__PURE__ */ new Set([
 var isHeavyCompiler = (name) => !isNeverTouched(name) && HEAVY.has(key(name));
 var canPause = (name) => !isNeverTouched(name) && COMPILERS.has(key(name));
 var INITIAL_STATE = {
-  pressure: false,
+  step: 0,
   calm: 0,
-  samples: 0,
   lowered: {},
-  pausedUntil: 0,
-  nextPauseAt: 0,
-  hostUntil: 0
+  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 PAUSE_MS = 5e3;
-var PAUSE_COOLDOWN_MS = 1e4;
-var IDLE_AFTER = 3;
-var PAUSE_AFTER = 4;
-var PAUSE_MIN_MB = 300;
-function decide(prev, sample, nowMs, thresholds, profile, maxCompilers2 = null) {
+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 commit = (sample.commitLimitMb - sample.commitAvailMb) / Math.max(1, sample.commitLimitMb) * 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 low = ramFree < thresholds.enterAvailablePercent || commit > thresholds.enterCommitPercent || pcLow;
-  const recovered = ramFree > thresholds.exitAvailablePercent && commit < thresholds.exitCommitPercent && !pcLow;
-  let pressure = prev.pressure;
-  let calm = prev.calm;
-  let samples = prev.samples;
-  if (low) {
-    pressure = true;
-    calm = 0;
-    samples = prev.samples + 1;
-  } else if (prev.pressure) {
-    calm = recovered ? prev.calm + 1 : 0;
-    if (calm >= thresholds.calmSamples) {
-      pressure = false;
+  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;
-      samples = 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;
-  if (pressure) {
-    const target = samples > IDLE_AFTER ? "idle" : "below";
-    for (const p of sample.procs) {
-      if (!canLower(p.name) || lowered[p.pid] === target) continue;
-      if (p.prio !== target && !(target === "below" && p.prio === "idle"))
-        actions.push({ kind: "priority", pid: p.pid, name: p.name, to: target });
-      lowered[p.pid] = target;
-    }
-  } else {
-    for (const p of sample.procs) {
-      if (!canLower(p.name)) continue;
-      const base = profile === "gentle" && canPause(p.name) ? "below" : "normal";
-      const was = lowered[p.pid];
-      if (prev.pressure && was !== void 0 && was !== base) {
-        if (p.prio !== base) actions.push({ kind: "priority", pid: p.pid, name: p.name, to: base });
-        if (base === "normal") delete lowered[p.pid];
-        else lowered[p.pid] = base;
-      } else if (!prev.pressure && base === "below" && was === void 0) {
-        if (p.prio === "normal") actions.push({ kind: "priority", pid: p.pid, name: p.name, to: "below" });
-        lowered[p.pid] = "below";
-      }
-    }
-  }
-  let pausedUntil = prev.pausedUntil;
-  let nextPauseAt = prev.nextPauseAt;
-  if (pressure && samples >= PAUSE_AFTER && nowMs >= prev.nextPauseAt && nowMs >= prev.pausedUntil) {
-    const victim = [...sample.procs].filter((p) => canPause(p.name) && p.mb >= PAUSE_MIN_MB).sort((a, b) => b.mb - a.mb)[0];
-    if (victim) {
-      actions.push({ kind: "pause", pid: victim.pid, name: victim.name, ms: PAUSE_MS });
-      pausedUntil = nowMs + PAUSE_MS;
-      nextPauseAt = pausedUntil + PAUSE_COOLDOWN_MS;
-    }
-  }
-  if (maxCompilers2 !== null) {
-    const heavy = sample.procs.filter(
-      (p) => isHeavyCompiler(p.name) && !(nowMs < pausedUntil && actions.some((a) => a.kind === "pause" && a.pid === p.pid))
-    ).sort((a, b) => a.pid - b.pid);
-    for (const p of heavy.slice(Math.max(1, maxCompilers2)))
+  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 });
-  }
-  const level = nowMs < pausedUntil ? "suspending" : pressure ? "throttled" : "ok";
+      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: { pressure, calm, samples, lowered, pausedUntil, nextPauseAt, hostUntil: prev.hostUntil },
+    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),
@@ -32662,26 +32775,14 @@ function decide(prev, sample, nowMs, thresholds, profile, maxCompilers2 = null)
   };
 }
 
-// src/guest/governor/governor.ts
-import fs53 from "node:fs";
-import os12 from "node:os";
-import path69 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)
-});
+// 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;
@@ -32691,52 +32792,51 @@ var GovernorCore = class {
   lastAction = "";
   lastWrite = "";
   lastWriteAt = 0;
-  pausedName = "";
-  pausedPid = 0;
-  held = /* @__PURE__ */ new Set();
-  hostPressure(seconds, reason) {
-    const until = this.deps.now() + seconds * 1e3;
-    if (until > this.state.hostUntil) {
-      if (this.state.hostUntil <= this.deps.now())
-        this.deps.logLine("governor: this PC is low (" + reason + "); slowing builds down");
-      this.state = { ...this.state, hostUntil: until };
-    }
+  /** 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.pressure;
-    const seen = new Set(sample.procs.map((p) => p.pid));
-    for (const pid of this.held) if (!seen.has(pid)) this.held.delete(pid);
-    const d = decide(
-      this.state,
-      sample,
-      nowMs,
-      GUEST_THRESHOLDS[this.deps.profile],
-      this.deps.profile,
-      this.deps.maxCompilers ?? null
-    );
+    const before = this.state.step;
+    const d = decide(this.state, sample, nowMs, this.deps.profile, this.deps.maxCompilers ?? null);
     this.state = d.state;
-    for (const action of d.actions) this.apply(action);
-    if (d.state.pressure !== before)
+    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(
-        d.state.pressure ? "governor: memory is low (" + d.ramFreePercent + "% RAM free, commit " + d.commitPercent + "% used): slowing builds down" : "governor: memory is fine again: builds back to normal"
+        "governor: step " + d.state.step + " (" + d.ramFreePercent + "% RAM free, commit " + d.commitPercent + "% used): " + STEP_TEXT[d.state.step]
       );
-    const paused = nowMs < d.state.pausedUntil && this.pausedPid ? [{ name: this.pausedName, pid: this.pausedPid, seconds: Math.ceil((d.state.pausedUntil - nowMs) / 1e3) }] : [];
     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,
+      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,
+      lastAction: this.lastAction.slice(0, 300),
       updatedAt: now()
     };
-    const shape = JSON.stringify({ ...status, updatedAt: "", paused: paused.map((p) => p.pid) });
+    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;
@@ -32744,33 +32844,64 @@ var GovernorCore = class {
     }
   }
   apply(action) {
+    const port = this.deps.port;
     try {
-      if (action.kind === "hold") {
-        this.deps.port.pause(action.pid, action.ms);
-        if (!this.held.has(action.pid)) {
-          this.held.add(action.pid);
-          this.lastAction = "holding " + action.name + " (" + action.pid + ") until another compiler ends";
-          this.deps.logLine("governor: " + this.lastAction);
-        }
-        return;
-      }
-      if (action.kind === "priority") {
-        this.deps.port.setPriority(action.pid, action.to);
-        this.lastAction = action.name + " (" + action.pid + ") priority " + action.to;
-      } else {
-        this.deps.port.pause(action.pid, action.ms);
-        this.pausedName = action.name;
-        this.pausedPid = action.pid;
-        this.lastAction = "paused " + action.name + " (" + action.pid + ") for " + action.ms / 1e3 + " s";
-        this.deps.logLine("governor: " + this.lastAction);
-        return;
+      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;
       }
-      this.deps.logLine("governor: " + this.lastAction);
     } catch (e) {
-      warn("governor: " + errMsg(e));
+      this.deps.warn("governor: " + errMsg(e));
     }
   }
+  note(text) {
+    this.lastAction = text;
+    this.deps.logLine("governor: " + text);
+  }
 };
+
+// src/guest/governor/governor.ts
+import fs53 from "node:fs";
+import os12 from "node:os";
+import path69 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;
@@ -32801,10 +32932,25 @@ var MemGovProcess = class {
     }
   }
   setPriority(pid, to) {
-    this.child?.stdin?.write("priority " + pid + " " + to + "\n");
+    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);
   }
-  pause(pid, ms) {
-    this.child?.stdin?.write("suspend " + pid + " " + ms + "\n");
+  send(line) {
+    this.child?.stdin?.write(line + "\n");
   }
 };
 function appendToMemoryLog(line) {
@@ -32822,8 +32968,8 @@ var Governor = class {
   core = null;
   describe() {
     const profile = session.loadProfile === "gentle" ? "gentle" : "normal";
-    const t = GUEST_THRESHOLDS[profile];
-    return session.pressureResponse === false ? "off (sandbox.pressureResponse)" : profile + " profile: slows builds down below " + t.enterAvailablePercent + "% free RAM or above " + t.enterCommitPercent + "% commit";
+    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;
@@ -32835,6 +32981,7 @@ var Governor = class {
       maxCompilers: maxCompilers(os12.cpus().length, profile),
       now: () => Date.now(),
       logLine: appendToMemoryLog,
+      warn,
       saveStatus: (status) => {
         try {
           writeJsonAtomic(run.pressureFile, status);
@@ -32845,9 +32992,9 @@ var Governor = class {
     });
     proc.start();
   }
-  /** The host's watchdog: this PC is low for a while. */
-  hostPressure(seconds, reason) {
-    this.core?.hostPressure(seconds, reason);
+  /** 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();
@@ -32895,7 +33042,7 @@ var Daemon = class {
       case "restart":
         return sessions.restart(req);
       case "pressure":
-        return governor.hostPressure(req.seconds, req.reason);
+        return governor.hostPressure(req.seconds, req.reason, req.level ?? "slow");
       case "ping":
         return respond(req.id, { ok: true, message: "pong (" + sessions.count + " session(s) running)" });
     }