windows-development-sandbox 1.4.1 → 1.4.3

package/dist/sync/sync-state.js

@@ -0,0 +1,37 @@
+import path from 'node:path';
+import { z } from 'zod';
+import { JsonFile } from '../shared/io/index.js';
+import { hostStateFile, storageOf } from '../host/storage/index.js';
+/** Host-only record of the last launch: which folders map to each other and what syncs (from the effective config). */
+const AbsolutePathSchema = z
+    .string()
+    .max(1024)
+    .refine((p) => path.isAbsolute(p), 'must be an absolute path');
+const SyncStateSchema = z.object({
+    hostClaudeDir: AbsolutePathSchema,
+    hostWorkspace: AbsolutePathSchema,
+    guestWorkspace: z.string().max(1024),
+    syncHistory: z.boolean().optional(),
+    syncClaudeMem: z.boolean().optional(),
+    syncClaudeMemBack: z.boolean().optional(),
+    historyScope: z.enum(['project', 'all']).optional(),
+    /** Newest claude-mem database time on each side right after the last sync (detects edits on both sides). */
+    memHostStamp: z.number().optional(),
+    memGuestStamp: z.number().optional(),
+    /** Projects registered while the sandbox ran (their history goes back to their own folders). */
+    projects: z
+        .array(z.object({ hostWorkspace: AbsolutePathSchema, guestWorkspace: z.string().max(1024) }))
+        .max(256)
+        .optional(),
+});
+/**
+ * Host-only: <storage>\sync\<dataName>.json. It records which folder on this PC history flows back into, so it must
+ * never live in the data folder the sandbox can write (a forged copy could redirect writes anywhere on this PC).
+ */
+export const syncStatePath = (dataPath) => hostStateFile(storageOf(dataPath), dataPath, '.json');
+/**
+ * A state file that is missing, oversized or not in this shape counts as no state (nothing syncs back until the next
+ * launch).
+ */
+export const readSyncState = (dataPath) => new JsonFile(SyncStateSchema, syncStatePath(dataPath)).read();
+export const writeSyncState = (dataPath, state) => new JsonFile(SyncStateSchema, syncStatePath(dataPath)).write(state);

package/dist/sync/watcher.d.ts

@@ -1,21 +1,3 @@
-import type { Config } from '../core/types.js';
-import { type MemResult } from './claude-mem.js';
-/**
- * A project registered while the sandbox runs: its history comes in now (the sandbox's copy only gains files), and
- * from now on syncs back to its own folder on this PC.
- */
-export declare const syncProjectIn: (dataPath: string, project: {
-    hostWorkspace: string;
-    guestWorkspace: string;
-}) => number;
-export interface SyncSummary {
-    history: number;
-    claudeMem: MemResult | 'disabled';
-}
-/** Before launch: finish syncing the previous run out, then bring this PC's history (and claude-mem) in. */
-export declare const syncBeforeLaunch: (config: Config, dataPath: string, hostWorkspace: string) => SyncSummary;
-/** Syncs the sandbox's history (and, when `final`, claude-mem) back to this PC, as configured for the last launch. */
-export declare const syncBack: (dataPath: string, final: boolean) => SyncSummary;
 export declare const watcherRunning: (dataPath: string) => boolean;
 /** Body of the detached watcher process (`agent-sandbox _watch`). */
 export declare const watch: (dataPath: string) => Promise<void>;

package/dist/sync/watcher.js

@@ -3,92 +3,38 @@
 // Its pid file and log live in host-only storage, never in the data folder the sandbox can write.
 import fs from 'node:fs';
 import path from 'node:path';
-import { writeFileAtomic } from '../shared/rundir.js';
+import { writeFileAtomic } from '../shared/io/index.js';
 import { refuseInSelfTest } from '../host/test-guard.js';
-import { assertNoLinks, errMsg, sleep } from '../core/util.js';
-import { hostClaudeDir } from '../host/claude-profile.js';
-import { checkRepo } from '../host/repo-guard.js';
-import { isSandboxRunning } from '../host/platform.js';
-import { readActiveViews, WorkspaceView } from '../host/workspace-view/index.js';
-import { readForwards, sandboxAddress, startPortForwards } from '../host/port-forward.js';
+import { errMsg, sleep } from '../core/util/index.js';
+import { RepoGuardStore } from '../host/guard/index.js';
+import { isSandboxRunning } from '../host/sandbox/index.js';
+import { readActiveViews } from '../host/workspace-view/index.js';
+import { WorkspaceView } from '../host/workspace-view/index.js';
+import { readForwards, sandboxAddress, startPortForwards } from '../host/network/index.js';
 import { AuditCollector, readAuditSettings } from '../host/audit/collect.js';
-import { readMarkedProjects, saveDataSize, watchAndMark } from '../host/motw.js';
-import { sizeOf } from '../core/disk.js';
-import { beatLife, causeSince, endLife, keepAwake, readLife } from '../host/stops.js';
-import { hostClaudeMemDir, syncClaudeMem } from './claude-mem.js';
-import { readSyncState, syncHistoryIn, syncHistoryOut, writeSyncState } from './history.js';
+import { readMarkedProjects, saveDataSize, watchAndMark } from '../host/guard/index.js';
+import { sizeWithin } from '../core/disk.js';
+import { causeSince, KeepAwake, LifeRecord, saveCrashReport } from '../host/life/index.js';
+import { storageOf } from '../host/storage/index.js';
+import { syncBack } from './sync-cycle.js';
 const WATCH_INTERVAL_MS = 60 * 1000;
-const storageOf = (dataPath) => path.dirname(path.dirname(dataPath));
-const guestClaude = (dataPath) => path.join(dataPath, 'state', 'claude');
-const guestMem = (dataPath) => path.join(dataPath, 'state', 'claude-mem');
-/** Sync paths for the sandbox side, after checking nothing on the way there is a link planted by the sandbox. */
-const toPaths = (state, dataPath) => {
-    assertNoLinks(dataPath, guestClaude(dataPath));
-    return { hostClaudeDir: state.hostClaudeDir, guestClaudeDir: guestClaude(dataPath), hostWorkspace: state.hostWorkspace, guestWorkspace: state.guestWorkspace, extra: state.projects ?? [] };
-};
-/**
- * A project registered while the sandbox runs: its history comes in now (the sandbox's copy only gains files), and
- * from now on syncs back to its own folder on this PC.
- */
-export const syncProjectIn = (dataPath, project) => {
-    const state = readSyncState(dataPath);
-    if (!state)
-        return 0;
-    const projects = [...(state.projects ?? []).filter((p) => p.hostWorkspace.toLowerCase() !== project.hostWorkspace.toLowerCase()), project];
-    const next = { ...state, projects };
-    writeSyncState(dataPath, next);
-    // Prompt history is left alone: sessions are appending to the sandbox's copy right now.
-    return state.syncHistory ? syncHistoryIn(toPaths(next, dataPath), { promptHistory: false, scope: state.historyScope }) : 0;
-};
-const memSync = (dataPath, state, direction) => {
-    assertNoLinks(dataPath, guestMem(dataPath));
-    return syncClaudeMem(hostClaudeMemDir(), guestMem(dataPath), state, direction);
-};
-/** Before launch: finish syncing the previous run out, then bring this PC's history (and claude-mem) in. */
-export const syncBeforeLaunch = (config, dataPath, hostWorkspace) => {
-    const profile = config.claudeProfile;
-    const summary = { history: 0, claudeMem: 'disabled' };
-    if (!config.storage.persistAgentState)
-        return summary;
-    const previous = readSyncState(dataPath);
-    if (previous?.syncHistory)
-        syncHistoryOut(toPaths(previous, dataPath));
-    const state = { ...previous, hostClaudeDir: hostClaudeDir(profile), hostWorkspace, guestWorkspace: config.guestWorkspace, syncHistory: profile.syncHistory, historyScope: profile.historyScope, syncClaudeMem: profile.syncClaudeMem, syncClaudeMemBack: profile.syncClaudeMemBack, projects: [] };
-    if (profile.syncHistory)
-        summary.history = syncHistoryIn(toPaths(state, dataPath), { scope: profile.historyScope });
-    if (profile.syncClaudeMem) {
-        if (previous?.syncClaudeMem && previous.syncClaudeMemBack)
-            memSync(dataPath, state, 'out');
-        summary.claudeMem = memSync(dataPath, state, 'in');
-    }
-    writeSyncState(dataPath, state);
-    return summary;
-};
-/** Syncs the sandbox's history (and, when `final`, claude-mem) back to this PC, as configured for the last launch. */
-export const syncBack = (dataPath, final) => {
-    const state = readSyncState(dataPath);
-    const summary = { history: 0, claudeMem: 'disabled' };
-    if (!state)
-        return summary;
-    if (state.syncHistory)
-        summary.history = syncHistoryOut(toPaths(state, dataPath));
-    if (final && state.syncClaudeMem && state.syncClaudeMemBack)
-        summary.claudeMem = memSync(dataPath, state, 'out');
-    writeSyncState(dataPath, state);
-    return summary;
-};
 const hostRunDir = (dataPath) => path.join(storageOf(dataPath), 'run');
+/** The longest the watcher may take after the sandbox closed (final syncs) before it stops anyway. */
+const END_DEADLINE_MS = 3 * 60 * 1000;
 const watcherPidFile = (dataPath) => path.join(hostRunDir(dataPath), 'watcher-' + path.basename(dataPath) + '.pid');
 const watcherLog = (dataPath) => path.join(storageOf(dataPath), 'logs', 'host-sync-' + path.basename(dataPath) + '.log');
 // Signal 0 only asks whether the process exists. pid 0 would mean "my own process group", so it never counts.
-const alive = (pid) => { if (!Number.isInteger(pid) || pid <= 0)
-    return false; try {
-    process.kill(pid, 0);
-    return true;
-}
-catch {
-    return false;
-} };
+const alive = (pid) => {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
 export const watcherRunning = (dataPath) => {
     try {
         return alive(Number(fs.readFileSync(watcherPidFile(dataPath), 'utf8')));
@@ -105,13 +51,17 @@ export const watch = async (dataPath) => {
     fs.mkdirSync(hostRunDir(dataPath), { recursive: true });
     fs.mkdirSync(path.dirname(watcherLog(dataPath)), { recursive: true });
     writeFileAtomic(watcherPidFile(dataPath), String(process.pid));
-    const note = (message) => { try {
-        fs.appendFileSync(watcherLog(dataPath), new Date().toISOString() + ' ' + message + '\n');
-    }
-    catch { /* ignore */ } };
+    const note = (message) => {
+        try {
+            fs.appendFileSync(watcherLog(dataPath), new Date().toISOString() + ' ' + message + '\n');
+        }
+        catch {
+            /* ignore */
+        }
+    };
     const sync = (final) => {
         try {
-            for (const finding of checkRepo(dataPath)) {
+            for (const finding of new RepoGuardStore(dataPath).check()) {
                 note('SECURITY: neutralised a git ' + finding.kind + ' added inside the sandbox: ' + finding.detail);
                 audit?.guard(finding.kind + ': ' + finding.detail);
             }
@@ -133,12 +83,16 @@ export const watch = async (dataPath) => {
     const auditSettings = readAuditSettings(storageOf(dataPath), dataPath);
     const audit = auditSettings?.enabled ? new AuditCollector(dataPath, storageOf(dataPath), auditSettings) : null;
     audit?.start();
-    const auditTimer = audit ? setInterval(() => { try {
-        audit.flush();
-    }
-    catch (e) {
-        note('audit: ' + errMsg(e));
-    } }, 10000) : null;
+    const auditTimer = audit
+        ? setInterval(() => {
+            try {
+                audit.flush();
+            }
+            catch (e) {
+                note('audit: ' + errMsg(e));
+            }
+        }, 10000)
+        : null;
     // storage.markSandboxFiles: programs and scripts that appear in the projects get the "from the internet" mark.
     const stopMarking = watchAndMark(readMarkedProjects(storageOf(dataPath), dataPath), (m) => note(m));
     // network.forwardPorts: localhost on this PC reaches servers in the sandbox while it runs.
@@ -154,29 +108,37 @@ export const watch = async (dataPath) => {
         }
     });
     // sandbox.keepAwake, and the life record that tells the next launch how this run ended (host/stops.ts).
-    const awake = readLife(storageOf(dataPath), dataPath)?.keepAwake ? keepAwake(process.pid) : null;
+    const life = new LifeRecord(storageOf(dataPath), dataPath);
+    const awake = life.read()?.keepAwake ? KeepAwake.start(process.pid) : null;
     try {
         await sleep(30000);
         while (isSandboxRunning()) {
-            beatLife(storageOf(dataPath), dataPath);
+            life.beat();
             sync(false);
             await sleep(WATCH_INTERVAL_MS);
         }
         try {
-            const life = readLife(storageOf(dataPath), dataPath);
-            const cause = life ? causeSince(life.lastSeen) : null;
-            endLife(storageOf(dataPath), dataPath, cause);
+            const last = life.read();
+            const cause = last ? causeSince(last.lastSeen) : null;
+            const report = last && cause ? saveCrashReport(storageOf(dataPath), dataPath, last.lastSeen) : null;
+            life.end(cause, new Date(), report);
             if (cause)
-                note('sandbox ended: ' + cause.text);
+                note('sandbox ended: ' + cause.text + (report ? '; crash report: ' + report : ''));
         }
         catch (e) {
             note('could not record how the sandbox ended: ' + errMsg(e));
         }
         await sleep(3000);
+        // The sandbox is gone: this process ends within minutes whatever happens below (it must never outlive the sandbox).
+        setTimeout(() => {
+            note('final work took too long; stopped.');
+            fs.rmSync(watcherPidFile(dataPath), { force: true });
+            process.exit(0);
+        }, END_DEADLINE_MS).unref();
         sync(true);
     }
     finally {
-        awake?.kill();
+        awake?.stop();
         stops.forEach((stop) => stop());
         stopForwards();
         stopMarking();
@@ -197,11 +159,15 @@ export const watch = async (dataPath) => {
                 note('workspace ' + v.host + ': final sync failed: ' + errMsg(e));
             }
         }
-        // For the next launch's storage.warnDataGb (measuring then would be slow).
+        // For the next launch's storage.warnDataGb, only when it can be measured quickly (a big data folder takes minutes).
         try {
-            saveDataSize(storageOf(dataPath), dataPath, sizeOf(dataPath));
+            const bytes = sizeWithin(dataPath, 20000);
+            if (bytes !== null)
+                saveDataSize(storageOf(dataPath), dataPath, bytes);
+        }
+        catch {
+            /* best effort */
         }
-        catch { /* best effort */ }
         fs.rmSync(watcherPidFile(dataPath), { force: true });
     }
 };

package/native/keep-awake.ps1

@@ -0,0 +1,8 @@
+#Requires -Version 5.1
+# Keeps this PC awake (the screen may still turn off) until the process -OwnerId ends: the background watcher, which
+# ends with the sandbox. Used by host/stops.ts for sandbox.keepAwake.
+param([Parameter(Mandatory = $true)][int]$OwnerId)
+$ErrorActionPreference = 'Stop'
+Add-Type -Path (Join-Path $PSScriptRoot 'power.cs')
+[AgentSandbox.Power]::StayAwake()
+Wait-Process -Id $OwnerId -ErrorAction SilentlyContinue

package/native/power.cs

@@ -0,0 +1,23 @@
+// Keeps this PC from sleeping while a sandbox runs (sandbox.keepAwake). Loaded by keep-awake.ps1 (Add-Type). C# 5.
+using System.Runtime.InteropServices;
+
+namespace AgentSandbox
+{
+    public static class Power
+    {
+        // ES_CONTINUOUS | ES_SYSTEM_REQUIRED: the system stays awake until this thread ends or clears it.
+        private const uint ContinuousSystemRequired = 0x80000001;
+
+        private static class NativeMethods
+        {
+            [DllImport("kernel32.dll")]
+            public static extern uint SetThreadExecutionState(uint flags);
+        }
+
+        /// <summary>Asks Windows not to sleep for as long as the calling thread runs.</summary>
+        public static void StayAwake()
+        {
+            NativeMethods.SetThreadExecutionState(ContinuousSystemRequired);
+        }
+    }
+}

package/native/stop-events.ps1

@@ -0,0 +1,38 @@
+#Requires -Version 5.1
+# Prints, as JSON, the Windows events since -Since that can end a sandbox: restarts and shutdowns, power loss, sleep,
+# low memory, this PC's blue screens, and Windows inside the sandbox crashing. Read-only. Used by host/stops.ts.
+param([Parameter(Mandatory = $true)][datetime]$Since)
+$ErrorActionPreference = 'Stop'
+
+$filters = @(
+    @{ LogName = 'System'; Id = 1074, 6008, 41, 42, 2004; StartTime = $Since },
+    @{ LogName = 'System'; Id = 1001; ProviderName = 'Microsoft-Windows-WER-SystemErrorReporting'; StartTime = $Since },
+    @{ LogName = 'Microsoft-Windows-Hyper-V-Worker-Admin'; Id = 18590, 40001; StartTime = $Since }
+)
+$maxMessage = 390
+
+# What each event says beyond its id: the program that asked for a restart (1074), else the start of the message.
+function Get-EventDetail($record) {
+    if ($record.Id -eq 1074) { return [string]$record.Properties[0].Value }
+    if ($record.Id -in 18590, 40001, 1001) {
+        $message = [string]$record.Message
+        return $message.Substring(0, [math]::Min($maxMessage, $message.Length))
+    }
+    return ''
+}
+
+$events = foreach ($filter in $filters) {
+    try {
+        Get-WinEvent -FilterHashtable $filter -MaxEvents 100 | ForEach-Object {
+            [pscustomobject]@{
+                at       = $_.TimeCreated.ToUniversalTime().ToString('o')
+                id       = $_.Id
+                provider = $_.ProviderName
+                process  = Get-EventDetail $_
+            }
+        }
+    } catch {
+        # No matching events, or a log this PC does not have: nothing to add.
+    }
+}
+ConvertTo-Json -Compress -InputObject @($events)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windows-development-sandbox",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "A disposable Windows Sandbox for development, with or without an AI agent (Claude Code, Codex, Gemini, opencode, ...): the folder you run it from is the workspace, toolchains and databases for your project install themselves, and nothing else on your PC is reachable.",
   "type": "module",
   "license": "MIT",
@@ -33,6 +33,7 @@
   "files": [
     "dist",
     "sandbox",
+    "native",
     "schemas",
     "hooks",
     "config.example.json",
@@ -51,7 +52,10 @@
     "release:major": "npm version major && git push --follow-tags",
     "install:global": "node scripts/install-global.mjs",
     "publish:npm": "node scripts/publish-npm.mjs",
-    "doctor": "node dist/bin/agent-sandbox.js doctor"
+    "doctor": "node dist/bin/agent-sandbox.js doctor",
+    "lint": "eslint src scripts",
+    "format": "prettier --write src scripts",
+    "format:check": "prettier --check src scripts"
   },
   "publishConfig": {
     "access": "public"
@@ -78,10 +82,14 @@
     "zod": "^4.6.5"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.5",
     "@types/lodash": "^4.17.26",
     "@types/node": "^22.0.0",
     "esbuild": "^0.28.2",
-    "typescript": "^5.8.0"
+    "eslint": "^9.39.5",
+    "prettier": "^3.9.10",
+    "typescript": "^5.8.0",
+    "typescript-eslint": "^8.71.2"
   },
   "repository": {
     "type": "git",

package/sandbox/linkgate.cs

@@ -0,0 +1,98 @@
+// The linker for Rust's GNU host inside the sandbox (CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER). It runs MinGW's gcc,
+// but only as many at once as AGENT_LINK_SLOTS allows across the whole sandbox, and with Rust's own lld when
+// AGENT_LLD_DIR is set: several agents linking big programs with GNU ld at the same time used 2 GB+ each and took
+// Windows down. Each slot is a named mutex, which Windows frees when its owner dies (a killed build never keeps a
+// slot). Compiled inside the sandbox with the .NET Framework csc.exe (C# 5).
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+
+static class LinkGate
+{
+    const string SlotPrefix = @"Global\AgentSandboxLinkSlot";
+
+    static int Main()
+    {
+        string real = Environment.GetEnvironmentVariable("AGENT_REAL_LINKER");
+        if (string.IsNullOrEmpty(real) || !File.Exists(real))
+        {
+            Console.Error.WriteLine("error: the real linker was not found (AGENT_REAL_LINKER).");
+            return 1;
+        }
+        string args = ArgumentsOf(Environment.CommandLine);
+        string lld = Environment.GetEnvironmentVariable("AGENT_LLD_DIR");
+        if (!string.IsNullOrEmpty(lld) && File.Exists(Path.Combine(lld, "ld.lld.exe")))
+        {
+            args = args + " -fuse-ld=lld \"-B" + lld + "\"";
+        }
+        Mutex[] slots = new Mutex[SlotCount()];
+        for (int i = 0; i < slots.Length; i++) slots[i] = new Mutex(false, SlotPrefix + i);
+        try
+        {
+            int held = Acquire(slots);
+            try
+            {
+                return Run(real, args);
+            }
+            finally
+            {
+                slots[held].ReleaseMutex();
+            }
+        }
+        finally
+        {
+            foreach (Mutex slot in slots) slot.Dispose();
+        }
+    }
+
+    /// <summary>Waits for any free slot and returns its index (a slot left by a killed linker counts as free).</summary>
+    static int Acquire(Mutex[] slots)
+    {
+        try
+        {
+            return WaitHandle.WaitAny(slots);
+        }
+        catch (AbandonedMutexException e)
+        {
+            return e.MutexIndex;
+        }
+    }
+
+    static int Run(string program, string args)
+    {
+        var start = new ProcessStartInfo(program, args) { UseShellExecute = false };
+        // Ctrl+C reaches the linker too (same console); the gate only waits for it to finish.
+        Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e) { e.Cancel = true; };
+        using (Process p = Process.Start(start))
+        {
+            p.WaitForExit();
+            return p.ExitCode;
+        }
+    }
+
+    static int SlotCount()
+    {
+        int slots;
+        string value = Environment.GetEnvironmentVariable("AGENT_LINK_SLOTS");
+        return int.TryParse(value, out slots) && slots > 0 && slots <= 32 ? slots : 2;
+    }
+
+    // Everything after the program name, untouched, so quoting survives exactly as cargo wrote it.
+    static string ArgumentsOf(string commandLine)
+    {
+        string s = commandLine.TrimStart();
+        int end;
+        if (s.StartsWith("\""))
+        {
+            end = s.IndexOf('"', 1);
+            end = end < 0 ? s.Length : end + 1;
+        }
+        else
+        {
+            end = s.IndexOf(' ');
+            if (end < 0) end = s.Length;
+        }
+        return s.Substring(end).TrimStart();
+    }
+}

package/sandbox/memlog.ps1

@@ -1,10 +1,12 @@
 #Requires -Version 5.1
-# Writes the sandbox's memory state to C:\AgentData\logs\memory-<time>.log every 30 seconds, while it runs. That folder
-# outlives the sandbox, so if Windows inside it ever crashes again, the last lines show what was using memory just
-# before. Bounded: a file is closed at 1 MB (about two days) and a new one started; only the newest 10 are kept, so
-# the logs never take more than about 10 MB. Started hidden by logon.cmd. Never stops the boot.
+# Writes the sandbox's memory state to C:\AgentData\logs\memory-<time>.log while it runs: every 30 seconds, and every
+# 5 when RAM or commit is above 60%. That folder outlives the sandbox, so if Windows inside it crashes, the last lines
+# show what used memory just before. memory-pressure.txt holds the latest state (ok, high, critical) for agents to
+# check before big builds. Bounded: a file is closed at 1 MB and a new one started; only the newest 10 are kept.
+# Started hidden by logon.cmd. Never stops the boot.
 $ErrorActionPreference = 'SilentlyContinue'
 $logFolder = 'C:\AgentData\logs'
+$pressureFile = Join-Path $logFolder 'memory-pressure.txt'
 $maxFileBytes = 1MB
 $keepFiles = 10
 
@@ -27,8 +29,15 @@ while ($true) {
     $processes = @(Get-Process)
     $biggest = $processes | Sort-Object PrivateMemorySize64 -Descending | Select-Object -First 5 |
         ForEach-Object { '{0} {1}' -f $_.ProcessName, [math]::Round($_.PrivateMemorySize64 / 1MB) }
-    '{0:HH:mm:ss} | {1}/{2} | {3}/{4} | {5} processes; {6}' -f (Get-Date), $ramUsedMb, $ramTotalMb, $commitUsedMb, $commitLimitMb, $processes.Count, ($biggest -join ', ') |
+    $now = Get-Date
+    '{0:HH:mm:ss} | {1}/{2} | {3}/{4} | {5} processes; {6}' -f $now, $ramUsedMb, $ramTotalMb, $commitUsedMb, $commitLimitMb, $processes.Count, ($biggest -join ', ') |
         Add-Content -LiteralPath $logPath
+
+    $usedShare = [math]::Max($ramUsedMb / [math]::Max($ramTotalMb, 1), $commitUsedMb / [math]::Max($commitLimitMb, 1))
+    $level = if ($usedShare -ge 0.85) { 'critical' } elseif ($usedShare -ge 0.6) { 'high' } else { 'ok' }
+    '{0} {1:yyyy-MM-ddTHH:mm:ss} RAM {2}/{3} MB, commit {4}/{5} MB' -f $level, $now, $ramUsedMb, $ramTotalMb, $commitUsedMb, $commitLimitMb |
+        Set-Content -LiteralPath $pressureFile
+
     if ((Get-Item -LiteralPath $logPath).Length -ge $maxFileBytes) { $logPath = New-MemoryLog }
-    Start-Sleep -Seconds 30
+    Start-Sleep -Seconds $(if ($level -eq 'ok') { 30 } else { 5 })
 }

package/schemas/config.schema.json

@@ -99,7 +99,7 @@
             "description": "Folder on this PC (relative paths are relative to the config file)."
           },
           "guest": {
-            "description": "Where it appears inside the sandbox, e.g. C:\\Assets, or on another drive letter (D: to Z:) such as F:\\SteamLibrary\\steamapps\\common\\Game (shown as F: at boot). Leave it out to use the same path as on this PC (a folder inside the project stays where it is in the project). A path the sandbox cannot use (C:\\Windows\\..., C:\\Users\\..., one already in use) goes to C:\\Mapped\\<drive>\\<path> instead, and the launch says so.",
+            "description": "Where it appears inside the sandbox, e.g. C:\\Assets, or on another drive letter (D: to Z:) such as F:\\SteamLibrary\\steamapps\\common\\Game (shown as F: at boot). Leave it out to use the same path as on this PC (a folder inside the project stays where it is in the project). A full path only; one the sandbox cannot use (C:\\Windows\\..., C:\\Users\\..., one already in use) stops the launch with the fix.",
             "type": "string",
             "minLength": 1,
             "maxLength": 1024
@@ -510,6 +510,28 @@
               "type": "string",
               "minLength": 1,
               "description": "\"shared\": cargo's default target\\ (shared with builds on this PC, so builds on either side invalidate the other), \"separate\": <workspace>\\target\\sandbox (kept, no cross-talk), \"local\": on the sandbox's own disk (fastest, lost every boot), or a guest path."
+            },
+            "linker": {
+              "type": "string",
+              "enum": [
+                "lld",
+                "gnu"
+              ],
+              "description": "GNU host: \"lld\" links with Rust's own lld through MinGW's gcc (much less memory than GNU ld), \"gnu\" with GNU ld."
+            },
+            "linkSlots": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "const": "auto"
+                },
+                {
+                  "type": "integer",
+                  "minimum": 1,
+                  "maximum": 32
+                }
+              ],
+              "description": "GNU host: how many programs may link at the same time in the whole sandbox (other links wait). \"auto\" = one per 8 GB of sandbox memory, 2 to 4. Several agents linking big programs at once can take Windows down."
             }
           },
           "additionalProperties": false
@@ -1206,6 +1228,17 @@
               "xh",
               "grpcurl",
               "k6",
+              "rea",
+              "ghidra",
+              "x64dbg",
+              "ilspy",
+              "dnspy",
+              "die",
+              "pe-bear",
+              "cutter",
+              "radare2",
+              "jadx",
+              "system-informer",
               "jq",
               "yq",
               "ripgrep",

package/schemas/sandbox-config.schema.json

@@ -61,7 +61,7 @@
             "description": "Folder on this PC (relative paths are relative to the config file)."
           },
           "guest": {
-            "description": "Where it appears inside the sandbox, e.g. C:\\Assets, or on another drive letter (D: to Z:) such as F:\\SteamLibrary\\steamapps\\common\\Game (shown as F: at boot). Leave it out to use the same path as on this PC (a folder inside the project stays where it is in the project). A path the sandbox cannot use (C:\\Windows\\..., C:\\Users\\..., one already in use) goes to C:\\Mapped\\<drive>\\<path> instead, and the launch says so.",
+            "description": "Where it appears inside the sandbox, e.g. C:\\Assets, or on another drive letter (D: to Z:) such as F:\\SteamLibrary\\steamapps\\common\\Game (shown as F: at boot). Leave it out to use the same path as on this PC (a folder inside the project stays where it is in the project). A full path only; one the sandbox cannot use (C:\\Windows\\..., C:\\Users\\..., one already in use) stops the launch with the fix.",
             "type": "string",
             "minLength": 1,
             "maxLength": 1024
@@ -380,6 +380,28 @@
               "type": "string",
               "minLength": 1,
               "description": "\"shared\": cargo's default target\\ (shared with builds on this PC, so builds on either side invalidate the other), \"separate\": <workspace>\\target\\sandbox (kept, no cross-talk), \"local\": on the sandbox's own disk (fastest, lost every boot), or a guest path."
+            },
+            "linker": {
+              "type": "string",
+              "enum": [
+                "lld",
+                "gnu"
+              ],
+              "description": "GNU host: \"lld\" links with Rust's own lld through MinGW's gcc (much less memory than GNU ld), \"gnu\" with GNU ld."
+            },
+            "linkSlots": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "const": "auto"
+                },
+                {
+                  "type": "integer",
+                  "minimum": 1,
+                  "maximum": 32
+                }
+              ],
+              "description": "GNU host: how many programs may link at the same time in the whole sandbox (other links wait). \"auto\" = one per 8 GB of sandbox memory, 2 to 4. Several agents linking big programs at once can take Windows down."
             }
           },
           "additionalProperties": false
@@ -1020,6 +1042,17 @@
               "xh",
               "grpcurl",
               "k6",
+              "rea",
+              "ghidra",
+              "x64dbg",
+              "ilspy",
+              "dnspy",
+              "die",
+              "pe-bear",
+              "cutter",
+              "radare2",
+              "jadx",
+              "system-informer",
               "jq",
               "yq",
               "ripgrep",