windows-development-sandbox 1.1.0 → 1.4.1

package/dist/sync/watcher.js

@@ -9,6 +9,12 @@ 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 { 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';
 const WATCH_INTERVAL_MS = 60 * 1000;
@@ -32,7 +38,7 @@ export const syncProjectIn = (dataPath, 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 }) : 0;
+    return state.syncHistory ? syncHistoryIn(toPaths(next, dataPath), { promptHistory: false, scope: state.historyScope }) : 0;
 };
 const memSync = (dataPath, state, direction) => {
     assertNoLinks(dataPath, guestMem(dataPath));
@@ -47,11 +53,11 @@ export const syncBeforeLaunch = (config, dataPath, hostWorkspace) => {
     const previous = readSyncState(dataPath);
     if (previous?.syncHistory)
         syncHistoryOut(toPaths(previous, dataPath));
-    const state = { ...previous, hostClaudeDir: hostClaudeDir(profile), hostWorkspace, guestWorkspace: config.guestWorkspace, syncHistory: profile.syncHistory, syncClaudeMem: profile.syncClaudeMem, projects: [] };
+    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));
+        summary.history = syncHistoryIn(toPaths(state, dataPath), { scope: profile.historyScope });
     if (profile.syncClaudeMem) {
-        if (previous?.syncClaudeMem)
+        if (previous?.syncClaudeMem && previous.syncClaudeMemBack)
             memSync(dataPath, state, 'out');
         summary.claudeMem = memSync(dataPath, state, 'in');
     }
@@ -66,7 +72,7 @@ export const syncBack = (dataPath, final) => {
         return summary;
     if (state.syncHistory)
         summary.history = syncHistoryOut(toPaths(state, dataPath));
-    if (final && state.syncClaudeMem)
+    if (final && state.syncClaudeMem && state.syncClaudeMemBack)
         summary.claudeMem = memSync(dataPath, state, 'out');
     writeSyncState(dataPath, state);
     return summary;
@@ -105,8 +111,10 @@ export const watch = async (dataPath) => {
     catch { /* ignore */ } };
     const sync = (final) => {
         try {
-            for (const finding of checkRepo(dataPath))
+            for (const finding of checkRepo(dataPath)) {
                 note('SECURITY: neutralised a git ' + finding.kind + ' added inside the sandbox: ' + finding.detail);
+                audit?.guard(finding.kind + ': ' + finding.detail);
+            }
         }
         catch (e) {
             note('repo guard failed: ' + errMsg(e));
@@ -120,16 +128,80 @@ export const watch = async (dataPath) => {
             note('sync failed: ' + errMsg(e));
         }
     };
+    // workspaceFilter: each filtered project is kept in step with its view from now until the sandbox closes.
+    // audit.enabled: programs, files, sessions and guard findings into the host-only audit log.
+    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;
+    // 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.
+    const stopForwards = startPortForwards(readForwards(storageOf(dataPath), dataPath), () => sandboxAddress(dataPath), (m) => note('port forward: ' + m));
+    const views = readActiveViews(storageOf(dataPath), dataPath);
+    const stops = views.flatMap((v) => {
+        try {
+            return [new WorkspaceView({ ...v, note: (m) => note('workspace ' + v.host + ': ' + m) }).watch()];
+        }
+        catch (e) {
+            note('workspace ' + v.host + ': could not watch: ' + errMsg(e));
+            return [];
+        }
+    });
+    // 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;
     try {
         await sleep(30000);
         while (isSandboxRunning()) {
+            beatLife(storageOf(dataPath), dataPath);
             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);
+            if (cause)
+                note('sandbox ended: ' + cause.text);
+        }
+        catch (e) {
+            note('could not record how the sandbox ended: ' + errMsg(e));
+        }
         await sleep(3000);
         sync(true);
     }
     finally {
+        awake?.kill();
+        stops.forEach((stop) => stop());
+        stopForwards();
+        stopMarking();
+        if (auditTimer)
+            clearInterval(auditTimer);
+        try {
+            audit?.stop();
+        }
+        catch (e) {
+            note('audit: ' + errMsg(e));
+        }
+        for (const v of views) {
+            try {
+                const s = new WorkspaceView(v).syncAll();
+                note('workspace ' + v.host + ': final sync ' + s.toHost + ' out, ' + s.toView + ' in');
+            }
+            catch (e) {
+                note('workspace ' + v.host + ': final sync failed: ' + errMsg(e));
+            }
+        }
+        // For the next launch's storage.warnDataGb (measuring then would be slow).
+        try {
+            saveDataSize(storageOf(dataPath), dataPath, sizeOf(dataPath));
+        }
+        catch { /* best effort */ }
         fs.rmSync(watcherPidFile(dataPath), { force: true });
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windows-development-sandbox",
-  "version": "1.1.0",
+  "version": "1.4.1",
   "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",
@@ -72,6 +72,7 @@
   "dependencies": {
     "@inquirer/prompts": "^7.10.1",
     "commander": "^14.0.3",
+    "ignore": "^7.0.12",
     "jsonc-parser": "^3.3.1",
     "lodash": "^4.18.1",
     "zod": "^4.6.5"

package/sandbox/cargoshim.cs

@@ -0,0 +1,56 @@
+// cargo.exe stand-in for toolchains.rust.targetDir = "separate": every checkout builds into ITS OWN target\sandbox.
+// One CARGO_TARGET_DIR for the whole sandbox made agents working in different git worktrees overwrite each other's
+// builds (and the Claude Code Bash tool does not keep a per-call variable). The checkout is the nearest folder with a
+// .git (a folder, or the file a worktree has); without one, the nearest folder with a Cargo.toml. A CARGO_TARGET_DIR
+// you set yourself always wins. Compiled inside the sandbox with the .NET Framework csc.exe (C# 5).
+using System;
+using System.Diagnostics;
+using System.IO;
+
+static class CargoShim
+{
+    static int Main()
+    {
+        string real = Environment.GetEnvironmentVariable("AGENT_REAL_CARGO");
+        if (string.IsNullOrEmpty(real) || !File.Exists(real))
+        {
+            Console.Error.WriteLine("error: the real cargo was not found (AGENT_REAL_CARGO).");
+            return 101;
+        }
+        var start = new ProcessStartInfo(real, ArgumentsOf(Environment.CommandLine)) { UseShellExecute = false };
+        if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("CARGO_TARGET_DIR")))
+        {
+            string root = CheckoutOf(Environment.CurrentDirectory);
+            if (root != null) start.EnvironmentVariables["CARGO_TARGET_DIR"] = Path.Combine(root, "target", "sandbox");
+        }
+        // Ctrl+C reaches cargo too (same console); the shim 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 string CheckoutOf(string dir)
+    {
+        string cargoRoot = null;
+        for (var d = new DirectoryInfo(dir); d != null; d = d.Parent)
+        {
+            string git = Path.Combine(d.FullName, ".git");
+            if (Directory.Exists(git) || File.Exists(git)) return d.FullName;
+            if (cargoRoot == null && File.Exists(Path.Combine(d.FullName, "Cargo.toml"))) cargoRoot = d.FullName;
+        }
+        return cargoRoot;
+    }
+
+    // Everything after the program name, untouched, so quoting survives exactly as the caller 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/cpucap.cs

@@ -0,0 +1,33 @@
+// Caps a process and everything it starts at a share of the PC's CPU. Loaded by cpucap.ps1 (Add-Type). C# 5.
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+
+public static class SandboxCpuCap {
+    // JOBOBJECT_CPU_RATE_CONTROL_INFORMATION.
+    [StructLayout(LayoutKind.Sequential)]
+    private struct CpuRate { public uint ControlFlags; public uint Rate; }
+
+    [DllImport("kernel32.dll", SetLastError = true)] private static extern IntPtr CreateJobObject(IntPtr attributes, string name);
+    [DllImport("kernel32.dll", SetLastError = true)] private static extern bool SetInformationJobObject(IntPtr job, int infoClass, ref CpuRate info, int length);
+    [DllImport("kernel32.dll", SetLastError = true)] private static extern IntPtr OpenProcess(uint access, bool inherit, int pid);
+    [DllImport("kernel32.dll", SetLastError = true)] private static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
+    [DllImport("kernel32.dll")] private static extern bool CloseHandle(IntPtr handle);
+
+    private const int JobObjectCpuRateControlInformation = 15;
+    private const uint CpuRateEnable = 0x1, CpuRateHardCap = 0x4;
+    private const uint ProcessTerminate = 0x0001, ProcessSetQuota = 0x0100;  // what AssignProcessToJobObject needs
+
+    /// <summary>Puts process pid in a new job with a hard cap of percent % of all processors. Throws on failure.</summary>
+    public static void Apply(int pid, int percent) {
+        IntPtr job = CreateJobObject(IntPtr.Zero, null);
+        if (job == IntPtr.Zero) throw new Win32Exception();
+        // The rate is in 1/100 % of all processors.
+        CpuRate rate = new CpuRate { ControlFlags = CpuRateEnable | CpuRateHardCap, Rate = (uint)(percent * 100) };
+        if (!SetInformationJobObject(job, JobObjectCpuRateControlInformation, ref rate, Marshal.SizeOf(typeof(CpuRate)))) throw new Win32Exception();
+        IntPtr process = OpenProcess(ProcessSetQuota | ProcessTerminate, false, pid);
+        if (process == IntPtr.Zero) throw new Win32Exception();
+        try { if (!AssignProcessToJobObject(job, process)) throw new Win32Exception(); } finally { CloseHandle(process); }
+        // The job's handle is left to close with this process: the job lives on while any process in it runs.
+    }
+}

package/sandbox/cpucap.ps1

@@ -3,46 +3,15 @@
 # every processor, so heavy builds inside can take the whole PC. This puts logon.cmd (the parent of this script),
 # before it starts anything, into a Windows job object with a hard CPU-rate cap; everything it starts inherits it:
 # Windows Terminal and its tabs, the boot, the agents, installs and builds. Programs started from the sandbox's Start
-# menu are not covered. Never stops the boot: any problem is logged and the sandbox starts uncapped.
-param([int]$ProcessId = 0, [int]$Percent = 0)
+# menu are not covered. Never stops the boot: it logs one line either way and the sandbox starts uncapped on failure.
+param([int]$ProcessId = 0, [int]$Percent = 0)  # 0 = the parent process / cpuLimitPercent from session.json
 $ErrorActionPreference = 'Stop'
 $log = 'C:\AgentData\logs\logon-hit.txt'
 try {
-    if ($Percent -eq 0) {
-        $session = Get-Content -LiteralPath 'C:\AgentLaunch\session.json' -Raw -Encoding UTF8 | ConvertFrom-Json
-        if ($null -eq $session.cpuLimitPercent) { exit 0 }
-        $Percent = [int]$session.cpuLimitPercent
-    }
+    if ($Percent -eq 0) { $Percent = [int](Get-Content -LiteralPath 'C:\AgentLaunch\session.json' -Raw -Encoding UTF8 | ConvertFrom-Json).cpuLimitPercent }
     if ($Percent -lt 1 -or $Percent -ge 100) { exit 0 }
     if ($ProcessId -eq 0) { $ProcessId = [int](Get-CimInstance Win32_Process -Filter "ProcessId=$PID").ParentProcessId }
-    Add-Type -TypeDefinition @'
-using System;
-using System.ComponentModel;
-using System.Runtime.InteropServices;
-public static class SandboxCpuCap {
-    [StructLayout(LayoutKind.Sequential)]
-    private struct CpuRate { public uint ControlFlags; public uint Rate; }
-    [DllImport("kernel32.dll", SetLastError = true)] private static extern IntPtr CreateJobObject(IntPtr attributes, string name);
-    [DllImport("kernel32.dll", SetLastError = true)] private static extern bool SetInformationJobObject(IntPtr job, int infoClass, ref CpuRate info, int length);
-    [DllImport("kernel32.dll", SetLastError = true)] private static extern IntPtr OpenProcess(uint access, bool inherit, int pid);
-    [DllImport("kernel32.dll", SetLastError = true)] private static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
-    [DllImport("kernel32.dll")] private static extern bool CloseHandle(IntPtr handle);
-    // JobObjectCpuRateControlInformation; ENABLE | HARD_CAP; the rate is in 1/100 % of all processors.
-    public static void Apply(int pid, int percent) {
-        IntPtr job = CreateJobObject(IntPtr.Zero, null);
-        if (job == IntPtr.Zero) throw new Win32Exception();
-        CpuRate rate = new CpuRate();
-        rate.ControlFlags = 0x1 | 0x4;
-        rate.Rate = (uint)(percent * 100);
-        if (!SetInformationJobObject(job, 15, ref rate, Marshal.SizeOf(typeof(CpuRate)))) throw new Win32Exception();
-        // PROCESS_SET_QUOTA | PROCESS_TERMINATE: what AssignProcessToJobObject needs.
-        IntPtr process = OpenProcess(0x0100 | 0x0001, false, pid);
-        if (process == IntPtr.Zero) throw new Win32Exception();
-        try { if (!AssignProcessToJobObject(job, process)) throw new Win32Exception(); } finally { CloseHandle(process); }
-        // The job's handle may close: it lives on while any process in it runs.
-    }
-}
-'@
+    Add-Type -Path (Join-Path $PSScriptRoot 'cpucap.cs')
     [SandboxCpuCap]::Apply($ProcessId, $Percent)
     "CPU capped at $Percent% of the PC (sandbox.cpuLimit)." | Add-Content -LiteralPath $log
 } catch {

package/sandbox/logon.cmd

@@ -4,9 +4,15 @@ rem (downloaded once by the host into persistent storage), or a plain PowerShell
 if not exist C:\AgentData\logs mkdir C:\AgentData\logs
 echo logon.cmd ran at %date% %time% > C:\AgentData\logs\logon-hit.txt
 call C:\AgentLaunch\sandbox\trust.cmd
+rem New Terminal tabs start in %AGENT_WORKSPACE%: Terminal must have it before the runtime sets it machine-wide.
+if exist C:\AgentLaunch\env.cmd call C:\AgentLaunch\env.cmd
 set "PS=%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe"
 rem sandbox.cpuLimit: this window joins a CPU-capped job first, so everything started below inherits the cap.
 "%PS%" -NoLogo -NoProfile -ExecutionPolicy Bypass -File C:\AgentLaunch\sandbox\cpucap.ps1
+rem sandbox.pageFileMb: room for many parallel builds (the sandbox starts with about 1 GB of paging file).
+"%PS%" -NoLogo -NoProfile -ExecutionPolicy Bypass -File C:\AgentLaunch\sandbox\pagefile.ps1
+rem The memory state every 30 s into the persistent logs, so a crash leaves evidence.
+start "" /min "%PS%" -NoLogo -NoProfile -WindowStyle Hidden -ExecutionPolicy Bypass -File C:\AgentLaunch\sandbox\memlog.ps1
 set "BOOT=%PS% -NoLogo -NoProfile -ExecutionPolicy Bypass -NoExit -File C:\AgentLaunch\sandbox\bootstrap.ps1"
 if not exist C:\AgentData\tools\terminal\wt.exe goto plain
 start "" C:\AgentData\tools\terminal\wt.exe --maximized new-tab --title "Agent Sandbox" -d C:\AgentLaunch %BOOT%

package/sandbox/memlog.ps1

@@ -0,0 +1,34 @@
+#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.
+$ErrorActionPreference = 'SilentlyContinue'
+$logFolder = 'C:\AgentData\logs'
+$maxFileBytes = 1MB
+$keepFiles = 10
+
+# A new log file, and the oldest ones beyond $keepFiles removed. Returns its path.
+function New-MemoryLog {
+    $path = Join-Path $logFolder ('memory-{0:yyyyMMdd-HHmmss}.log' -f (Get-Date))
+    'time     | RAM used/total MB | commit used/limit MB | biggest processes (private MB)' | Set-Content -LiteralPath $path
+    Get-ChildItem -LiteralPath $logFolder -Filter 'memory-*.log' | Sort-Object LastWriteTime -Descending |
+        Select-Object -Skip $keepFiles | Remove-Item -Force
+    return $path
+}
+
+$logPath = New-MemoryLog
+while ($true) {
+    $os = Get-CimInstance Win32_OperatingSystem
+    $ramTotalMb = [math]::Round($os.TotalVisibleMemorySize / 1KB)
+    $ramUsedMb = $ramTotalMb - [math]::Round($os.FreePhysicalMemory / 1KB)
+    $commitLimitMb = [math]::Round($os.TotalVirtualMemorySize / 1KB)
+    $commitUsedMb = $commitLimitMb - [math]::Round($os.FreeVirtualMemory / 1KB)
+    $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 ', ') |
+        Add-Content -LiteralPath $logPath
+    if ((Get-Item -LiteralPath $logPath).Length -ge $maxFileBytes) { $logPath = New-MemoryLog }
+    Start-Sleep -Seconds 30
+}

package/sandbox/pagefile.cs

@@ -0,0 +1,31 @@
+// Sets the size of the sandbox's paging file at once, with no restart. Loaded by pagefile.ps1 (Add-Type). C# 5.
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+
+public static class SandboxPageFile {
+    // UNICODE_STRING. The marshaller copies Buffer to native memory for the length of the call.
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    private struct NtString { public ushort Length; public ushort MaximumLength; public string Buffer; }
+
+    [DllImport("ntdll.dll")] private static extern int RtlAdjustPrivilege(int privilege, bool enable, bool currentThread, out bool wasEnabled);
+    [DllImport("ntdll.dll")] private static extern int NtCreatePagingFile(ref NtString path, ref long minimumBytes, ref long maximumBytes, uint priority);
+    [DllImport("ntdll.dll")] private static extern int RtlNtStatusToDosError(int status);
+
+    private const int SeCreatePagefilePrivilege = 15;
+
+    /// <summary>Makes C:\pagefile.sys sizeMb, fixed (it never grows). Throws with Windows' reason on failure.</summary>
+    public static void Set(int sizeMb) {
+        bool wasEnabled;
+        Check(RtlAdjustPrivilege(SeCreatePagefilePrivilege, true, false, out wasEnabled));
+        // The same call Windows makes at startup; for the existing file it changes the size in place.
+        const string path = @"\??\C:\pagefile.sys";
+        NtString name = new NtString { Length = (ushort)(path.Length * 2), MaximumLength = (ushort)(path.Length * 2 + 2), Buffer = path };
+        long minimum = sizeMb * 1048576L, maximum = minimum;
+        Check(NtCreatePagingFile(ref name, ref minimum, ref maximum, 0));
+    }
+
+    private static void Check(int status) {
+        if (status != 0) throw new Win32Exception(RtlNtStatusToDosError(status));
+    }
+}

package/sandbox/pagefile.ps1

@@ -0,0 +1,21 @@
+#Requires -Version 5.1
+# Gives the sandbox a paging file of sandbox.pageFileMb, created at full size now, before anything runs. Windows Sandbox
+# starts with about 1 GB, so parallel builds run out of memory ("The paging file is too small", os error 1455), and
+# then Windows grows the file while they run: both crashes of Windows inside the sandbox (13 Oct 2026, stop code 0x1A
+# MEMORY_MANAGEMENT) happened under that load. A fixed size never grows. Never stops the boot: it logs one line.
+param([int]$SizeMb = 0)  # 0 = read sandbox.pageFileMb from session.json
+$ErrorActionPreference = 'Stop'
+$log = 'C:\AgentData\logs\logon-hit.txt'
+try {
+    if ($SizeMb -eq 0) { $SizeMb = [int](Get-Content -LiteralPath 'C:\AgentLaunch\session.json' -Raw -Encoding UTF8 | ConvertFrom-Json).pageFileMb }
+    if ($SizeMb -le 0) { exit 0 }
+    # Keep 8 GB of the sandbox's disk free for everything else.
+    $SizeMb = [math]::Min($SizeMb, [math]::Floor((Get-PSDrive -Name C).Free / 1MB) - 8192)
+    if ($SizeMb -lt 1024) { throw 'too little free disk.' }
+    Add-Type -Path (Join-Path $PSScriptRoot 'pagefile.cs')
+    [SandboxPageFile]::Set($SizeMb)
+    "Paging file set to $SizeMb MB, fixed (sandbox.pageFileMb)." | Add-Content -LiteralPath $log
+} catch {
+    "Paging file left as it is: $($_.Exception.Message)" | Add-Content -LiteralPath $log
+}
+exit 0

package/sandbox/ptyhost.cs

@@ -16,6 +16,10 @@
 //                  18 ERROR   utf8 message
 //                  19 RESTARTING
 //                  20 STATUS  [viewers:2][remoteViewers:2]  viewers heard from recently (remote = not loopback, i.e. the PC)
+//                  21 CONSOLE utf8 "conpty.dll" or "windows", sent after HELLO. With conpty.dll the output is passed
+//                             through (real scrollback, no repaint on resize): a viewer that joins later is sent the
+//                             terminal modes in force (mouse tracking ...) and the output since the last screen clear
+//                             instead, and must not clear its screen on a resize.
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
@@ -75,6 +79,7 @@ sealed class SessionHost
             using (var console = PseudoConsole.Start(command, hub.Cols, hub.Rows, hub.Broadcast))
             {
                 hub.Attach(console);
+                log.Write("pseudo console: " + Native.ConsoleKind);
                 int exitCode = console.WaitForExit();
                 if (!restartRequested)
                 {
@@ -92,6 +97,7 @@ sealed class SessionHost
     public void Restart()
     {
         restartRequested = true;
+        hub.ResetReplay();
         hub.Notify(Frame.Restarting);
         hub.KillProgram();
     }
@@ -225,6 +231,9 @@ sealed class ClientHub
     readonly byte[] token;
     readonly byte[] tail = new byte[8192];
     int tailLength;
+    readonly object replayGate = new object();
+    readonly MemoryStream replay = new MemoryStream();
+    const int MaxReplay = 4 << 20;
     PseudoConsole console;
     Client sizeOwner;
     short cols, rows;
@@ -251,8 +260,23 @@ sealed class ClientHub
         client.ControlOnly = (hello[4] & 3) != 0;
         client.Query = (hello[4] & 2) != 0;
         if (client.Query) return true;
-        lock (gate) clients.Add(client);
-        if (!client.ControlOnly) TakeOwnership(client);
+        if (!client.ControlOnly)
+        {
+            Send(client, Frame.Console, Encoding.UTF8.GetBytes(Native.ConsoleKind.StartsWith("conpty") ? "conpty.dll" : "windows"));
+            // Taken and queued under the replay lock, so no output falls between the replay and the live stream.
+            lock (replayGate)
+            {
+                if (Native.ConsoleKind.StartsWith("conpty"))
+                {
+                    byte[] prefix = ModePrefix();
+                    if (prefix.Length > 0) Send(client, Frame.Output, prefix);
+                    if (replay.Length > 0) Send(client, Frame.Output, replay.ToArray());
+                }
+                lock (gate) clients.Add(client);
+            }
+            TakeOwnership(client);
+        }
+        else lock (gate) clients.Add(client);
         return true;
     }
 
@@ -287,7 +311,92 @@ sealed class ClientHub
     public void Broadcast(byte[] output)
     {
         Remember(output);
-        foreach (Client c in Snapshot()) if (!c.ControlOnly) Send(c, Frame.Output, output);
+        lock (replayGate)
+        {
+            Record(output);
+            foreach (Client c in Snapshot()) if (!c.ControlOnly) Send(c, Frame.Output, output);
+        }
+    }
+
+    /**
+     * The output a viewer joining now needs to see the screen (conpty.dll does not repaint for it): everything since the
+     * last "clear screen", capped. Cut at a line start when capped, so the replay never begins inside an escape sequence.
+     */
+    void Record(byte[] output)
+    {
+        if (!Native.ConsoleKind.StartsWith("conpty")) return;
+        TrackModes(output);
+        int clear = LastClear(output);
+        if (clear >= 0) { replay.SetLength(0); replay.Write(output, clear, output.Length - clear); }
+        else replay.Write(output, 0, output.Length);
+        if (replay.Length <= MaxReplay) return;
+        byte[] all = replay.ToArray();
+        int from = all.Length - MaxReplay / 2;
+        while (from < all.Length && all[from] != (byte)'\n') from++;
+        replay.SetLength(0);
+        if (from + 1 < all.Length) replay.Write(all, from + 1, all.Length - from - 1);
+    }
+
+    /**
+     * Terminal modes the program (or conpty.dll) turned on that a late viewer's terminal must have too, or its clicks and
+     * wheel never reach the program: mouse tracking (1000, 1002, 1003, 1005, 1006, 1015), focus events (1004), bracketed
+     * paste (2004), win32 input (9001), application cursor keys (1), cursor visibility (25), the alternate screen (1049).
+     * The replay is cut at the last screen clear, which may come after the program turned them on.
+     */
+    static readonly int[] ReplayedModes = { 1, 25, 1000, 1002, 1003, 1004, 1005, 1006, 1015, 1049, 2004, 9001 };
+    readonly Dictionary<int, bool> modes = new Dictionary<int, bool>();
+    /** DECSET / DECRST parser, kept across chunks: 0 text, 1 after ESC, 2 after ESC[, 3 in ESC[? parameters. */
+    int modeState;
+    readonly StringBuilder modeParams = new StringBuilder();
+
+    void TrackModes(byte[] output)
+    {
+        foreach (byte b in output)
+        {
+            if (b == 0x1b) { modeState = 1; continue; }
+            switch (modeState)
+            {
+                case 1: modeState = b == (byte)'[' ? 2 : 0; break;
+                case 2: modeState = b == (byte)'?' ? 3 : 0; modeParams.Length = 0; break;
+                case 3:
+                    if ((b >= (byte)'0' && b <= (byte)'9') || b == (byte)';') { if (modeParams.Length < 64) modeParams.Append((char)b); }
+                    else
+                    {
+                        if (b == (byte)'h' || b == (byte)'l')
+                            foreach (string p in modeParams.ToString().Split(';'))
+                            {
+                                int mode;
+                                if (int.TryParse(p, out mode) && Array.IndexOf(ReplayedModes, mode) >= 0) modes[mode] = b == (byte)'h';
+                            }
+                        modeState = 0;
+                    }
+                    break;
+            }
+        }
+    }
+
+    /** The modes to set before the replay, e.g. ESC[?1000h ESC[?1006h. */
+    byte[] ModePrefix()
+    {
+        var text = new StringBuilder();
+        foreach (int mode in ReplayedModes)
+        {
+            bool on;
+            if (modes.TryGetValue(mode, out on)) text.Append("\x1b[?" + mode + (on ? "h" : "l"));
+        }
+        return Encoding.ASCII.GetBytes(text.ToString());
+    }
+
+    /** Where the last ESC[2J (clear screen) or ESC c (reset) starts in `data`, or -1. */
+    static int LastClear(byte[] data)
+    {
+        for (int i = data.Length - 2; i >= 0; i--)
+        {
+            if (data[i] != 0x1b) continue;
+            if (data[i + 1] == (byte)'c') return i;
+            if (i + 3 < data.Length && data[i + 1] == (byte)'[' && data[i + 2] == (byte)'2' && data[i + 3] == (byte)'J') return i;
+        }
+        return -1;
     }
 
     /** The program's last output as plain text (escape sequences removed), for the log when it exits. */
@@ -311,6 +420,9 @@ sealed class ClientHub
         }
     }
 
+    /** A restarted program starts on a clean screen (viewers clear theirs on RESTARTING). */
+    public void ResetReplay() { lock (replayGate) { replay.SetLength(0); modes.Clear(); modeState = 0; } }
+
     public void Notify(byte type)
     {
         foreach (Client c in Snapshot()) if (!c.ControlOnly) Send(c, type, new byte[0]);
@@ -503,7 +615,7 @@ sealed class PseudoConsole : IDisposable
 static class Frame
 {
     public const byte Hello = 1, Input = 2, Resize = 3, Restart = 4, Ping = 5;
-    public const byte Output = 16, Exit = 17, Error = 18, Restarting = 19, Status = 20;
+    public const byte Output = 16, Exit = 17, Error = 18, Restarting = 19, Status = 20, Console = 21;
     const int MaxPayload = 1 << 20;
 
     public static bool Read(Stream stream, out byte type, out byte[] payload)
@@ -598,9 +710,52 @@ static class Native
         }
     }
 
-    [DllImport("kernel32.dll")] public static extern int CreatePseudoConsole(Coord size, SafeFileHandle hInput, SafeFileHandle hOutput, uint dwFlags, out IntPtr phPC);
-    [DllImport("kernel32.dll")] public static extern int ResizePseudoConsole(IntPtr hPC, Coord size);
-    [DllImport("kernel32.dll")] public static extern void ClosePseudoConsole(IntPtr hPC);
+    // The pseudo console: the newer conpty.dll (+ OpenConsole.exe next to it) when PTYHOST_CONPTY names one, else the one
+    // built into Windows. Windows 10/11 before 24H2 ship a ConPTY that re-renders the screen instead of passing the
+    // program's output through, which garbles wide characters after a resize and loses mouse input and scrollback.
+    [UnmanagedFunctionPointer(CallingConvention.Winapi)] delegate int CreateFn(Coord size, SafeFileHandle hInput, SafeFileHandle hOutput, uint dwFlags, out IntPtr phPC);
+    [UnmanagedFunctionPointer(CallingConvention.Winapi)] delegate int ResizeFn(IntPtr hPC, Coord size);
+    [UnmanagedFunctionPointer(CallingConvention.Winapi)] delegate void CloseFn(IntPtr hPC);
+    static CreateFn create;
+    static ResizeFn resize;
+    static CloseFn close;
+    /** "conpty.dll" or "windows": which pseudo console is in use (logged, and told to viewers). */
+    public static string ConsoleKind = "windows";
+
+    static Native()
+    {
+        string dll = Environment.GetEnvironmentVariable("PTYHOST_CONPTY");
+        if (string.IsNullOrEmpty(dll) || !File.Exists(dll) || !File.Exists(Path.Combine(Path.GetDirectoryName(dll), "OpenConsole.exe"))) return;
+        IntPtr module = LoadLibraryW(dll);
+        if (module == IntPtr.Zero) return;
+        IntPtr c = GetProcAddress(module, "ConptyCreatePseudoConsole"), r = GetProcAddress(module, "ConptyResizePseudoConsole"), x = GetProcAddress(module, "ConptyClosePseudoConsole");
+        if (c == IntPtr.Zero || r == IntPtr.Zero || x == IntPtr.Zero) return;
+        create = (CreateFn)Marshal.GetDelegateForFunctionPointer(c, typeof(CreateFn));
+        resize = (ResizeFn)Marshal.GetDelegateForFunctionPointer(r, typeof(ResizeFn));
+        close = (CloseFn)Marshal.GetDelegateForFunctionPointer(x, typeof(CloseFn));
+        ConsoleKind = "conpty.dll";
+    }
+
+    /** conpty.dll first; if it cannot start one (OpenConsole.exe blocked or broken), the built-in one for good. */
+    public static int CreatePseudoConsole(Coord size, SafeFileHandle hInput, SafeFileHandle hOutput, uint dwFlags, out IntPtr phPC)
+    {
+        if (create != null)
+        {
+            int hr = create(size, hInput, hOutput, dwFlags, out phPC);
+            if (hr == 0) return 0;
+            create = null; resize = null; close = null;
+            ConsoleKind = "windows (conpty.dll failed: 0x" + hr.ToString("X8") + ")";
+        }
+        return KernelCreatePseudoConsole(size, hInput, hOutput, dwFlags, out phPC);
+    }
+    public static int ResizePseudoConsole(IntPtr hPC, Coord size) { return resize != null ? resize(hPC, size) : KernelResizePseudoConsole(hPC, size); }
+    public static void ClosePseudoConsole(IntPtr hPC) { if (close != null) close(hPC); else KernelClosePseudoConsole(hPC); }
+
+    [DllImport("kernel32.dll", EntryPoint = "CreatePseudoConsole")] static extern int KernelCreatePseudoConsole(Coord size, SafeFileHandle hInput, SafeFileHandle hOutput, uint dwFlags, out IntPtr phPC);
+    [DllImport("kernel32.dll", EntryPoint = "ResizePseudoConsole")] static extern int KernelResizePseudoConsole(IntPtr hPC, Coord size);
+    [DllImport("kernel32.dll", EntryPoint = "ClosePseudoConsole")] static extern void KernelClosePseudoConsole(IntPtr hPC);
+    [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)] static extern IntPtr LoadLibraryW(string path);
+    [DllImport("kernel32.dll", CharSet = CharSet.Ansi, BestFitMapping = false)] static extern IntPtr GetProcAddress(IntPtr module, string name);
     [DllImport("kernel32.dll", SetLastError = true)] public static extern bool CreatePipe(out SafeFileHandle hReadPipe, out SafeFileHandle hWritePipe, IntPtr lpPipeAttributes, int nSize);
     [DllImport("kernel32.dll", SetLastError = true)] static extern bool InitializeProcThreadAttributeList(IntPtr lpAttributeList, int dwAttributeCount, int dwFlags, ref IntPtr lpSize);
     [DllImport("kernel32.dll", SetLastError = true)] static extern bool UpdateProcThreadAttribute(IntPtr lpAttributeList, uint dwFlags, IntPtr attribute, IntPtr lpValue, IntPtr cbSize, IntPtr lpPreviousValue, IntPtr lpReturnSize);