windows-development-sandbox 1.9.0 → 1.10.0

package/config.example.json

@@ -222,7 +222,8 @@
   },
   "web": {
     "enabled": false,
-    "port": 47800
+    "port": 47800,
+    "openOnLaunch": false
   },
   "agentCommands": {
     "enabled": false,

package/dist/cli/commands/launch/launch.js

@@ -29,6 +29,7 @@ import { packageVersion } from '../../../core/package-info.js';
 import { reopenedText, reopenSessions } from '../sessions/reopen.js';
 import { sessionsToResume } from './resume-offer.js';
 import { startIntoRunning, launchIntoRunning, contextFor, waitForBoot, attachHere, waitForStart, openSession, readySandbox, } from './running.js';
+import { startWebOnLaunch } from '../web.js';
 import { maybeAddRoot } from './add-root.js';
 import { prepare, firstBootNotice } from './prepare.js';
 import { bootWantsFor } from './boot-wants.js';
@@ -202,6 +203,7 @@ class Launcher {
         this.share(generated);
         await engine.start(generated.enginePlan);
         this.startWatcher();
+        await startWebOnLaunch(this.ctx);
         if (reopen.length)
             await this.reopenAfterBoot(generated.launchId, reopen);
         return this.afterStart(run, generated);

package/dist/cli/commands/vpn.js

@@ -12,6 +12,7 @@ const LOGIN_TEXT = {
 };
 /** The warnings every VPN user must see. */
 export const VPN_WARNINGS = [
+    'The VPN is an alpha: not yet tried on a real PC (docs/vpn.md lists what still needs checking).',
     'The agent in the sandbox can read the VPN login (a service login you can revoke) and can turn the tunnel off, because it is the administrator there.',
     'Free VPNs see all your traffic: use one you trust.',
 ];

package/dist/cli/commands/web.d.ts

@@ -1,4 +1,9 @@
 import { type Context } from './context.js';
+/**
+ * At a sandbox start, with web.enabled: the web UI is started in the background when it is not running, and with
+ * web.openOnLaunch opened in the browser, signed in. Never stops the launch: a problem is one line.
+ */
+export declare function startWebOnLaunch(ctx: Context): Promise<void>;
 export declare function web(ctx: Context): Promise<number>;
 /** Body of the background process (`sandbox _web`): runs until stopped. */
 export declare function webServer(ctx: Context): Promise<void>;

package/dist/cli/commands/web.js

@@ -37,6 +37,44 @@ async function startServer(ctx, control) {
     }
     return fail('The web UI did not start.', 'Run sandbox _web to see why (the port ' + config.web.port + ' may be taken: change web.port).');
 }
+/**
+ * At a sandbox start, with web.enabled: the web UI is started in the background when it is not running, and with
+ * web.openOnLaunch opened in the browser, signed in. Never stops the launch: a problem is one line.
+ */
+export async function startWebOnLaunch(ctx) {
+    const { web: settings } = ctx.loaded.config;
+    if (!settings.enabled)
+        return;
+    try {
+        const control = controlOf(ctx);
+        const before = await control.status();
+        let state = before.running ? before.state : null;
+        if (!state) {
+            if (before.state)
+                control.clear();
+            const configFile = ctx.options.config;
+            spawnDetached(ctx.entry, ['_web', ...(configFile ? ['--config', path.resolve(configFile)] : [])]);
+            for (const started = Date.now(); !state && Date.now() - started < START_WAIT_MS; await sleep(300)) {
+                const now = await control.status();
+                if (now.running && now.state)
+                    state = now.state;
+            }
+        }
+        if (!state) {
+            console.log('The web UI did not start (port ' + settings.port + ' may be taken: change web.port). Try: sandbox web start');
+            return;
+        }
+        if (settings.openOnLaunch) {
+            openBrowser(control.url(state));
+            console.log('The web UI is open in your browser (http://127.0.0.1:' + state.port + '/).');
+        }
+        else
+            console.log('The web UI is at http://127.0.0.1:' + state.port + '/ (open it signed in with: sandbox web open).');
+    }
+    catch (e) {
+        console.log('The web UI could not be started: ' + (e instanceof Error ? e.message : String(e)));
+    }
+}
 export async function web(ctx) {
     requireOnPc('web');
     const action = ctx.options.positionals[0] ?? 'status';

package/dist/core/config/defaults.js

@@ -94,7 +94,7 @@ export const DEFAULTS = {
         sqlserver: { enabled: 'auto' },
     },
     attach: { enabled: true, reuseSession: true, auto: false, autoHide: false },
-    web: { enabled: false, port: 47800 },
+    web: { enabled: false, port: 47800, openOnLaunch: false },
     agentCommands: { enabled: false, agents: 'auto' },
     secrets: { strip: true, allow: [], patterns: [], warnFiles: true },
     personalization: { enabled: true },

package/dist/core/schema/config.d.ts

@@ -247,6 +247,7 @@ export declare const ConfigSchema: z.ZodObject<{
     web: z.ZodObject<{
         enabled: z.ZodBoolean;
         port: z.ZodNumber;
+        openOnLaunch: z.ZodBoolean;
     }, z.core.$strict>;
     agentCommands: z.ZodObject<{
         enabled: z.ZodBoolean;

package/dist/core/schema/vpn.js

@@ -4,7 +4,7 @@ export const VPN_PROVIDERS = ['nordvpn', 'openvpn-file', 'wireguard-file'];
 export const VpnSchema = z.strictObject({
     enabled: z
         .boolean()
-        .describe("Send the sandbox's traffic through a VPN. Only the sandbox: your PC's own connection is untouched. Needs a saved login first (sandbox vpn login). The agent in the sandbox can read that login and can turn the tunnel off (it is the administrator there)."),
+        .describe("(Alpha: not yet tried on a real PC) Send the sandbox's traffic through a VPN. Only the sandbox: your PC's own connection is untouched. Needs a saved login first (sandbox vpn login). The agent in the sandbox can read that login and can turn the tunnel off (it is the administrator there)."),
     provider: z
         .enum(VPN_PROVIDERS)
         .describe('nordvpn: a recommended NordVPN server is picked at every launch. openvpn-file: your own .ovpn file (configFile). wireguard-file: your own WireGuard .conf (configFile), e.g. from your company.'),

package/dist/core/schema/web.d.ts

@@ -3,4 +3,5 @@ export declare const WEB_DEFAULT_PORT = 47800;
 export declare const WebSchema: z.ZodObject<{
     enabled: z.ZodBoolean;
     port: z.ZodNumber;
+    openOnLaunch: z.ZodBoolean;
 }, z.core.$strict>;

package/dist/core/schema/web.js

@@ -4,11 +4,14 @@ export const WEB_DEFAULT_PORT = 47800;
 export const WebSchema = z.strictObject({
     enabled: z
         .boolean()
-        .describe('(Beta) Allow the web UI: your sandbox sessions in a browser on this PC. Off by default, and nothing starts it by itself yet: sandbox web start works either way and runs it until sandbox web stop (or a restart of the PC).'),
+        .describe('(Beta) The web UI: your sandbox sessions in a browser on this PC (http://127.0.0.1:<port>, this PC only). On: every sandbox start also starts it in the background (it keeps running until sandbox web stop or a restart of the PC). Off: only sandbox web start runs it. Open it signed in with sandbox web open.'),
     port: z
         .number()
         .int()
         .min(1024)
         .max(65535)
         .describe('Port of the web UI on 127.0.0.1 (this PC only). Pick another when it is taken.'),
+    openOnLaunch: z
+        .boolean()
+        .describe('(Beta) With the web UI on: open it in your browser, already signed in, every time a sandbox starts.'),
 });

package/dist/guest/boot/boot.js

@@ -14,7 +14,7 @@ import { syncClaudeProfile } from '../setup/claude-profile.js';
 import { agentEnv, persistEnvironment } from '../setup/environment.js';
 import { runHooks } from '../setup/hooks.js';
 import { applyAllowOnly, proxyEnv } from '../network/allow-only.js';
-import { applyNetworkPolicy } from '../network/firewall.js';
+import { applyNetworkPolicy, networkProblems } from '../network/firewall.js';
 import { writeManagedSettings } from '../setup/managed-policy.js';
 import { applyPersonalization } from '../setup/desktop.js';
 import { setupGitConfig } from '../setup/git-identity.js';
@@ -175,6 +175,8 @@ export class Boot {
             databases: session.databases ?? [],
             apps: session.apps,
         });
+        for (const p of networkProblems())
+            tools.summary.push('PROTECTION MISSING: ' + p);
         if (!dryRun)
             tools.prepend.push(writeDbCommand());
         // network.allowOnly / network.proxy: everything started from now on uses the proxy.

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

@@ -17,6 +17,7 @@ export interface MemSample {
 }
 export declare const isNeverTouched: (name: string) => boolean;
 export declare const canLower: (name: string) => boolean;
+export declare const isHeavyCompiler: (name: string) => boolean;
 export declare const canPause: (name: string) => boolean;
 export type Level = 'ok' | 'throttled' | 'suspending';
 export interface GovernorState {
@@ -45,7 +46,16 @@ export type Action = {
     readonly pid: number;
     readonly name: string;
     readonly ms: number;
+}
+/** Waits (suspended) because more compilers run than the cap allows; repeated while it is over, never killed. */
+ | {
+    readonly kind: 'hold';
+    readonly pid: number;
+    readonly name: string;
+    readonly ms: number;
 };
+/** How long a held compiler waits before it gets a turn again (the governor repeats the hold while over the cap). */
+export declare const HOLD_MS = 3000;
 export interface Decision {
     readonly state: GovernorState;
     readonly actions: readonly Action[];
@@ -58,4 +68,4 @@ export declare const PAUSE_MS = 5000;
  * 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).
  */
-export declare function decide(prev: GovernorState, sample: MemSample, nowMs: number, thresholds: GuestThresholds, profile: LoadProfile): Decision;
+export declare function decide(prev: GovernorState, sample: MemSample, nowMs: number, thresholds: GuestThresholds, profile: LoadProfile, maxCompilers?: number | null): Decision;

package/dist/guest/governor/decide.js

@@ -77,6 +77,24 @@ 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,
@@ -87,6 +105,8 @@ export const INITIAL_STATE = {
     nextPauseAt: 0,
     hostUntil: 0,
 };
+/** How long a held compiler waits before it gets a turn again (the governor repeats the hold while over the cap). */
+export const HOLD_MS = 3000;
 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. */
@@ -98,7 +118,7 @@ const PAUSE_MIN_MB = 300;
  * 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).
  */
-export function decide(prev, sample, nowMs, thresholds, profile) {
+export function decide(prev, sample, nowMs, thresholds, 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 pcLow = nowMs < prev.hostUntil;
@@ -171,6 +191,15 @@ export function decide(prev, sample, nowMs, thresholds, profile) {
             nextPauseAt = pausedUntil + PAUSE_COOLDOWN_MS;
         }
     }
+    // Concurrency cap (vGPU profile): the oldest N heavy compilers run, the newer ones wait a few seconds at a time.
+    if (maxCompilers !== 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, maxCompilers)))
+            actions.push({ kind: 'hold', pid: p.pid, name: p.name, ms: HOLD_MS });
+    }
     const level = nowMs < pausedUntil ? 'suspending' : pressure ? 'throttled' : 'ok';
     return {
         state: { pressure, calm, samples, lowered, pausedUntil, nextPauseAt, hostUntil: prev.hostUntil },

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

@@ -10,6 +10,8 @@ export interface GovernorPort {
 export interface GovernorDeps {
     readonly port: GovernorPort;
     readonly profile: LoadProfile;
+    /** At most this many heavy compilers run at once (null = no cap). */
+    readonly maxCompilers?: number | null;
     readonly now: () => number;
     /** A line in the memory log. */
     readonly logLine: (line: string) => void;
@@ -25,6 +27,7 @@ export declare class GovernorCore {
     private lastWriteAt;
     private pausedName;
     private pausedPid;
+    private held;
     constructor(deps: GovernorDeps);
     hostPressure(seconds: number, reason: string): void;
     get current(): GovernorState;

package/dist/guest/governor/governor.js

@@ -2,13 +2,14 @@
 // 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.
 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 { GUEST_THRESHOLDS, maxCompilers } from '../../shared/memory/index.js';
 import { ensureCompiled } from '../runtime/csc.js';
 import { dataDir } from '../runtime/paths.js';
 import { warn } from '../runtime/log.js';
@@ -39,6 +40,7 @@ export class GovernorCore {
     lastWriteAt = 0;
     pausedName = '';
     pausedPid = 0;
+    held = new Set();
     constructor(deps) {
         this.deps = deps;
     }
@@ -56,7 +58,11 @@ export class GovernorCore {
     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);
+        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);
         this.state = d.state;
         for (const action of d.actions)
             this.apply(action);
@@ -92,6 +98,15 @@ export class GovernorCore {
     }
     apply(action) {
         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;
@@ -193,6 +208,7 @@ export class Governor {
         this.core = new GovernorCore({
             port: proc,
             profile,
+            maxCompilers: maxCompilers(os.cpus().length, profile),
             now: () => Date.now(),
             logLine: appendToMemoryLog,
             saveStatus: (status) => {

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

@@ -1,5 +1,6 @@
 /** What the agent's manifest says about the LAN. */
 export type LanState = 'blocked' | 'open' | 'offline';
+export declare function networkProblems(): readonly 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). */
+const longPath = (file) => {
+    if (!hasShortName(file))
+        return file;
+    try {
+        return fs.realpathSync.native(file);
+    }
+    catch {
+        return file;
+    }
+};
+/**
+ * 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))) {

package/dist/guest/runtime/process.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { moveIntoPlace, spawnAsync, stagingFolder } from '../../shared/download/index.js';
 import { safeRemove } from '../../shared/io/safe-remove.js';
+import { robocopyErrors, robocopyFailed, robocopyMeaning } from '../../shared/io/robocopy-result.js';
 import { SYSTEM } from '../../shared/system.js';
 import { scriptArgs } from '../../shared/scripts.js';
 import { isWin } from './paths.js';
@@ -27,7 +28,18 @@ export function execOutput(file, args, options = {}) {
 }
 /** Runs sandbox\scripts\<name> (a .ps1 in the launch folder) with `args`; throws when it fails. */
 export function runScript(name, args = []) {
-    exec(SYSTEM.powershell(), scriptArgs(name, args));
+    const result = spawnSync(SYSTEM.powershell(), scriptArgs(name, args), {
+        stdio: ['inherit', 'inherit', 'pipe'],
+        encoding: 'utf8',
+        windowsHide: true,
+    });
+    if (result.error)
+        throw result.error;
+    const errors = String(result.stderr ?? '').trim();
+    if (errors)
+        process.stderr.write(errors + '\n');
+    if (result.status !== 0)
+        throw new Error(name + ' failed with exit code ' + result.status + (errors ? ': ' + errors.slice(0, 400) : ''));
 }
 /** runScript for what it prints ('' when it fails). */
 export function scriptOutput(name, args = [], options = {}) {
@@ -59,10 +71,46 @@ export function robocopy(from, to, files = []) {
             fs.copyFileSync(path.join(from, f), path.join(to, f));
         return;
     }
-    const what = files.length ? files : ['/E', '/MT:16'];
-    const result = spawnSync(SYSTEM.robocopy(), [from, to, ...what, '/NFL', '/NDL', '/NJH', '/NJS', '/NP', '/R:1', '/W:1', '/XJ'], { stdio: 'ignore', windowsHide: true });
-    if ((result.status ?? 16) >= 8)
-        throw new Error('robocopy ' + from + ' -> ' + to + ' failed (exit ' + result.status + ')');
+    const what = files.length ? files : ['/E'];
+    // A second pass for what the first could not copy (a file another program holds open for a moment, a busy mapped
+    // folder): one thread and more patience; robocopy skips what is already in place.
+    const passes = [
+        ['/MT:16', '/R:1', '/W:1'],
+        ['/MT:1', '/R:4', '/W:3'],
+    ];
+    let code = null;
+    let output = '';
+    for (const pass of passes) {
+        const result = spawnSync(SYSTEM.robocopy(), [
+            from,
+            to,
+            ...what,
+            ...(files.length ? [] : [pass[0]]),
+            pass[1],
+            pass[2],
+            '/NFL',
+            '/NDL',
+            '/NJH',
+            '/NJS',
+            '/NP',
+            '/XJ',
+        ], { encoding: 'utf8', windowsHide: true });
+        code = result.status;
+        output = String(result.stdout ?? '') + String(result.stderr ?? '');
+        if (!robocopyFailed(code))
+            return;
+    }
+    const why = robocopyErrors(output);
+    throw new Error('robocopy ' +
+        from +
+        ' -> ' +
+        to +
+        ' failed (exit ' +
+        code +
+        ': ' +
+        robocopyMeaning(code) +
+        ')' +
+        (why.length ? ': ' + why.join(' | ') : ''));
 }
 /**
  * A Node install without its global packages (nvm keeps those per version: often tens of thousands of small files,

package/dist/guest/setup/claude-mem.js

@@ -6,6 +6,7 @@ import { dryRun } from '../runtime/paths.js';
 import { exists, mkdirp } from '../runtime/fs.js';
 import { log, warn } from '../runtime/log.js';
 import { robocopy } from '../runtime/process.js';
+import { copyTreeTolerant } from '../../shared/io/copy-tree.js';
 /**
  * claude-mem keeps SQLite + a vector store. They run from the sandbox's own disk (SQLite and mapped folders do not
  * mix) and are mirrored to persistent storage, from where the host syncs them back to your PC.
@@ -49,8 +50,13 @@ const databaseFingerprint = (dir) => {
             if (entry.isDirectory())
                 walk(full);
             else if (entry.isFile() && /\.(db|sqlite3?)(-wal)?$/i.test(entry.name)) {
-                const s = fs.statSync(full);
-                parts.push(full + ':' + s.size + ':' + s.mtimeMs);
+                try {
+                    const s = fs.statSync(full);
+                    parts.push(full + ':' + s.size + ':' + s.mtimeMs);
+                }
+                catch {
+                    // Gone since the listing (a database being replaced): left out, the next save looks again.
+                }
             }
         }
     };
@@ -116,8 +122,10 @@ export function saveClaudeMem() {
     const incoming = store + '.incoming';
     const previous = store + '.previous';
     fs.rmSync(incoming, { recursive: true, force: true });
-    // The database, its -wal and -shm files are copied together, so the copy is consistent with itself.
-    fs.cpSync(local, incoming, { recursive: true, filter: (src) => !/\.(pid|lock)$/i.test(src) });
+    // The database and its -wal are copied together, so the copy is consistent with itself. A -journal is never copied:
+    // beside a database taken at another moment it would be rolled back over it. The -shm is rebuilt by SQLite. Files the
+    // agent removes while this runs (hook spool files) are skipped.
+    copyTreeTolerant(local, incoming, (name) => /\.(pid|lock)$|-journal$|-shm$/i.test(name));
     // Swap without a window where no copy exists: old aside, new in, then keep the old one as a dated backup.
     fs.rmSync(previous, { recursive: true, force: true });
     if (exists(store))

package/dist/guest/toolchains/languages/node.js

@@ -14,6 +14,7 @@ import { arch, tool } from '../tool-env.js';
 import { installOnce } from '../package-ledger.js';
 import { resolveCached } from '../version-cache.js';
 import { duringSession } from '../../runtime/project-context.js';
+import { session } from '../../runtime/session.js';
 import { pickNodeVersion, pickSpreadVersions } from '../../../core/detect/versions.js';
 const NVM_HOME = tool('nvm');
 const NVM_SYMLINK = path.join(localDir, 'nodejs');
@@ -73,7 +74,14 @@ const ensureNvm = async () => {
     log('Downloading nvm-windows (' + asset.url.split('/').slice(-2, -1)[0] + ') ...');
     await downloader.archive(asset.url, NVM_HOME, { sha256: asset.sha256, locate: 'nvm.exe', fileName: asset.name });
 };
-/** A Node version: from the host's nvm when it has it (fast, offline), else `nvm install`. */
+/** This PC's own Node folder (mapped read-only), when it is exactly this version. */
+const hostNodeFolder = (version) => {
+    const dir = path.join(hostToolsDir, 'node');
+    return session.hostTools.nodeVersion?.replace(/^v/, '') === version && exists(path.join(dir, 'node.exe'))
+        ? dir
+        : null;
+};
+/** A Node version: from the host's nvm or Node when it has it (fast, offline), else `nvm install`. */
 const installNodeVersion = async (version) => {
     const dir = path.join(NVM_HOME, 'v' + version);
     const fromHost = path.join(HOST_NVM, 'v' + version);
@@ -84,6 +92,12 @@ const installNodeVersion = async (version) => {
         copyNode(fromHost, dir);
         return;
     }
+    const hostNode = hostNodeFolder(version);
+    if (hostNode) {
+        log('Copying Node ' + version + ' from this PC (without global packages) ...');
+        copyNode(hostNode, dir);
+        return;
+    }
     log('Downloading Node ' + version + ' (~30 MB once) ...');
     mkdirp(NVM_TEMP);
     let out;
@@ -93,8 +107,20 @@ const installNodeVersion = async (version) => {
     finally {
         safeRemove(NVM_TEMP, NVM_HOME);
     }
-    if (!exists(path.join(dir, 'node.exe')))
-        throw new Error('nvm install ' + version + ' failed: ' + out.trim().split('\n').slice(-2).join(' '));
+    if (!exists(path.join(dir, 'node.exe'))) {
+        const tail = out.trim().split(/\r?\n/).filter(Boolean).slice(-3).join(' ');
+        const why = /complete/i.test(out)
+            ? 'nvm said it finished, but its move into the data folder did not happen'
+            : 'nvm could not download or unpack it: check the internet connection and the free disk space';
+        throw new Error('nvm install ' +
+            version +
+            ' did not leave ' +
+            path.join(dir, 'node.exe') +
+            ' (' +
+            why +
+            ')' +
+            (tail ? '. nvm printed: ' + tail : ''));
+    }
 };
 const activate = async (version) => {
     await nvm(['use', version]);