windows-development-sandbox 1.10.0 → 1.11.3

package/native/csharp/HcsHost/AssemblyInfo.cs

@@ -8,7 +8,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyCompany("windows-development-sandbox (open source)")]
 [assembly: AssemblyProduct("Windows Development Sandbox")]
 [assembly: AssemblyCopyright("MIT License, windows-development-sandbox contributors")]
-[assembly: AssemblyVersion("1.10.0.0")]
-[assembly: AssemblyFileVersion("1.10.0.0")]
-[assembly: AssemblyInformationalVersion("1.10.0")]
+[assembly: AssemblyVersion("1.11.3.0")]
+[assembly: AssemblyFileVersion("1.11.3.0")]
+[assembly: AssemblyInformationalVersion("1.11.3")]
 [assembly: ComVisible(false)]

package/native/csharp/HostTools/AssemblyInfo.cs

@@ -8,7 +8,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyCompany("windows-development-sandbox (open source)")]
 [assembly: AssemblyProduct("Windows Development Sandbox")]
 [assembly: AssemblyCopyright("MIT License, windows-development-sandbox contributors")]
-[assembly: AssemblyVersion("1.10.0.0")]
-[assembly: AssemblyFileVersion("1.10.0.0")]
-[assembly: AssemblyInformationalVersion("1.10.0")]
+[assembly: AssemblyVersion("1.11.3.0")]
+[assembly: AssemblyFileVersion("1.11.3.0")]
+[assembly: AssemblyInformationalVersion("1.11.3")]
 [assembly: ComVisible(false)]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windows-development-sandbox",
-  "version": "1.10.0",
+  "version": "1.11.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",
@@ -42,7 +42,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/bundle.mjs && node scripts/bundle-web.mjs && node scripts/schemas.mjs",
+    "build": "tsc -p tsconfig.json && tsc -p web/tsconfig.json --noEmit && node scripts/bundle.mjs && node scripts/bundle-web.mjs && node scripts/schemas.mjs",
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "rebuild": "npm run clean && npm run build",
     "test": "npm run build && node dist/bin/agent-sandbox.js self-test",
@@ -55,7 +55,9 @@
     "doctor": "node dist/bin/agent-sandbox.js doctor",
     "lint": "eslint src scripts web",
     "format": "prettier --write src scripts web",
-    "format:check": "prettier --check src scripts web"
+    "format:check": "prettier --check src scripts web",
+    "web:preview": "node dist/selftest/support/web-preview.js",
+    "web:shots": "node scripts/web-shots.mjs"
   },
   "publishConfig": {
     "access": "public"
@@ -98,6 +100,7 @@
     "@mantine/hooks": "^7.17.8",
     "@mantine/modals": "^7.17.8",
     "@mantine/notifications": "^7.17.8",
+    "@mantine/spotlight": "7.17.8",
     "@tabler/icons-react": "^3.49.0",
     "@tanstack/react-query": "^5.104.3",
     "@types/lodash": "^4.17.26",
@@ -106,10 +109,14 @@
     "@types/react-dom": "^18.3.7",
     "@types/ws": "^8.18.2",
     "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-search": "0.16.0",
+    "@xterm/addon-unicode11": "0.9.0",
+    "@xterm/addon-web-links": "0.12.0",
     "@xterm/xterm": "^6.0.0",
     "esbuild": "^0.28.2",
     "eslint": "^9.39.5",
     "mantine-form-zod-resolver": "^1.3.0",
+    "playwright-core": "1.63.0",
     "prettier": "^3.9.10",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",

package/sandbox/csharp/MemGov.cs

@@ -35,6 +35,24 @@ static class MemGov
     private const uint IdleClass = 0x00000040;
     private const uint BelowNormalClass = 0x00004000;
     private const uint NormalClass = 0x00000020;
+    // The throttle job: compilers join it from the governor's step 2; its CPU cap follows the dial.
+    private const string ThrottleJobName = "Local\\AgentSandboxBuildThrottle";
+    private const uint ProcessTerminate = 0x0001;
+    private const uint ProcessSetQuota = 0x0100;
+    private const int JobObjectCpuRateControlInformation = 15;
+    private const uint CpuRateEnable = 0x1;
+    private const uint CpuRateHardCap = 0x4;
+    private const int ProcessMemoryPriorityClass = 0;
+    private const uint MemoryPriorityLow = 2;
+    private const uint MemoryPriorityNormal = 5;
+
+    // JOBOBJECT_CPU_RATE_CONTROL_INFORMATION (CpuRate in hundredths of a percent).
+    [StructLayout(LayoutKind.Sequential)]
+    private struct CpuRateControl
+    {
+        public uint ControlFlags;
+        public uint CpuRate;
+    }
 
     // MEMORYSTATUSEX.
     [StructLayout(LayoutKind.Sequential)]
@@ -51,6 +69,23 @@ static class MemGov
         public ulong AvailExtendedVirtual;
     }
 
+    // PROCESS_MEMORY_COUNTERS_EX (PrivateUsage is the private memory Process.PrivateMemorySize64 reported).
+    [StructLayout(LayoutKind.Sequential)]
+    private struct MemoryCounters
+    {
+        public uint Size;
+        public uint PageFaultCount;
+        public UIntPtr PeakWorkingSetSize;
+        public UIntPtr WorkingSetSize;
+        public UIntPtr QuotaPeakPagedPoolUsage;
+        public UIntPtr QuotaPagedPoolUsage;
+        public UIntPtr QuotaPeakNonPagedPoolUsage;
+        public UIntPtr QuotaNonPagedPoolUsage;
+        public UIntPtr PagefileUsage;
+        public UIntPtr PeakPagefileUsage;
+        public UIntPtr PrivateUsage;
+    }
+
     private static class NativeMethods
     {
         [DllImport("kernel32.dll", SetLastError = true)]
@@ -77,6 +112,27 @@ static class MemGov
         [DllImport("kernel32.dll", SetLastError = true)]
         public static extern bool CloseHandle(IntPtr handle);
 
+        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        public static extern IntPtr CreateJobObjectW(IntPtr attributes, string name);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool SetInformationJobObject(IntPtr job, int infoClass, ref CpuRateControl info, int length);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool SetProcessInformation(IntPtr process, int infoClass, ref uint info, int length);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool SetProcessWorkingSetSize(IntPtr process, IntPtr minimum, IntPtr maximum);
+
+        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        public static extern bool QueryFullProcessImageNameW(IntPtr process, uint flags, StringBuilder name, ref uint size);
+
+        [DllImport("kernel32.dll", EntryPoint = "K32GetProcessMemoryInfo", SetLastError = true)]
+        public static extern bool GetProcessMemoryInfo(IntPtr process, ref MemoryCounters counters, uint size);
+
         [DllImport("ntdll.dll")]
         public static extern int NtSuspendProcess(IntPtr process);
 
@@ -90,6 +146,7 @@ static class MemGov
     /// <summary>The paused process ids on disk, so a memgov that is killed mid-pause is undone by the next one.</summary>
     private static readonly string HeldFile = Path.Combine(Path.GetTempPath(), "agent-sandbox-memgov-held.txt");
     private static IntPtr job = IntPtr.Zero;
+    private static IntPtr throttleJob = IntPtr.Zero;
     private static volatile bool stop;
 
     static int Main(string[] args)
@@ -113,6 +170,8 @@ static class MemGov
         }
         // A memgov that ended without resuming (killed, crashed) left its pauses in the file: undo them first.
         RecoverHeld();
+        // A memgov that ended while compilers were capped left the cap: lift it before anything else.
+        SetCpuRate(100);
         Thread commands = new Thread(ReadCommands);
         commands.IsBackground = true;
         commands.Start();
@@ -136,15 +195,28 @@ static class MemGov
             }
         }
         ResumeAll();
+        SetCpuRate(100);
         return 0;
     }
 
+    /// <summary>The self-test's own job (MEMGOV_JOB_NAME, a name in the agents' job family), or null.</summary>
+    private static string TestJobName()
+    {
+        string name = Environment.GetEnvironmentVariable("MEMGOV_JOB_NAME");
+        return !string.IsNullOrEmpty(name) && name.StartsWith(AgentJobName + "Test", StringComparison.Ordinal) ? name : null;
+    }
+
+    private static string JobName()
+    {
+        return TestJobName() ?? AgentJobName;
+    }
+
     /// <summary>The job, opened once it exists (ptyhost makes it when the first agent starts).</summary>
     private static IntPtr Job()
     {
         if (job == IntPtr.Zero)
         {
-            job = NativeMethods.OpenJobObjectW(JobObjectQuery, false, AgentJobName);
+            job = NativeMethods.OpenJobObjectW(JobObjectQuery, false, JobName());
         }
         return job;
     }
@@ -164,36 +236,70 @@ static class MemGov
         sb.Append(",\"commitAvailMb\":").Append(Mb(status.AvailPageFile));
         sb.Append(",\"procs\":[");
         bool first = true;
-        int self = Process.GetCurrentProcess().Id;
+        int self = SelfId;
         foreach (int pid in JobProcessIds())
         {
             if (pid == self)
             {
                 continue;
             }
-            try
+            // Read everything first: a process that ends half way must not leave half an entry behind.
+            string entry = Entry(pid);
+            if (entry == null)
             {
-                using (Process p = Process.GetProcessById(pid))
-                {
-                    if (!first)
-                    {
-                        sb.Append(',');
-                    }
-                    first = false;
-                    sb.Append("{\"pid\":").Append(pid.ToString(CultureInfo.InvariantCulture));
-                    sb.Append(",\"name\":").Append(Json(p.ProcessName));
-                    sb.Append(",\"mb\":").Append(Mb((ulong)p.PrivateMemorySize64));
-                    sb.Append(",\"prio\":\"").Append(PriorityName(pid)).Append("\"}");
-                }
+                continue;
             }
-            catch (Exception)
+            if (!first)
             {
-                // The process ended while it was read.
+                sb.Append(',');
             }
+            first = false;
+            sb.Append(entry);
         }
         return sb.Append("]}").ToString();
     }
 
+    private static readonly int SelfId = Process.GetCurrentProcess().Id;
+
+    /// <summary>
+    /// One process's line, read through one handle: its name, private memory and priority (null when it ended). Not
+    /// System.Diagnostics.Process, which reads the whole system's process list for every process it opens: with a
+    /// build's dozens of processes every two seconds that alone kept a CPU busy.
+    /// </summary>
+    private static string Entry(int pid)
+    {
+        IntPtr process = NativeMethods.OpenProcess(ProcessQueryLimited, false, pid);
+        if (process == IntPtr.Zero)
+        {
+            return null;
+        }
+        try
+        {
+            StringBuilder path = new StringBuilder(1024);
+            uint size = (uint)path.Capacity;
+            if (!NativeMethods.QueryFullProcessImageNameW(process, 0, path, ref size))
+            {
+                return null;
+            }
+            MemoryCounters counters = new MemoryCounters();
+            counters.Size = (uint)Marshal.SizeOf(typeof(MemoryCounters));
+            if (!NativeMethods.GetProcessMemoryInfo(process, ref counters, counters.Size))
+            {
+                return null;
+            }
+            uint c = NativeMethods.GetPriorityClass(process);
+            string priority = c == IdleClass ? "idle" : c == BelowNormalClass ? "below" : "normal";
+            return "{\"pid\":" + pid.ToString(CultureInfo.InvariantCulture)
+                + ",\"name\":" + Json(Path.GetFileNameWithoutExtension(path.ToString(0, (int)size)))
+                + ",\"mb\":" + Mb(counters.PrivateUsage.ToUInt64())
+                + ",\"prio\":\"" + priority + "\"}";
+        }
+        finally
+        {
+            NativeMethods.CloseHandle(process);
+        }
+    }
+
     private static List<int> JobProcessIds()
     {
         List<int> ids = new List<int>();
@@ -224,28 +330,10 @@ static class MemGov
         return ids;
     }
 
-    private static string PriorityName(int pid)
-    {
-        IntPtr process = NativeMethods.OpenProcess(ProcessQueryLimited, false, pid);
-        if (process == IntPtr.Zero)
-        {
-            return "normal";
-        }
-        try
-        {
-            uint c = NativeMethods.GetPriorityClass(process);
-            return c == IdleClass ? "idle" : c == BelowNormalClass ? "below" : "normal";
-        }
-        finally
-        {
-            NativeMethods.CloseHandle(process);
-        }
-    }
-
     /// <summary>Whether pid is a process of the agents' job and not this one: the only ones this program touches.</summary>
     private static bool Allowed(int pid)
     {
-        return pid != Process.GetCurrentProcess().Id && JobProcessIds().Contains(pid);
+        return pid != SelfId && JobProcessIds().Contains(pid);
     }
 
     private static void ReadCommands()
@@ -277,12 +365,39 @@ static class MemGov
             stop = true;
             return;
         }
+        if (parts.Length == 2 && parts[0] == "cpurate")
+        {
+            int percent;
+            if (int.TryParse(parts[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out percent))
+            {
+                SetCpuRate(percent);
+            }
+            return;
+        }
         int pid;
-        if (parts.Length < 3 || !int.TryParse(parts[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out pid) || !Allowed(pid))
+        if (parts.Length < 2 || !int.TryParse(parts[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out pid) || !Allowed(pid))
+        {
+            return;
+        }
+        if (parts[0] == "throttle")
+        {
+            Throttle(pid);
+            return;
+        }
+        if (parts[0] == "trim")
+        {
+            Trim(pid);
+            return;
+        }
+        if (parts.Length < 3)
         {
             return;
         }
-        if (parts[0] == "priority")
+        if (parts[0] == "memprio")
+        {
+            SetMemoryPriority(pid, parts[2] == "low" ? MemoryPriorityLow : MemoryPriorityNormal);
+        }
+        else if (parts[0] == "priority")
         {
             uint cls = parts[2] == "idle" ? IdleClass : parts[2] == "below" ? BelowNormalClass : NormalClass;
             IntPtr process = NativeMethods.OpenProcess(ProcessSetInformation, false, pid);
@@ -303,6 +418,93 @@ static class MemGov
         }
     }
 
+    /// <summary>The throttle job, made once. A process already in the agents' job is nested in it (Windows 8+).</summary>
+    private static IntPtr ThrottleJob()
+    {
+        if (throttleJob == IntPtr.Zero)
+        {
+            string test = TestJobName();
+            throttleJob = NativeMethods.CreateJobObjectW(IntPtr.Zero, test != null ? test + "Throttle" : ThrottleJobName);
+        }
+        return throttleJob;
+    }
+
+    /// <summary>The CPU cap of the compilers in the throttle job, percent of the sandbox; 100 or more lifts it.</summary>
+    private static void SetCpuRate(int percent)
+    {
+        IntPtr throttle = ThrottleJob();
+        if (throttle == IntPtr.Zero)
+        {
+            return;
+        }
+        CpuRateControl info = new CpuRateControl();
+        if (percent < 100)
+        {
+            info.ControlFlags = CpuRateEnable | CpuRateHardCap;
+            info.CpuRate = (uint)(Math.Max(1, percent) * 100);
+        }
+        NativeMethods.SetInformationJobObject(throttle, JobObjectCpuRateControlInformation, ref info, Marshal.SizeOf(typeof(CpuRateControl)));
+    }
+
+    private static void Throttle(int pid)
+    {
+        IntPtr throttle = ThrottleJob();
+        if (throttle == IntPtr.Zero)
+        {
+            return;
+        }
+        IntPtr process = NativeMethods.OpenProcess(ProcessSetQuota | ProcessTerminate, false, pid);
+        if (process == IntPtr.Zero)
+        {
+            return;
+        }
+        try
+        {
+            NativeMethods.AssignProcessToJobObject(throttle, process);
+        }
+        finally
+        {
+            NativeMethods.CloseHandle(process);
+        }
+    }
+
+    /// <summary>Low memory priority: Windows trims this process's pages before others' (the agents keep theirs).</summary>
+    private static void SetMemoryPriority(int pid, uint priority)
+    {
+        IntPtr process = NativeMethods.OpenProcess(ProcessSetInformation, false, pid);
+        if (process == IntPtr.Zero)
+        {
+            return;
+        }
+        try
+        {
+            uint value = priority;
+            NativeMethods.SetProcessInformation(process, ProcessMemoryPriorityClass, ref value, sizeof(uint));
+        }
+        finally
+        {
+            NativeMethods.CloseHandle(process);
+        }
+    }
+
+    /// <summary>A waiting compiler's pages go to the paging file now, so the ones that run have the RAM.</summary>
+    private static void Trim(int pid)
+    {
+        IntPtr process = NativeMethods.OpenProcess(ProcessSetQuota, false, pid);
+        if (process == IntPtr.Zero)
+        {
+            return;
+        }
+        try
+        {
+            NativeMethods.SetProcessWorkingSetSize(process, new IntPtr(-1), new IntPtr(-1));
+        }
+        finally
+        {
+            NativeMethods.CloseHandle(process);
+        }
+    }
+
     private static void Suspend(int pid, int ms)
     {
         lock (Gate)

package/sandbox/csharp/PtyHost.cs

@@ -432,7 +432,17 @@ sealed class ClientHub
                 clients.Add(client);
             }
         }
-        TakeOwnership(client);
+        // Passed through, a size change makes the program redraw for everyone (a second copy of the screen in some),
+        // so a viewer that only looks leaves the size to the one in use; it takes over when it types or is resized.
+        bool owned;
+        lock (gate)
+        {
+            owned = sizeOwner != null;
+        }
+        if (!passthrough || !owned)
+        {
+            TakeOwnership(client);
+        }
         return true;
     }
 
@@ -781,9 +791,11 @@ sealed class ClientHub
             return;
         }
         PseudoConsole current;
+        bool same;
         lock (gate)
         {
             current = console;
+            same = cols == width && rows == height;
             cols = width;
             rows = height;
         }
@@ -791,7 +803,18 @@ sealed class ClientHub
         {
             return;
         }
-        // ConPTY repaints everything on a size change; resizing by one row first forces that even for the same size.
+        if (Native.ConsoleKind.StartsWith("conpty"))
+        {
+            // Passed through: nothing repaints, the program redraws itself on every resize. Programs like Claude Code
+            // leave a second copy of their screen behind when they do, so resize only when the size really changes.
+            if (!same)
+            {
+                current.Resize(width, height);
+            }
+            return;
+        }
+        // Windows' own ConPTY repaints everything on a size change; resizing by one row first forces that even for the
+        // same size.
         current.Resize(width, (short)(height - 1));
         current.Resize(width, height);
     }
@@ -1090,6 +1113,10 @@ static class Native
     private const string AgentJobName = "Local\\AgentSandboxAgentsJob";
     private const int JobObjectExtendedLimitInformation = 9;
     private const uint JobObjectLimitJobMemory = 0x00000200;
+    private const int ErrorAlreadyExists = 183;
+    /// <summary>The backstop's headroom for "auto": this much of the commit limit, at least MinHeadroomMb.</summary>
+    private const int HeadroomPercent = 3;
+    private const long MinHeadroomMb = 1536;
     private const long BytesPerMb = 1024L * 1024L;
     private const int UseStdHandles = 0x00000100;
     private static readonly IntPtr PseudoConsoleAttribute = (IntPtr)0x00020016;
@@ -1157,6 +1184,21 @@ static class Native
         public ulong OtherTransferCount;
     }
 
+    // MEMORYSTATUSEX: ullTotalPageFile is the commit limit (RAM plus paging files).
+    [StructLayout(LayoutKind.Sequential)]
+    private struct MemoryStatus
+    {
+        public uint Length;
+        public uint MemoryLoad;
+        public ulong TotalPhys;
+        public ulong AvailPhys;
+        public ulong TotalPageFile;
+        public ulong AvailPageFile;
+        public ulong TotalVirtual;
+        public ulong AvailVirtual;
+        public ulong AvailExtendedVirtual;
+    }
+
     [StructLayout(LayoutKind.Sequential)]
     private struct JobExtendedLimit
     {
@@ -1228,6 +1270,9 @@ static class Native
         [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
         public static extern IntPtr CreateJobObjectW(IntPtr attributes, string name);
 
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool GlobalMemoryStatusEx(ref MemoryStatus status);
+
         [DllImport("kernel32.dll", SetLastError = true)]
         public static extern bool SetInformationJobObject(IntPtr job, int infoClass, ref JobExtendedLimit info, int length);
 
@@ -1300,10 +1345,12 @@ static class Native
     private static bool agentJobTried;
 
     /// <summary>
-    /// The shared job of everything the agents start, with a memory limit for all of it together (PTYHOST_JOB_MB, set
-    /// by the daemon from sandbox.agentMemoryHeadroomMb): a runaway build then gets out-of-memory errors in its own
-    /// session instead of using up the whole sandbox. Zero when no limit is asked for or the job cannot be made; ptyhost
-    /// itself is never in it. The handle stays open for ptyhost's whole life (the job lives while a handle is open).
+    /// The shared job of everything the agents start (the governor reads it to slow builds down). Its only limit is a
+    /// last-resort backstop: the sandbox's commit limit minus a small headroom (PTYHOST_BACKSTOP_MB: "auto", a number
+    /// of MB, or "none"). The job's committed memory is part of the whole sandbox's, so it can reach the backstop only
+    /// when Windows inside the sandbox is about to refuse memory to everyone; then a build is refused instead of
+    /// Windows' own processes. Only the ptyhost that creates the job sets it: one that joins it never changes it.
+    /// ptyhost itself is never in it; the handle stays open for ptyhost's whole life.
     /// </summary>
     private static IntPtr AgentJob(Log log)
     {
@@ -1312,31 +1359,73 @@ static class Native
             return agentJob;
         }
         agentJobTried = true;
-        long limitMb;
-        if (!long.TryParse(Environment.GetEnvironmentVariable("PTYHOST_JOB_MB"), out limitMb) || limitMb < 512)
+        string setting = Environment.GetEnvironmentVariable("PTYHOST_BACKSTOP_MB");
+        if (string.IsNullOrEmpty(setting))
         {
             return IntPtr.Zero;
         }
-        IntPtr job = NativeMethods.CreateJobObjectW(IntPtr.Zero, AgentJobName);
+        // The self-test uses a job of its own (a name in the same family), never the agents' real one.
+        string name = Environment.GetEnvironmentVariable("PTYHOST_JOB_NAME");
+        if (string.IsNullOrEmpty(name) || !name.StartsWith(AgentJobName + "Test", StringComparison.Ordinal))
+        {
+            name = AgentJobName;
+        }
+        IntPtr job = NativeMethods.CreateJobObjectW(IntPtr.Zero, name);
+        int error = Marshal.GetLastWin32Error();
         if (job == IntPtr.Zero)
         {
-            log.Write("agent job: CreateJobObject failed (" + Marshal.GetLastWin32Error() + "); no memory limit");
+            log.Write("agent job: CreateJobObject failed (" + error + "); agents run outside it");
             return IntPtr.Zero;
         }
+        agentJob = job;
+        if (error == ErrorAlreadyExists)
+        {
+            log.Write("agent job: joined the existing one (its backstop stays as it was set)");
+            return job;
+        }
+        if (setting == "none")
+        {
+            log.Write("agent job: no backstop (sandbox.agentMemoryHeadroomMb is none)");
+            return job;
+        }
+        long commitMb;
+        long limitMb = BackstopMb(setting, out commitMb);
+        if (limitMb <= 0)
+        {
+            log.Write("agent job: the commit limit cannot be read; no backstop");
+            return job;
+        }
         JobExtendedLimit info = new JobExtendedLimit();
         info.BasicLimitInformation.LimitFlags = JobObjectLimitJobMemory;
         info.JobMemoryLimit = new UIntPtr((ulong)(limitMb * BytesPerMb));
         if (!NativeMethods.SetInformationJobObject(job, JobObjectExtendedLimitInformation, ref info, Marshal.SizeOf(typeof(JobExtendedLimit))))
         {
-            log.Write("agent job: setting the limit failed (" + Marshal.GetLastWin32Error() + "); no memory limit");
-            NativeMethods.CloseHandle(job);
-            return IntPtr.Zero;
+            log.Write("agent job: setting the backstop failed (" + Marshal.GetLastWin32Error() + "); no backstop");
+            return job;
         }
-        log.Write("agent job: everything the agent starts may use " + limitMb + " MB together");
-        agentJob = job;
+        log.Write("agent job: last-resort backstop at " + limitMb + " MB committed (the sandbox's commit limit is " + commitMb + " MB)");
         return job;
     }
 
+    /// <summary>The commit limit minus the headroom ("auto" or MB), at least half of it; 0 when it cannot be read.</summary>
+    private static long BackstopMb(string setting, out long commitMb)
+    {
+        commitMb = 0;
+        MemoryStatus status = new MemoryStatus();
+        status.Length = (uint)Marshal.SizeOf(typeof(MemoryStatus));
+        if (!NativeMethods.GlobalMemoryStatusEx(ref status))
+        {
+            return 0;
+        }
+        commitMb = (long)(status.TotalPageFile / (ulong)BytesPerMb);
+        long headroom;
+        if (setting == "auto" || !long.TryParse(setting, out headroom) || headroom < 0)
+        {
+            headroom = Math.Max(MinHeadroomMb, commitMb * HeadroomPercent / 100);
+        }
+        return Math.Max(commitMb / 2, commitMb - headroom);
+    }
+
     /// <summary>Starts `commandLine` attached to the pseudo console. Null std handles: never leak our own stdio into the child.</summary>
     public static IntPtr Spawn(string commandLine, IntPtr pseudoConsole, Log log)
     {