windows-development-sandbox 1.9.0 → 1.11.3

package/dist/guest/governor/decide.js

@@ -1,3 +1,9 @@
+// The memory governor's decisions (pure): given a memory sample and what it did before, how far to turn the dial and
+// what that means for the build programs in the agents' job. Like a PC that gets slower instead of failing: lower
+// priority, lower memory priority (their pages are trimmed first), less CPU, fewer compilers at a time (the others wait
+// their turn, suspended and always resumed), waiting compilers trimmed to the paging file. Agents, shells and Windows
+// are never touched. Nothing here touches Windows; governor.ts carries the actions out through a port.
+import { compilersAllowed, DIAL_CALM_SAMPLES, DIAL_CPU_RATE, DIAL_EXIT_MARGIN, DIAL_STEPS, } from '../../shared/memory/index.js';
 /** Programs that compile or link: they may be slowed down and, as the last resort, paused for a few seconds. */
 const COMPILERS = new Set([
     'rustc',
@@ -25,8 +31,8 @@ const COMPILERS = new Set([
     'javac',
 ]);
 /** Build tools and workers: slowed down but never paused (a node process may be a dev server or an agent). */
+// Not node: agents such as Codex and Gemini run as node.exe, and the agents are never slowed down.
 const BUILD_TOOLS = new Set([
-    'node',
     'dotnet',
     'msbuild',
     'vbcscompiler',
@@ -77,103 +83,180 @@ const NEVER = new Set([
 const key = (name) => name.toLowerCase().replace(/\.exe$/, '');
 export const isNeverTouched = (name) => NEVER.has(key(name));
 export const canLower = (name) => !isNeverTouched(name) && (COMPILERS.has(key(name)) || BUILD_TOOLS.has(key(name)));
+/** The heavy ones the concurrency cap counts (drivers like gcc and collect2 only wait for these). */
+const HEAVY = new Set([
+    'rustc',
+    'clippy-driver',
+    'rustdoc',
+    'cc1',
+    'cc1plus',
+    'clang',
+    'clang++',
+    'clang-cl',
+    'cl',
+    'link',
+    'lld',
+    'lld-link',
+    'ld',
+    'ld.lld',
+]);
+export const isHeavyCompiler = (name) => !isNeverTouched(name) && HEAVY.has(key(name));
 export const canPause = (name) => !isNeverTouched(name) && COMPILERS.has(key(name));
 export const INITIAL_STATE = {
-    pressure: false,
+    step: 0,
     calm: 0,
-    samples: 0,
     lowered: {},
-    pausedUntil: 0,
-    nextPauseAt: 0,
+    memLow: [],
+    throttled: [],
+    trimmed: [],
+    cpuRate: 100,
+    lastCommitMb: 0,
+    lastAt: 0,
+    growth: 0,
     hostUntil: 0,
+    hostStep: 0,
 };
-export const PAUSE_MS = 5000;
-const PAUSE_COOLDOWN_MS = 10000;
-/** Samples under pressure before programs go from below-normal to idle, and before one is paused. */
-const IDLE_AFTER = 3;
-const PAUSE_AFTER = 4;
-/** Only a program this big is worth pausing. */
-const PAUSE_MIN_MB = 300;
+/** How much the newest sample counts in the smoothed commit growth. */
+const GROWTH_WEIGHT = 0.3;
+/** How long a held compiler waits before it may get a turn again (the governor repeats the hold while it waits). */
+export const HOLD_MS = 3000;
+/** Which compilers wait their turn changes this often, so none waits for ever. */
+export const ROTATE_MS = 20000;
+/**
+ * "Full soon" only counts this close (in commit percent) to a step's own threshold: a build that grabs a few GB in a
+ * burst while most of the memory is free is normal, not a reason to pause compilers.
+ */
+const SOON_WITHIN_PERCENT = 12;
+/** The step a sample calls for on its own: the highest step whose threshold it crosses. */
+export 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 !== undefined && secondsToLimit < t.secondsToLimit;
+        if (ramFree < t.availablePercent || commit > t.commitPercent || soon)
+            step = i + 1;
+    });
+    return step;
+}
+/** Is the sample clear of `step` by the exit margins (so the dial may turn down from it)? */
+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);
+}
 /**
- * One step. `gentle` (vGPU on): compilers start below normal even without pressure. Programs go back to their normal
- * priority only when pressure ends (several calm samples in a row).
+ * One step of the governor. The dial turns up at once and down one step at a time after calm samples. `gentle` (vGPU
+ * on): compilers rest below normal priority, and `maxCompilers` caps how many heavy compilers run at any step.
  */
-export function decide(prev, sample, nowMs, thresholds, profile) {
+export function decide(prev, sample, nowMs, profile, maxCompilers = 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) / 1000;
+    const instant = prev.lastAt > 0 && seconds > 0 ? (usedMb - prev.lastCommitMb) / seconds : 0;
+    // Smoothed over the last samples, so one burst between two samples is not read as a trend.
+    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 wanted = Math.max(stepFor(ramFree, commit, secondsToLimit, profile), pcLow ? prev.hostStep : 0);
+    let step = prev.step;
+    let calm = 0;
+    if (wanted > prev.step)
+        step = wanted;
+    else if (prev.step > 0 && wanted < 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 present = new Set(sample.procs.map((p) => p.pid));
+    const keep = (pids) => pids.filter((pid) => present.has(pid));
     const lowered = {};
     for (const [pid, to] of Object.entries(prev.lowered))
         if (present.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;
-            // Already as low as asked (or lower): only remember it.
-            if (p.prio !== target && !(target === 'below' && p.prio === 'idle'))
-                actions.push({ kind: 'priority', pid: p.pid, name: p.name, to: target });
+    const memLow = new Set(keep(prev.memLow));
+    const throttled = new Set(keep(prev.throttled));
+    const trimmed = new Set(keep(prev.trimmed));
+    // CPU priority: where a program rests (normal; compilers below in the gentle profile), below from step 1, idle
+    // from step 2. Only changes are sent.
+    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 !== undefined || 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;
-        }
     }
-    else {
-        for (const p of sample.procs) {
-            if (!canLower(p.name))
-                continue;
-            // Where a program rests when nothing is wrong: compilers below normal in the gentle profile.
-            const base = profile === 'gentle' && canPause(p.name) ? 'below' : 'normal';
-            const was = lowered[p.pid];
-            if (prev.pressure && was !== undefined && 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;
+    // Memory priority: low from step 1, so Windows trims the builds' pages before the agents'.
+    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);
+    }
+    // CPU share of the compilers: they join the throttle job once (from step 2); its cap follows the dial.
+    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);
             }
-            else if (!prev.pressure && base === 'below' && was === undefined) {
-                if (p.prio === 'normal')
-                    actions.push({ kind: 'priority', pid: p.pid, name: p.name, to: 'below' });
-                lowered[p.pid] = 'below';
+    const cpuRate = DIAL_CPU_RATE[step] ?? 100;
+    if (cpuRate !== prev.cpuRate)
+        actions.push({ kind: 'cpu', percent: cpuRate });
+    // Turns: of the heavy compilers only so many go on; the rest wait, and who waits changes every ROTATE_MS.
+    const heavy = sample.procs.filter((p) => isHeavyCompiler(p.name)).sort((a, b) => a.pid - b.pid);
+    let allowed = compilersAllowed(step, heavy.length);
+    // The cap is a memory measure: with memory to spare, Windows shares the CPU (the priorities above) and no compiler
+    // waits. A waiting rustc also holds cargo's job tokens, which stalls the whole build.
+    if (maxCompilers !== null && step >= 2)
+        allowed = Math.min(allowed, Math.max(1, maxCompilers));
+    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);
     }
-    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;
-        }
-    }
-    const level = nowMs < pausedUntil ? 'suspending' : pressure ? 'throttled' : 'ok';
+    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),

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

@@ -1,42 +1,9 @@
-import type { PressureStatus } from '../../shared/channel/schema.js';
-import { type LoadProfile } from '../../shared/memory/index.js';
-import { type GovernorState, type MemSample } from './decide.js';
-/** What the governor needs from Windows (injectable: the tests use a fake). */
-export interface GovernorPort {
-    setPriority(pid: number, to: 'idle' | 'below' | 'normal'): void;
-    pause(pid: number, ms: number): void;
-}
-/** Everything a step changes outside the decision, behind injectable functions. */
-export interface GovernorDeps {
-    readonly port: GovernorPort;
-    readonly profile: LoadProfile;
-    readonly now: () => number;
-    /** A line in the memory log. */
-    readonly logLine: (line: string) => void;
-    /** run\pressure.json. */
-    readonly saveStatus: (status: PressureStatus) => void;
-}
-/** The governor's logic over a port: feed it samples; the host's "slow down" requests go to hostPressure. */
-export declare class GovernorCore {
-    private readonly deps;
-    private state;
-    private lastAction;
-    private lastWrite;
-    private lastWriteAt;
-    private pausedName;
-    private pausedPid;
-    constructor(deps: GovernorDeps);
-    hostPressure(seconds: number, reason: string): void;
-    get current(): GovernorState;
-    onSample(sample: MemSample): void;
-    private apply;
-}
 /** The daemon's governor: on unless sandbox.pressureResponse is off. */
 export declare class Governor {
     private core;
     describe(): string;
     start(): void;
-    /** The host's watchdog: this PC is low for a while. */
-    hostPressure(seconds: number, reason: string): void;
+    /** The host's watchdog: this PC is low (or nearly out of memory) for a while. */
+    hostPressure(seconds: number, reason: string, level?: 'slow' | 'severe'): void;
 }
 export declare const governor: Governor;

package/dist/guest/governor/governor.js

@@ -1,21 +1,21 @@
-// The memory governor: samples the sandbox's memory every 2 seconds (memgov.exe, sandbox/csharp/MemGov.cs) and, when it
-// runs low, slows the heaviest build programs the agents started down and, as a last resort, pauses the biggest
-// compiler for a few seconds (decide.ts). What it does goes to the memory log and run\pressure.json, for the host.
+// The memory governor: samples the sandbox's memory every 2 seconds (memgov.exe, sandbox/csharp/MemGov.cs) and turns
+// a dial as it fills: the build programs the agents started get lower priority, lower memory priority, less CPU, and
+// take turns (decide.ts). Builds slow down; nothing fails. What it does goes to the memory log and run\pressure.json.
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { z } from 'zod';
-import { now } from '../../shared/channel/run-dir.js';
 import { writeJsonAtomic } from '../../shared/io/json.js';
-import { GUEST_THRESHOLDS } from '../../shared/memory/index.js';
+import { DIAL_STEPS, maxCompilers } from '../../shared/memory/index.js';
 import { ensureCompiled } from '../runtime/csc.js';
 import { dataDir } from '../runtime/paths.js';
 import { warn } from '../runtime/log.js';
 import { run } from '../runtime/paths.js';
 import { session } from '../runtime/session.js';
 import { errMsg } from '../../core/util/errors.js';
-import { decide, INITIAL_STATE } from './decide.js';
+import { GovernorCore } from './core.js';
 const SampleSchema = z.object({
     ramTotalMb: z.number(),
     ramAvailMb: z.number(),
@@ -30,87 +30,6 @@ const SampleSchema = z.object({
     }))
         .max(1024),
 });
-/** The governor's logic over a port: feed it samples; the host's "slow down" requests go to hostPressure. */
-export class GovernorCore {
-    deps;
-    state = INITIAL_STATE;
-    lastAction = '';
-    lastWrite = '';
-    lastWriteAt = 0;
-    pausedName = '';
-    pausedPid = 0;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    hostPressure(seconds, reason) {
-        const until = this.deps.now() + seconds * 1000;
-        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 };
-        }
-    }
-    get current() {
-        return this.state;
-    }
-    onSample(sample) {
-        const nowMs = this.deps.now();
-        const before = this.state.pressure;
-        const d = decide(this.state, sample, nowMs, GUEST_THRESHOLDS[this.deps.profile], this.deps.profile);
-        this.state = d.state;
-        for (const action of d.actions)
-            this.apply(action);
-        if (d.state.pressure !== 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');
-        const paused = nowMs < d.state.pausedUntil && this.pausedPid
-            ? [{ name: this.pausedName, pid: this.pausedPid, seconds: Math.ceil((d.state.pausedUntil - nowMs) / 1000) }]
-            : [];
-        const status = {
-            level: d.level,
-            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,
-            pcLow: nowMs < d.state.hostUntil,
-            lastAction: this.lastAction,
-            updatedAt: now(),
-        };
-        // Written when something changed, else once a minute (the host reads it, never polls it hard).
-        const shape = JSON.stringify({ ...status, updatedAt: '', paused: paused.map((p) => p.pid) });
-        if (shape !== this.lastWrite || nowMs - this.lastWriteAt > 60000) {
-            this.lastWrite = shape;
-            this.lastWriteAt = nowMs;
-            this.deps.saveStatus(status);
-        }
-    }
-    apply(action) {
-        try {
-            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 / 1000 + ' s';
-                this.deps.logLine('governor: ' + this.lastAction);
-                return;
-            }
-            this.deps.logLine('governor: ' + this.lastAction);
-        }
-        catch (e) {
-            warn('governor: ' + errMsg(e));
-        }
-    }
-}
 /** memgov.exe as a child process: samples come out of its stdout, commands go into its stdin. */
 class MemGovProcess {
     onSample;
@@ -145,10 +64,25 @@ class MemGovProcess {
         }
     }
     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');
     }
 }
 /** The newest memory log SandboxTools writes, to add the governor's lines to it. */
@@ -175,15 +109,15 @@ export class Governor {
     core = null;
     describe() {
         const profile = session.loadProfile === 'gentle' ? 'gentle' : 'normal';
-        const t = GUEST_THRESHOLDS[profile];
+        const first = DIAL_STEPS[profile][0];
         return session.pressureResponse === false
             ? 'off (sandbox.pressureResponse)'
             : profile +
-                ' profile: slows builds down below ' +
-                t.enterAvailablePercent +
-                '% free RAM or above ' +
-                t.enterCommitPercent +
-                '% commit';
+                ' profile: slows builds down from ' +
+                first.availablePercent +
+                '% free RAM or ' +
+                first.commitPercent +
+                '% commit, in steps';
     }
     start() {
         if (session.pressureResponse === false)
@@ -193,8 +127,10 @@ export class Governor {
         this.core = new GovernorCore({
             port: proc,
             profile,
+            maxCompilers: maxCompilers(os.cpus().length, profile),
             now: () => Date.now(),
             logLine: appendToMemoryLog,
+            warn,
             saveStatus: (status) => {
                 try {
                     writeJsonAtomic(run.pressureFile, status);
@@ -206,9 +142,9 @@ export class Governor {
         });
         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);
     }
 }
 export const governor = new Governor();

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

@@ -1,2 +1,3 @@
 export * from './decide.js';
+export * from './core.js';
 export * from './governor.js';

package/dist/guest/governor/index.js

@@ -1,2 +1,3 @@
 export * from './decide.js';
+export * from './core.js';
 export * from './governor.js';

package/dist/guest/network/firewall.d.ts

@@ -1,5 +1,8 @@
 /** What the agent's manifest says about the LAN. */
 export type LanState = 'blocked' | 'open' | 'offline';
+export declare function networkProblems(): readonly string[];
+/** netsh needs the long form of a path: the sandbox's TEMP is an 8.3 short path (WDAGUT~1). */
+export declare function longPath(file: string): string;
 export declare function run(commands: string[][]): void;
 /**
  * Applies the LAN block. Internet is checked first; if it works before the rules but not after, the rules (not the

package/dist/guest/network/firewall.js

@@ -4,14 +4,13 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { relayPort, withBlockedHosts } from '../../shared/network/policy.js';
-import { buildFirewallCommands, ipv4DnsServers, isIPv4, parseDefaultGateways, parseDnsServers, } from '../../shared/network/firewall-rules.js';
+import { attachRuleCommands, buildFirewallCommands, hasShortName, ipv4DnsServers, isIPv4, parseDefaultGateways, parseDnsServers, } from '../../shared/network/firewall-rules.js';
 import { SYSTEM } from '../../shared/system.js';
 import { scriptArgs } from '../../shared/scripts.js';
 import { dryRun, isWin } from '../runtime/paths.js';
 import { log, warn } from '../runtime/log.js';
 import { session } from '../runtime/session.js';
 import { errMsg } from '../../core/util/errors.js';
-const ATTACH_RULE = 'AgentSandbox-Attach';
 const netsh = (args) => {
     const r = spawnSync(SYSTEM.netsh(), args, { encoding: 'utf8', windowsHide: true });
     return { status: r.status, out: (r.stdout ?? '') + (r.stderr ?? '') };
@@ -51,24 +50,49 @@ const waitForInternet = async (seconds) => {
     }
     return false;
 };
-/** Inbound rule for ptyhost only, and only from the sandbox's own subnet (where the host's Hyper-V adapter is). */
-const attachRule = (ptyHostExe) => [
-    ['advfirewall', 'firewall', 'delete', 'rule', 'name=' + ATTACH_RULE],
-    [
-        'advfirewall',
-        'firewall',
-        'add',
-        'rule',
-        'name=' + ATTACH_RULE,
-        'dir=in',
-        'action=allow',
-        'enable=yes',
-        'profile=any',
-        'protocol=tcp',
-        'remoteip=LocalSubnet',
-        'program=' + ptyHostExe,
-    ],
-];
+/** Protections that could not be put in place this boot (shown in the boot summary and the log, never silent). */
+const problems = [];
+export function networkProblems() {
+    return problems;
+}
+/** netsh needs the long form of a path: the sandbox's TEMP is an 8.3 short path (WDAGUT~1). */
+export function longPath(file) {
+    if (!hasShortName(file))
+        return file;
+    try {
+        return fs.realpathSync.native(file);
+    }
+    catch {
+        return file; // netsh then says the program cannot be found, which is reported where the rule was wanted
+    }
+}
+/**
+ * The inbound rule for ptyhost (the attach channel). A rule that cannot be added is a missing protection, so it is
+ * tried again a few times and then reported loudly instead of being skipped.
+ */
+async function applyAttachRule(ptyHostExe) {
+    if (!session.attach.enabled)
+        return;
+    if (!ptyHostExe) {
+        problems.push('attach: the session host was not built, so the firewall rule for it was not created');
+        warn(problems[problems.length - 1]);
+        return;
+    }
+    let last = '';
+    for (let attempt = 1; attempt <= 3; attempt++) {
+        try {
+            run(attachRuleCommands(longPath(ptyHostExe)));
+            return;
+        }
+        catch (e) {
+            last = errMsg(e);
+            if (attempt < 3)
+                await new Promise((r) => setTimeout(r, 1000));
+        }
+    }
+    problems.push('attach: the firewall rule for the session host could not be created (' + last + ')');
+    warn('PROTECTION MISSING: ' + problems[problems.length - 1]);
+}
 export function run(commands) {
     for (const c of commands) {
         const r = netsh(c);
@@ -89,10 +113,11 @@ export async function applyNetworkPolicy(ptyHostExe) {
     const block = session.network.blockPrivateRanges;
     const exempt = block ? discoverExemptIps() : [];
     const lanRules = block ? buildFirewallCommands(exempt) : [];
+    const forwardRules = forwardRule();
     const commands = [
         ...lanRules,
-        ...(ptyHostExe && session.attach.enabled ? attachRule(ptyHostExe) : []),
-        ...forwardRule(),
+        ...(ptyHostExe && session.attach.enabled ? attachRuleCommands(ptyHostExe) : []),
+        ...forwardRules,
     ];
     if (isWin && !dryRun) {
         try {
@@ -122,7 +147,24 @@ export async function applyNetworkPolicy(ptyHostExe) {
     if (commands.length === 0)
         return 'open';
     const online = block ? await waitForInternet(30) : true;
-    run(commands);
+    // Each group on its own: one failing must not skip the others (or the internet check below).
+    const failures = [];
+    try {
+        run(lanRules);
+    }
+    catch (e) {
+        failures.push(errMsg(e));
+    }
+    await applyAttachRule(ptyHostExe);
+    try {
+        run(forwardRules);
+    }
+    catch (e) {
+        problems.push('forwardPorts: the firewall rule for the relays could not be created (' + errMsg(e) + ')');
+        warn('PROTECTION MISSING: ' + problems[problems.length - 1]);
+    }
+    if (failures.length)
+        throw new Error(failures[0]);
     if (!block)
         return 'open';
     if (online && !(await waitForInternet(15))) {