windows-development-sandbox 1.27.3 → 1.28.0

package/dist/runtime/view.js

@@ -5743,7 +5743,7 @@ var OutputFilter = class {
   }
 };
 
-// src/shared/pty/console-input.ts
+// src/shared/pty/clipboard-watch.ts
 import { spawn } from "node:child_process";
 
 // src/shared/system.ts
@@ -5796,7 +5796,36 @@ function scriptArgs(name, args = []) {
   ];
 }
 
+// src/shared/pty/clipboard-watch.ts
+var MAX_PENDING = 1024;
+function watchClipboard(onChange) {
+  if (process.platform !== "win32") return { stop: () => void 0 };
+  let child = null;
+  try {
+    child = spawn(SYSTEM.powershell(), scriptArgs("watch-clipboard.ps1", ["-ProcessId", String(process.pid)]), {
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    });
+  } catch {
+    return { stop: () => void 0 };
+  }
+  let pending = "";
+  child.stdout?.setEncoding("latin1");
+  child.stdout?.on("data", (text) => {
+    const lines = (pending + text).split("\n");
+    pending = (lines.pop() ?? "").slice(-MAX_PENDING);
+    for (const line of lines) if (line.trim() === "changed") onChange();
+  });
+  child.on("error", () => void 0);
+  return {
+    stop: () => {
+      if (child && child.exitCode === null && child.signalCode === null) child.kill();
+    }
+  };
+}
+
 // src/shared/pty/console-input.ts
+import { spawn as spawn2 } from "node:child_process";
 function enableVtInput() {
   if (process.platform !== "win32" || !process.stdin.isTTY)
     return { ready: Promise.resolve(false), stop: () => Promise.resolve() };
@@ -5804,7 +5833,7 @@ function enableVtInput() {
   let exited = Promise.resolve();
   const ready = new Promise((resolve) => {
     try {
-      child = spawn(SYSTEM.powershell(), scriptArgs("enable-vt-input.ps1", ["-ProcessId", String(process.pid)]), {
+      child = spawn2(SYSTEM.powershell(), scriptArgs("enable-vt-input.ps1", ["-ProcessId", String(process.pid)]), {
         stdio: "ignore",
         windowsHide: true
       });
@@ -5863,30 +5892,94 @@ function unfinishedSequence(data) {
   return data.length;
 }
 
-// src/shared/pty/ctrl-c.ts
+// src/shared/web/protocol.ts
+var MAX_CLIENT_MESSAGE_BYTES = 256 * 1024;
+
+// src/shared/web/ctrl-c.ts
 var CTRL_C_CONFIRM_MS = 1500;
 var CTRL_C_HINT = "Ctrl+C again to send it to the program (Esc stops an agent)";
-var OSC_TITLE = /\x1b\][02];([^\x07\x1b]{0,256})(?:\x07|\x1b\\)/g;
-var CtrlCGuard = class {
+var CTRL_C_COPY_HINT = "Copied: Ctrl+C after selecting text is not sent to the program (Esc stops an agent)";
+var CtrlCDecider = class {
+  constructor(confirm = true) {
+    this.confirm = confirm;
+  }
+  confirm;
   armedAt = Number.NEGATIVE_INFINITY;
-  lastTitle = "";
-  /** What to send for one read from the keyboard: a lone Ctrl+C only when another came just before. */
-  push(chunk, nowMs) {
-    if (chunk.length !== 1 || chunk[0] !== 3) return { send: chunk, held: false };
+  selected = false;
+  /** Text was selected in the program: Ctrl+C is "copy" from now on. */
+  selection() {
+    this.selected = true;
+    this.armedAt = Number.NEGATIVE_INFINITY;
+  }
+  /** Any other key or a click: Ctrl+C is an interrupt again. */
+  otherInput() {
+    this.selected = false;
+  }
+  /** What to do with a lone Ctrl+C pressed at `nowMs`. */
+  ctrlC(nowMs) {
+    if (this.selected) return "copy";
+    if (!this.confirm) return "send";
     if (nowMs - this.armedAt <= CTRL_C_CONFIRM_MS) {
       this.armedAt = Number.NEGATIVE_INFINITY;
-      return { send: chunk, held: false };
+      return "send";
     }
     this.armedAt = nowMs;
-    return { send: Buffer.alloc(0), held: true };
+    return "hold";
+  }
+};
+var MOUSE_REPORT = /\x1b\[<(\d{1,4});\d{1,5};\d{1,5}([Mm])|\x1b\[M([\s\S])[\s\S]{2}/g;
+function classifyInput(text) {
+  let drag = false;
+  let click = false;
+  for (const m of text.matchAll(MOUSE_REPORT)) {
+    const sgr = m[1] !== void 0;
+    const b = sgr ? Number(m[1]) : (m[3] ?? " ").charCodeAt(0) - 32;
+    if (b & 64) continue;
+    if (b & 32) {
+      if ((b & 3) !== 3) drag = true;
+    } else if (sgr ? m[2] === "M" : (b & 3) !== 3) click = true;
+  }
+  return { mouse: drag ? "drag" : click ? "click" : null, keys: text.replace(MOUSE_REPORT, "").length > 0 };
+}
+function hasClipboardWrite(text) {
+  return /\x1b\]0{0,2}52;/.test(text) || /\u009d0{0,2}52;/.test(text);
+}
+
+// src/shared/pty/ctrl-c.ts
+var OSC_TITLE = /\x1b\][02];([^\x07\x1b]{0,256})(?:\x07|\x1b\\)/g;
+var CtrlCGuard = class {
+  decider;
+  lastTitle = "";
+  constructor(options = {}) {
+    this.decider = new CtrlCDecider(options.confirm !== false);
+  }
+  /** What to send for one read from the keyboard: a lone Ctrl+C only when it is not held back or taken as "copy". */
+  push(chunk, nowMs) {
+    if (chunk.length === 1 && chunk[0] === 3) {
+      const action = this.decider.ctrlC(nowMs);
+      if (action === "send") return { send: chunk, held: false, copied: false };
+      return { send: Buffer.alloc(0), held: action === "hold", copied: action === "copy" };
+    }
+    const c = classifyInput(chunk.toString("latin1"));
+    if (c.keys || c.mouse === "click") this.decider.otherInput();
+    else if (c.mouse === "drag") this.decider.selection();
+    return { send: chunk, held: false, copied: false };
+  }
+  /** The clipboard changed since the last key: you just copied. */
+  clipboardChanged() {
+    this.decider.selection();
+  }
+  /** The program wrote to the clipboard: that is a selection too. */
+  watchClipboard(raw) {
+    if (hasClipboardWrite(raw)) this.decider.selection();
   }
   /** Remembers the title the program last set (from its output), to put it back after the hint. */
   watchOutput(text) {
     for (const m of text.matchAll(OSC_TITLE)) this.lastTitle = m[1];
   }
   /** The escape sequence that shows the hint, and the one that puts the program's title back. */
-  hintTitle() {
-    return "\x1B]0;" + CTRL_C_HINT + "\x07";
+  hintTitle(kind = "hold") {
+    return "\x1B]0;" + (kind === "copy" ? CTRL_C_COPY_HINT : CTRL_C_HINT) + "\x07";
   }
   restoreTitle() {
     return "\x1B]0;" + this.lastTitle.replace(/[\x00-\x1f\x7f]/g, "") + "\x07";
@@ -6090,6 +6183,7 @@ function runTerminalClient(socket, token, options = {}) {
       clearTimeout(joinTimer);
       clearTimeout(hintTimer);
       clearTimeout(vtTimer);
+      clipboard.stop();
       socket.destroy();
       const tracked = mouse.tracking();
       const reset = "\x1B[0m\x1B[?25h" + MOUSE_OFF + (mouse.has(2004) ? "\x1B[?2004l" : "") + "\r\n";
@@ -6107,23 +6201,22 @@ function runTerminalClient(socket, token, options = {}) {
       if (data.length && !done) socket.write(encodeFrame(FrameType.Input, data));
     };
     const sendInput = (data) => write(keys.push(passthrough ? mouse.filter(data) : data));
-    const guard = options.confirmCtrlC ? new CtrlCGuard() : null;
+    const guard = new CtrlCGuard({ confirm: options.confirmCtrlC !== false });
     let hintTimer;
+    const clipboard = watchClipboard(() => guard.clipboardChanged());
     const onInput = (chunk) => {
       if (options.detachKey !== void 0 && chunk.includes(options.detachKey)) {
         finish({ reason: "detach" });
         return;
       }
-      if (guard) {
-        const decided = guard.push(chunk, Date.now());
-        clearTimeout(hintTimer);
-        if (decided.held) {
-          stdout.write(guard.hintTitle());
-          hintTimer = setTimeout(() => stdout.write(guard.restoreTitle()), CTRL_C_CONFIRM_MS);
-          return;
-        }
-        if (decided.send.length === 1 && decided.send[0] === 3) stdout.write(guard.restoreTitle());
+      const decided = guard.push(chunk, Date.now());
+      clearTimeout(hintTimer);
+      if (decided.held || decided.copied) {
+        stdout.write(guard.hintTitle(decided.copied ? "copy" : "hold"));
+        hintTimer = setTimeout(() => stdout.write(guard.restoreTitle()), CTRL_C_CONFIRM_MS);
+        return;
       }
+      if (decided.send.length === 1 && decided.send[0] === 3) stdout.write(guard.restoreTitle());
       clearTimeout(joinTimer);
       sendInput(joiner.push(chunk));
       if (joiner.holding()) joinTimer = setTimeout(() => sendInput(joiner.flush()), JOIN_MS);
@@ -6156,9 +6249,10 @@ function runTerminalClient(socket, token, options = {}) {
       }
       for (const frame of frames) {
         if (frame.type === FrameType.Output) {
+          guard.watchClipboard(frame.payload.toString("latin1"));
           const out = filter.push(frame.payload);
           mouse.watch(out);
-          guard?.watchOutput(out.toString("latin1"));
+          guard.watchOutput(out.toString("latin1"));
           stdout.write(out);
         } else if (frame.type === FrameType.Console) passthrough = frame.payload.toString("latin1") === "conpty.dll";
         else if (frame.type === FrameType.Restarting) {
@@ -26106,7 +26200,7 @@ var SandboxSchema = external_exports.strictObject({
     '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 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."
+    "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. A memory gate also holds new compilers and linkers for a moment when the memory of the build programs grows faster than 4 GB in 3 seconds (3 GB with vGPU), and lets them go one at a time. 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). Browsers in the sandbox never use it (they draw in software)."
@@ -28304,6 +28398,8 @@ var PressureStatusSchema = external_exports.object({
   lowered: external_exports.number().int().min(0).max(1024),
   /** 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),
+  /** Build programs the memory gate holds right now (let go one at a time). */
+  held: external_exports.number().int().min(0).max(1024).optional(),
   /** 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). */
@@ -28324,6 +28420,8 @@ var HeartbeatSchema = external_exports.object({
   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(),
+  /** Build programs the memory gate holds right now (let go one at a time). */
+  held: external_exports.number().int().min(0).max(1024).optional(),
   /** "ending": the sandbox is shutting down in order (idle shutdown, sandbox stop, Windows shutting down). */
   phase: external_exports.enum(["ready", "working", "ending"])
 });
@@ -28652,7 +28750,7 @@ import crypto from "node:crypto";
 
 // src/shared/download/spawn.ts
 import os3 from "node:os";
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 function lowerPriority(pid) {
   if (pid === void 0) return;
   try {
@@ -28663,7 +28761,7 @@ function lowerPriority(pid) {
 function spawnAsync(file2, args, options = {}) {
   const { lowPriority, ...spawnOptions } = options;
   return new Promise((resolve, reject) => {
-    const child = spawn2(file2, args, { stdio: "ignore", windowsHide: true, ...spawnOptions });
+    const child = spawn3(file2, args, { stdio: "ignore", windowsHide: true, ...spawnOptions });
     if (lowPriority) lowerPriority(child.pid);
     child.once("error", reject);
     child.once("close", (code) => resolve(code ?? -1));

package/dist/selftest/agent-paths.test.js

@@ -7,7 +7,7 @@ import { isWin } from '../core/util/index.js';
 import { SYSTEM } from '../shared/system.js';
 import { agentCommand, agentShims, bootResetPaths, isCopyableDatabaseFile, isDatabaseFile, localStateEntries, shimText, } from '../guest/agents/agent-files.js';
 import { appendMissing, expandVars, installedToolPaths, isGitUsrBin, isMsvcToolsDir, isPinnedNodeDir, msvcBeforeGitUsr, parseRegPath, pathKey, planPath, rebuildPath, sessionPath, splitPath, } from '../guest/setup/path-plan.js';
-import { withReloadEnvironment } from '../host/tools/index.js';
+import { withCopyOnSelect, withReloadEnvironment } from '../host/tools/index.js';
 import { HarnessSchema } from '../core/schema/index.js';
 export const agentPathsSuite = {
     name: 'agent-paths',
@@ -136,6 +136,8 @@ export const agentPathsSuite = {
         t.section('Windows Terminal reloads the environment');
         t.equal(withReloadEnvironment({ compatibility: { reloadEnvironmentVariables: true } }), null, 'already set: unchanged');
         t.equal(withReloadEnvironment({ theme: 'dark', compatibility: { other: 1 } })?.compatibility, { other: 1, reloadEnvironmentVariables: true }, 'set without touching the rest of compatibility');
+        t.equal(withCopyOnSelect({ theme: 'dark' })?.copyOnSelect, true, 'copy on select is added when the key is missing');
+        t.equal(withCopyOnSelect({ copyOnSelect: false }), null, 'a copy-on-select value the user set stays');
         if (!isWin)
             return;
         t.section('shell start-up (pathsync.exe and the start-up files)');

package/dist/selftest/channel.test.js

@@ -4,6 +4,7 @@ import { safeId } from '../shared/channel/index.js';
 import { GuestRequestSchema, SandboxStatusSchema, SessionStatusSchema } from '../shared/channel/index.js';
 import { bootLine, firstStartNotice, pendingDownloads, readyIn, stillWorking } from '../cli/commands/launch/index.js';
 import { CTRL_C_CONFIRM_MS, CTRL_C_HINT, CtrlCGuard, encodeFrame, FrameReader, FrameType, fixWindowsKeys, helloFrame, InputJoiner, KeyGate, MAX_FRAME_BYTES, MOUSE_OFF, MouseModes, OutputFilter, } from '../shared/pty/index.js';
+import { classifyInput } from '../shared/web/index.js';
 import { bootSilent, FIRST_STATUS_MS } from '../host/channel/index.js';
 export const channelSuite = {
     name: 'channel',
@@ -251,6 +252,38 @@ export const channelSuite = {
             !g.push(Buffer.from('x'), 6000).held, 'a lone Ctrl+C is held back, a second one soon after is sent, a late second one is held again, other input passes');
         g.watchOutput('\x1b]0;claude: working\x07more \x1b]2;\u0001evil\x07');
         t.check(g.hintTitle().includes(CTRL_C_HINT) && g.restoreTitle() === '\x1b]0;evil\x07', "the hint shows in the title, and the program's last title comes back without control characters");
+        const drag = Buffer.from('\x1b[<32;10;5M');
+        const release = Buffer.from('\x1b[<0;12;5m');
+        const copyG = new CtrlCGuard();
+        copyG.push(drag, 0);
+        copyG.push(release, 10);
+        const copies = [100, 200, 300].map((at) => copyG.push(ctrlC, at));
+        t.check(copies.every((c) => c.send.length === 0 && c.copied && !c.held), 'after a mouse drag in the program every Ctrl+C is copied and never sent, however often it is pressed');
+        copyG.push(Buffer.from('x'), 400);
+        t.check(copyG.push(ctrlC, 500).held, 'after another key a lone Ctrl+C is held back again');
+        const clickG = new CtrlCGuard();
+        clickG.push(drag, 0);
+        clickG.push(Buffer.from('\x1b[<0;3;3M'), 10);
+        t.check(clickG.push(ctrlC, 20).held, 'a mouse click after a drag ends copy mode');
+        const quietG = new CtrlCGuard();
+        quietG.push(Buffer.from('\x1b[<64;3;3M'), 0);
+        quietG.push(Buffer.from('\x1b[<35;3;3M'), 1);
+        t.check(quietG.push(ctrlC, 2).held, 'mouse wheel and hover reports do not start copy mode');
+        const clipG = new CtrlCGuard();
+        clipG.watchClipboard('\x1b]52;c;aGk=');
+        t.check(clipG.push(ctrlC, 0).copied, 'the program writing the clipboard (OSC 52) starts copy mode');
+        const copiedG = new CtrlCGuard();
+        copiedG.clipboardChanged();
+        const afterCopy = copiedG.push(ctrlC, 0);
+        copiedG.push(Buffer.from('x'), 1);
+        t.check(afterCopy.copied && !afterCopy.held && afterCopy.send.length === 0 && copiedG.push(ctrlC, 2).held, 'after the clipboard changed a lone Ctrl+C is copied (not sent, not held) until another key is pressed');
+        const noConfirm = new CtrlCGuard({ confirm: false });
+        const sentAtOnce = noConfirm.push(ctrlC, 0);
+        noConfirm.push(drag, 1);
+        t.check(sentAtOnce.send.equals(ctrlC) && noConfirm.push(ctrlC, 2).copied, 'without confirmation a lone Ctrl+C is sent at once, but after a drag it is still copied');
+        const x10 = classifyInput('\x1b[M' + String.fromCharCode(32 + 32) + '!!');
+        const arrow = classifyInput('\x1b[A');
+        t.check(x10.mouse === 'drag' && !x10.keys && arrow.mouse === null && arrow.keys, 'an X10 drag is a drag without keys, and an arrow key is a key without a mouse report');
         t.section('typed input keeps escape sequences whole');
         const joined = (...chunks) => {
             const j = new InputJoiner();

package/dist/selftest/heavy-load.test.js

@@ -8,7 +8,7 @@ import { DEFAULTS } from '../core/config/index.js';
 import { isWin } from '../core/util/index.js';
 import { SYSTEM } from '../shared/system.js';
 import { GuestRequestSchema, PressureStatusSchema } from '../shared/channel/index.js';
-import { compilersAllowed, DIAL_CALM_SAMPLES, DIAL_STEPS, HOST_THRESHOLDS, buildJobs, cargoJobs, linkSlotsFor, usableCpus, effectiveCpuLimit, gentleCpuLimit, maxCompilers, chooseTargetDir, cargoLinkerVar, } from '../shared/memory/index.js';
+import { BURST_GATE, compilersAllowed, DIAL_CALM_SAMPLES, DIAL_STEPS, HOST_THRESHOLDS, buildJobs, cargoJobs, linkSlotsFor, usableCpus, effectiveCpuLimit, gentleCpuLimit, maxCompilers, chooseTargetDir, cargoLinkerVar, ubtBuildConfiguration, } from '../shared/memory/index.js';
 import { HeartbeatSchema } from '../shared/channel/index.js';
 import { heartbeatLine, lastEndOf, vanishedCause, stopWarning } from '../host/life/index.js';
 import { cappedMemoryMb, decideMemory, memoryNote, residentCapMb, residentNote, resolveMemoryMb, } from '../host/launch/index.js';
@@ -16,10 +16,10 @@ import { vgpuWarning, GENTLE_NOTE } from '../host/launch/risk-notes.js';
 import { judgeSandbox } from '../host/health/index.js';
 import { cleanUpLeftovers, cleanupQuestion, killArgs } from '../host/sandbox/index.js';
 import { parseTasklist } from '../host/sharing/index.js';
-import { bugcheckCode, cpuPercentBetween, explainStop, findDumps, findingLines, freezeLine, hostPressure, lowReason, severeHost, pageFileRisk, parseHostMemory, crashReportText, watchdogStep, WATCHDOG_START, } from '../host/life/index.js';
+import { bugcheckCode, cpuPercentBetween, explainStop, findDumps, findingLines, freezeLine, hostPressure, lowReason, memoryWasFineLine, severeHost, pageFileRisk, parseHostMemory, crashReportText, watchdogStep, WATCHDOG_START, } from '../host/life/index.js';
 // The pure governor files only: governor.ts loads the guest runtime (session.json), which exists only in a sandbox.
-import { canLower, canPause, decide, INITIAL_STATE, isLinker, linkerSlots, ROTATE_MS, } from '../guest/governor/decide.js';
-import { GovernorCore } from '../guest/governor/core.js';
+import { canLower, canPause, decide, GATE_NAMES, INITIAL_STATE, isLinker, isNeverTouched, linkerSlots, ROTATE_MS, } from '../guest/governor/decide.js';
+import { GateEventSchema, GovernorCore, memgovArgs } from '../guest/governor/core.js';
 const GB = 1024;
 const MB_SANDBOX = DEFAULTS.sandbox;
 const proc = (pid, name, mb, prio = 'normal') => ({
@@ -96,6 +96,10 @@ export const heavyLoadSuite = {
         t.check(cargoJobs(16, 32, 3) === 2 && cargoJobs(16, 32, 8) === 1, 'fewer when several sessions build');
         t.check(cargoJobs(32, 32, 1) === 8, '32 processors, 32 GB: 8 jobs for one session');
         t.check(buildJobs(32, 32) === 8 && buildJobs(32, 64) === 19 && buildJobs(4, 64) === 4 && buildJobs(16, 4) === 2, 'the build budget: 3 GB per job after 6 GB, never more than the processors, at least 2');
+        const ubt = ubtBuildConfiguration(buildJobs(20, 36));
+        t.check(ubt.includes('<MaxParallelActions>10</MaxParallelActions>') &&
+            ubt.includes('xmlns="https://www.unrealengine.com/BuildConfiguration"') &&
+            ubtBuildConfiguration(0).includes('<MaxParallelActions>1</MaxParallelActions>'), "UnrealBuildTool's compiles at once follow the build budget (at least 1)", ubt);
         t.check(linkSlotsFor(32) === 8 && linkSlotsFor(16) === 3 && linkSlotsFor(8) === 2 && linkSlotsFor(128) === 8, 'links at once ("auto"): one per 3 GB after 6 GB, 2 to 8');
         t.check(usableCpus(32, 80) === 25 && usableCpus(32, null) === 32 && usableCpus(4, 10) === 2 && usableCpus(8, 100) === 8, 'the processors programs see follow the CPU cap (at least 2)');
         t.section('the governor: which programs');
@@ -374,6 +378,105 @@ export const heavyLoadSuite = {
         t.check(decide({ ...INITIAL_STATE, hostUntil: clock + 60000, hostStep: 4 }, sample(60, 40, procs), clock, 'normal').state
             .step === 4, 'with plenty of memory in the sandbox, a severe PC still turns the dial to 4');
         t.check(core.current.hostUntil === clock + 60000, 'a host request is remembered for its seconds');
+        t.section('the memory gate (rate of growth)');
+        t.check(['cl', 'link', 'rustc', 'clang-cl', 'lld-link', 'shadercompileworker'].every((n) => GATE_NAMES.includes(n)), 'the gate may freeze compilers, linkers and Unreal shader workers', GATE_NAMES.join(','));
+        t.check([
+            'node',
+            'claude',
+            'codex',
+            'opencode',
+            'cmd',
+            'pwsh',
+            'powershell',
+            'msbuild',
+            'dotnet',
+            'cargo',
+            'ninja',
+            'unrealbuildtool',
+            'ubahost',
+            'unrealeditor',
+            'unrealeditor-cmd',
+            'mspdbsrv',
+            'ptyhost',
+            'memgov',
+        ].every((n) => !GATE_NAMES.includes(n)) &&
+            GATE_NAMES.every((n) => (canPause(n) || n === 'shadercompileworker') && !isNeverTouched(n)), 'agents, shells, build coordinators, the editor and the tools themselves are never frozen');
+        t.check(JSON.stringify(memgovArgs('normal')) ===
+            JSON.stringify([
+                'serve',
+                '--interval',
+                '2',
+                '--gate',
+                '4096:3000:1500:30000',
+                '--gate-names',
+                GATE_NAMES.join(','),
+            ]) && memgovArgs('gentle').includes('3072:3000:2000:30000'), 'memgov starts with the gate for the profile', memgovArgs('gentle').join(' '));
+        t.check(['normal', 'gentle'].every((p) => {
+            const g = BURST_GATE[p];
+            return g.growthMb >= 1024 && g.maxHoldMs <= 30000 && g.releaseMs < g.maxHoldMs && g.windowMs >= 1000;
+        }) && BURST_GATE.gentle.growthMb <= BURST_GATE.normal.growthMb, 'the gate is sane: a real burst size, every hold ends within 30 s, vGPU is not looser');
+        const gateExamples = [
+            { event: 'gate', at: 1, kind: 'ready', mode: 'notify', growthMb: 4096, windowMs: 3000 },
+            { event: 'gate', at: 1, kind: 'off', reason: 'bad --gate' },
+            { event: 'gate', at: 1, kind: 'trip', grewMb: 4210, ms: 1800, jobMb: 23456, held: [{ pid: 101, name: 'cl' }] },
+            { event: 'gate', at: 1, kind: 'hold', pid: 101, name: 'cl' },
+            { event: 'gate', at: 1, kind: 'release', pid: 101, name: 'cl', heldMs: 1500, forced: false },
+        ];
+        const heldOf = (n) => Array.from({ length: n }, (_, i) => ({ pid: i, name: 'cl' }));
+        t.check(gateExamples.every((e) => GateEventSchema.safeParse(e).success) &&
+            !GateEventSchema.safeParse({ event: 'gate', at: 1, kind: 'hold', pid: 1, name: 'x'.repeat(129) }).success &&
+            !GateEventSchema.safeParse({ event: 'gate', at: 1, kind: 'trip', grewMb: 1, ms: 1, jobMb: 1, held: heldOf(65) })
+                .success &&
+            !GateEventSchema.safeParse({ event: 'gate', at: 1, kind: 'boom' }).success &&
+            !GateEventSchema.safeParse({ at: 1, kind: 'hold', pid: 1, name: 'cl' }).success, 'gate events from memgov are checked: one of each kind passes; a long name, 65 held, a bad kind or no event fail');
+        {
+            const gateLogs = [];
+            const gateCore = new GovernorCore({
+                port,
+                profile: 'normal',
+                now: () => 0,
+                logLine: (l) => gateLogs.push(l),
+                saveStatus: () => undefined,
+                warn: (line) => gateLogs.push(line),
+            });
+            gateCore.onGate({
+                event: 'gate',
+                at: 1,
+                kind: 'trip',
+                grewMb: 4210,
+                ms: 1800,
+                jobMb: 23456,
+                held: [{ pid: 101, name: 'cl' }],
+            });
+            gateCore.onGate({
+                event: 'gate',
+                at: 2,
+                kind: 'release',
+                pid: 101,
+                name: 'cl',
+                heldMs: 30000,
+                forced: true,
+            });
+            t.check(gateLogs.some((l) => l.includes("governor: gate: the agents' programs grew 4210 MB in 1.8 s (now 23456 MB); holding 1: cl (101)")) &&
+                gateLogs.some((l) => l.endsWith('(the longest it may wait)')) &&
+                gateCore.current.step === 0, 'gate events go to the memory log and leave the dial alone', gateLogs.join('\n'));
+            const heldStatuses = [];
+            const heldCore = new GovernorCore({
+                port,
+                profile: 'normal',
+                now: () => 0,
+                logLine: () => undefined,
+                saveStatus: (s) => heldStatuses.push(s),
+                warn: () => undefined,
+            });
+            heldCore.onSample({ ...sample(60, 40, procs), gateHeld: 3 });
+            const heldStatus = heldStatuses[heldStatuses.length - 1];
+            t.check(PressureStatusSchema.safeParse(heldStatus).success &&
+                heldStatus.held === 3 &&
+                heldCore.snapshot?.held === 3, 'the number of held builds reaches the status file and the snapshot', JSON.stringify(heldStatus));
+            t.check(HeartbeatSchema.safeParse({ ...beat, held: 3 }).success &&
+                heartbeatLine({ ...beat, held: 3 }).includes('3 builds held by the memory gate'), 'the heartbeat carries the held builds into the crash report line');
+        }
         t.section("the PC's watchdog");
         const input = (memory, nowMs, cpu = 10, profile = 'normal') => ({
             memory,
@@ -541,6 +644,13 @@ export const heavyLoadSuite = {
             meaning.includes('froze, lost power') &&
             meaning.includes('hardware error') &&
             meaning.includes('vmwp.exe'), 'what each finding usually means, in plain words', meaning);
+        t.check(findingLines([ev(1000, 'Application Error', '2026-10-15T19:41:12Z', 'Faulting application name: vmwp.exe')])
+            .join('\n')
+            .includes('not a program inside the sandbox running out of memory'), 'a crash of vmwp.exe is named as a fault in Windows or a driver, not memory');
+        t.check(memoryWasFineLine('x\n2026-11-08T15:30:05.411Z | RAM free/total MB 42325/63170 | commit free/limit MB 52051/75458 | page file auto\n')?.includes('still had 41 GB of RAM and 50 GB') === true &&
+            memoryWasFineLine('2026-10-15T19:40:50Z | RAM free/total MB 900/32768 | commit free/limit MB 9000/40000') ===
+                null &&
+            memoryWasFineLine('') === null, 'the report says when this PC still had plenty of memory, and says nothing when it was low');
         const dumps = path.join(t.at('crash-dumps'), 'Minidump');
         fs.mkdirSync(dumps, { recursive: true });
         fs.writeFileSync(path.join(dumps, '101526-1.dmp'), 'x');
@@ -576,6 +686,7 @@ export const heavyLoadSuite = {
         };
         const sandboxCs = (n) => path.join(t.packageRoot, 'sandbox', 'csharp', n);
         build('ptyhost', [sandboxCs('PtyHost.cs')]);
+        build('clipboardwatch', [sandboxCs('ClipboardWatch.cs')], 'library');
         const memgov = build('memgov', [sandboxCs('MemGov.cs')]);
         const hostDir = path.join(t.packageRoot, 'native', 'csharp', 'HostTools');
         const tools = build('HostTools', fs
@@ -607,6 +718,7 @@ export const heavyLoadSuite = {
             // Not JSON: the check below fails.
         }
         t.check(sampleOk && served.status === 0, 'memgov serve prints a well-formed sample and ends when its input closes', firstLine);
+        t.check(!(served.stdout ?? '').split(/\r?\n/).some((l) => l.includes('"event":"gate"')), 'a memgov started without --gate never takes the job port (no gate events)');
         for (const script of ['memory-status.ps1', 'stop-events.ps1']) {
             const text = fs.readFileSync(path.join(t.packageRoot, 'native', 'scripts', script), 'utf8');
             t.check(text.startsWith('#Requires -Version 5.1'), script + ' says its PowerShell version');

package/dist/selftest/live-terminal.test.js

@@ -11,6 +11,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { pathToFileURL } from 'node:url';
 import { encodeFrame, FrameType } from '../shared/pty/index.js';
 import { SYSTEM } from '../shared/system.js';
+import { GateEventSchema } from '../guest/governor/core.js';
 import { CSC, openViewer, tail, WAIT } from './support/live.js';
 /**
  * The stand-in agent: VT input and SGR mouse tracking on, echoes what it reads ("got <1b>[<0;10;5M"). L prints 500
@@ -268,6 +269,108 @@ export const liveTerminalSuite = {
                 Number(set[1]) === Math.max(Math.floor(commit / 2), commit - Math.max(1536, Math.floor((commit * 3) / 100))), 'the ptyhost that creates the job sets the backstop just below the commit limit (auto: 3 %, at least 1.5 GB)', read('job-first.log'));
             t.check(read('job-second.log').includes('joined the existing one'), 'a ptyhost that joins the job never changes its backstop', read('job-second.log'));
         }
+        t.section('the memory gate: a burst is held at once and let go in turn');
+        {
+            // A job of the test's own (never the agents' real one) for both ptyhosts and memgov.
+            const jobName = 'Local\\AgentSandboxAgentsJobTest' + process.pid + '-gate-' + Date.now();
+            const memgovExe = t.at('memgov-gate.exe');
+            const burstExe = t.at('MemoryBurst.exe');
+            const gateErrors = compile(path.join(t.packageRoot, 'sandbox', 'csharp', 'MemGov.cs'), memgovExe) ||
+                compile(path.join(t.packageRoot, 'src', 'selftest', 'fixtures', 'memory-burst', 'MemoryBurst.cs'), burstExe);
+            t.check(!gateErrors, 'memgov and the memory burst program compile', gateErrors);
+            if (!gateErrors) {
+                const ping = path.join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'PING.EXE');
+                const holder = '"' + SYSTEM.cmd() + '" /c "' + ping + '" -n 60 127.0.0.1 >nul';
+                const progress = t.at('burst-progress.txt');
+                const startHost = async (command, log) => spawn(ptyhost, [String(await freePort()), 'tok', '80', '24', t.at(log), command], {
+                    env: { ...process.env, PTYHOST_BIND: 'loopback', PTYHOST_BACKSTOP_MB: 'none', PTYHOST_JOB_NAME: jobName },
+                    stdio: 'ignore',
+                    windowsHide: true,
+                });
+                const read = (file) => (fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '');
+                const hosts = [];
+                let memgov = null;
+                try {
+                    hosts.push(await startHost(holder, 'gate-a.log'));
+                    await t.waitFor(() => read(t.at('gate-a.log')).includes('agent job:'), WAIT.screen);
+                    memgov = spawn(memgovExe, ['serve', '--interval', '1', '--gate', '512:3000:800:4000', '--gate-names', 'memoryburst'], {
+                        env: { ...process.env, MEMGOV_JOB_NAME: jobName },
+                        stdio: ['pipe', 'pipe', 'ignore'],
+                        windowsHide: true,
+                    });
+                    let text = '';
+                    memgov.stdout.on('data', (chunk) => (text += chunk.toString('utf8')));
+                    const events = () => text
+                        .split(/\r?\n/)
+                        .filter((l) => l.includes('"event":"gate"'))
+                        .flatMap((l) => {
+                        try {
+                            const parsed = GateEventSchema.safeParse(JSON.parse(l));
+                            return parsed.success ? [parsed.data] : [];
+                        }
+                        catch {
+                            return [];
+                        }
+                    });
+                    const ready = await t.waitFor(() => events().some((e) => e.kind === 'ready'), WAIT.screen);
+                    const readyEvent = events().find((e) => e.kind === 'ready');
+                    t.check(Boolean(ready) && readyEvent?.kind === 'ready' && readyEvent.mode === 'notify', "the gate listens to the job's notifications (no polling)", text.slice(-400));
+                    hosts.push(await startHost('"' + burstExe + '" 1536 "' + progress + '"', 'gate-b.log'));
+                    const finished = await t.waitFor(() => read(progress).includes('done'), 15000);
+                    const marks = read(progress)
+                        .split(/\r?\n/)
+                        .flatMap((l) => {
+                        const m = /^(\d+) \d+$/.exec(l.trim());
+                        return m ? [Number(m[1])] : [];
+                    });
+                    const all = events();
+                    const trips = all.flatMap((e) => (e.kind === 'trip' ? [e] : []));
+                    const releases = all.flatMap((e) => (e.kind === 'release' ? [e] : []));
+                    const evidence = text.slice(-1200) + '\nprogress: ' + marks.length + ' lines';
+                    const firstTrip = trips[0];
+                    t.check(trips.some((e) => e.held.some((h) => h.name === 'memoryburst')) &&
+                        firstTrip !== undefined &&
+                        firstTrip.grewMb >= 512 &&
+                        firstTrip.grewMb <= 1024, 'a burst past the gate is held at once', evidence);
+                    const stalls = [];
+                    for (const trip of trips) {
+                        if (!trip.held.some((h) => h.name === 'memoryburst'))
+                            continue;
+                        const release = releases.find((r) => r.at >= trip.at && r.name === 'memoryburst');
+                        const until = release ? release.at : Infinity;
+                        if (marks.some((m) => m > trip.at + 200 && m < until))
+                            stalls.push('trip at ' + trip.at);
+                    }
+                    t.check(stalls.length === 0, 'the held program made no progress more than 200 ms after the trip until it was let go', stalls.join(', ') + '\n' + evidence);
+                    t.check(releases.length > 0 && releases.every((r) => r.heldMs <= 4500) && releases.some((r) => !r.forced), 'held programs go on in turn, never longer than the most allowed', evidence);
+                    t.check(Boolean(finished) && trips.length >= 2, 'the burst program reached its end after at least 2 trips', evidence);
+                }
+                finally {
+                    if (memgov) {
+                        memgov.stdin.end();
+                        const ended = memgov;
+                        await t.waitFor(() => ended.exitCode !== null, 5000);
+                        t.check(ended.exitCode === 0, 'memgov with the gate ends cleanly when its input closes');
+                        try {
+                            if (ended.exitCode === null)
+                                ended.kill();
+                        }
+                        catch {
+                            /* it ended between the check and the kill: nothing left to stop */
+                        }
+                    }
+                    for (const c of hosts) {
+                        try {
+                            if (c.exitCode === null)
+                                c.kill();
+                        }
+                        catch {
+                            /* it ended between the check and the kill: nothing left to stop */
+                        }
+                    }
+                }
+            }
+        }
         const client = t.at('client.mjs');
         fs.writeFileSync(client, [
             'import { connect, runTerminalClient } from ' +

package/dist/selftest/personalization.test.js

@@ -47,7 +47,8 @@ export const personalizationSuite = {
         const untouched = fs.readFileSync(settings, 'utf8');
         t.check(untouched.startsWith('// edited') &&
             /"guid": "\{x\}",\s*\}/.test(untouched) &&
-            /"reloadEnvironmentVariables":\s*true/.test(untouched), 'until pwsh is installed only the reload switch is added (comments and trailing commas survive)');
+            /"reloadEnvironmentVariables":\s*true/.test(untouched) &&
+            /"copyOnSelect":\s*true/.test(untouched), 'until pwsh is installed only the default switches are added (comments and trailing commas survive)');
         t.write(path.join(data, 'tools', 'pwsh', 'pwsh.exe'), 'MZ');
         syncPwshProfile(data, true);
         const added = read();

package/dist/selftest/support/engine-golden.js

@@ -62,6 +62,7 @@ export const LAUNCH_FILES_GOLDEN = [
     'sandbox/csharp/AppActivation.cs',
     'sandbox/csharp/BindMount.cs',
     'sandbox/csharp/CargoShim.cs',
+    'sandbox/csharp/ClipboardWatch.cs',
     'sandbox/csharp/Desktop.cs',
     'sandbox/csharp/EnvBroadcast.cs',
     'sandbox/csharp/GitShim.cs',
@@ -95,6 +96,7 @@ export const LAUNCH_FILES_GOLDEN = [
     'sandbox/scripts/set-machine-environment.ps1',
     'sandbox/scripts/set-registry-values.ps1',
     'sandbox/scripts/start-store-app.ps1',
+    'sandbox/scripts/watch-clipboard.ps1',
     'sandbox/templates/fivem/README.txt',
     'sandbox/templates/fivem/cs/Client/Client.csproj',
     'sandbox/templates/fivem/cs/Client/ClientMain.cs',