windows-development-sandbox 1.7.0 → 1.10.0

package/dist/cli/tui/app.d.ts

@@ -9,16 +9,21 @@ import { Terminal } from './terminal.js';
 import type { Screen } from './screen.js';
 export declare class App {
     readonly terminal: Terminal;
-    /** The status line for screens that do not set their own (refreshed on every draw). */
+    /** The status line for screens that do not set their own (read on every draw: it must not wait for anything). */
     status: () => string;
+    /** Awaited after an action changed something, before the screen loads what it shows again. */
+    afterAction: () => Promise<void>;
     /** The navigation on the left of every screen (none: no navigation column). */
     nav: () => NavState | undefined;
     /** The screens being shown, innermost last: a dialog is drawn over the one below it. */
     private readonly shown;
     private redrawNow;
+    private redrawTimer;
     constructor(terminal?: Terminal);
     /** Draws the screen on top again now (before a slow piece of work, so its notice is visible). */
     redraw(): void;
+    /** Draws it again soon: what happens between two keys (a resize, fresh facts) is drawn once, not once each. */
+    requestRedraw(): void;
     /** Shows `screen` until its handler says it is done, and returns what it returned. */
     show<T>(screen: Screen<T>): Promise<T>;
     /** A dialog over the screen below (Save / Discard / Cancel, Yes / No ...). */

package/dist/cli/tui/app.js

@@ -9,22 +9,40 @@ import { Frame } from './frame.js';
 import { ListScreen } from './list/list-screen.js';
 import { Terminal } from './terminal.js';
 import { Theme } from './theme.js';
+/** Changes that arrive together (a resize, fresh facts) are drawn once, this long after the first. */
+const REDRAW_DELAY_MS = 16;
+/** While keys are waiting, the screen is still drawn at least this often. */
+const MAX_STALE_MS = 100;
 export class App {
     terminal;
-    /** The status line for screens that do not set their own (refreshed on every draw). */
+    /** The status line for screens that do not set their own (read on every draw: it must not wait for anything). */
     status = () => '';
+    /** Awaited after an action changed something, before the screen loads what it shows again. */
+    afterAction = () => Promise.resolve();
     /** The navigation on the left of every screen (none: no navigation column). */
     nav = () => undefined;
     /** The screens being shown, innermost last: a dialog is drawn over the one below it. */
     shown = [];
     redrawNow = null;
+    redrawTimer;
     constructor(terminal = new Terminal()) {
         this.terminal = terminal;
+        terminal.onResized(() => this.requestRedraw());
     }
     /** Draws the screen on top again now (before a slow piece of work, so its notice is visible). */
     redraw() {
         this.redrawNow?.();
     }
+    /** Draws it again soon: what happens between two keys (a resize, fresh facts) is drawn once, not once each. */
+    requestRedraw() {
+        if (this.redrawTimer)
+            return;
+        this.redrawTimer = setTimeout(() => {
+            this.redrawTimer = undefined;
+            if (this.terminal.running)
+                this.redrawNow?.();
+        }, REDRAW_DELAY_MS);
+    }
     /** Shows `screen` until its handler says it is done, and returns what it returned. */
     async show(screen) {
         this.terminal.start();
@@ -39,10 +57,15 @@ export class App {
             this.terminal.render(Frame.render({ ...parts, status: parts.status ?? this.status(), nav: nav && { ...nav, dimmed: nav.dimmed || covered } }, width, height));
         };
         this.redrawNow = draw;
-        this.terminal.onResized(draw);
+        let drawnAt = 0;
         try {
             for (;;) {
-                draw();
+                // Keys that are already waiting (a held arrow, a paste) are handled first: the screen shows the result of the
+                // last one, but never stays stale for longer than MAX_STALE_MS.
+                if (!this.terminal.hasKeys || Date.now() - drawnAt >= MAX_STALE_MS) {
+                    draw();
+                    drawnAt = Date.now();
+                }
                 const step = await screen.handle(await this.terminal.key());
                 if (step)
                     return step.done;
@@ -51,7 +74,6 @@ export class App {
         finally {
             this.shown.pop();
             this.redrawNow = outer;
-            this.terminal.onResized(outer);
         }
     }
     /** A dialog over the screen below (Save / Discard / Cancel, Yes / No ...). */

package/dist/cli/tui/list/list-screen.d.ts

@@ -14,11 +14,21 @@ export declare class ListScreen<T> implements Screen<ListResult<T>> {
     private searching;
     private notice;
     private readonly checked;
+    /** The entries shown for the last query and category (the items never change, so only those two matter). */
+    private shown;
+    /** What a search looks in, per entry, lowercased once. */
+    private haystacks;
     constructor(o: ListOptions<T>);
     /** Indexes of the entries shown now: all matches of the search, else the current category's, else all. */
     private visible;
+    private matching;
+    private categoryLabel;
     private rows;
     render(size: Size): FrameParts;
+    /** The rows above the list: the tabs, the intro, the search box (with a blank row after them). */
+    private topLines;
+    /** The rows of the list that fit: scrolled to keep the cursor in view, with "▲ above / ▼ more" under them. */
+    private listLines;
     private rowLine;
     private sideLines;
     private detailsLines;
@@ -40,6 +50,10 @@ export declare class ListScreen<T> implements Screen<ListResult<T>> {
     get currentCategory(): string | undefined;
     /** The extra keys that work now (they may depend on the category and on the highlighted entry). */
     private actionsNow;
+    /** The value under the cursor (undefined: the list is empty). */
+    get current(): T | undefined;
+    /** The text of the search (empty: none). */
+    get searchText(): string;
     /** Keys are going into the search box (digits and letters are text, not shortcuts). */
     get isSearching(): boolean;
     /** The entries ticked now (multi-select). */

package/dist/cli/tui/list/list-screen.js

@@ -14,9 +14,14 @@ export class ListScreen {
     searching = false;
     notice;
     checked;
+    /** The entries shown for the last query and category (the items never change, so only those two matter). */
+    shown;
+    /** What a search looks in, per entry, lowercased once. */
+    haystacks;
     constructor(o) {
         this.o = o;
         this.notice = o.notice;
+        this.query = o.startQuery ?? '';
         this.checked = new Set(o.items.flatMap((item, i) => (item.checked ? [i] : [])));
         const start = o.startAt === undefined ? -1 : o.items.findIndex((item) => item.value === o.startAt);
         const startCategory = start >= 0 ? o.items[start].category : o.startCategory;
@@ -27,21 +32,26 @@ export class ListScreen {
     }
     /** Indexes of the entries shown now: all matches of the search, else the current category's, else all. */
     visible() {
+        const key = this.query + '\0' + this.category;
+        if (this.shown?.key !== key)
+            this.shown = { key, indexes: this.matching() };
+        return this.shown.indexes;
+    }
+    matching() {
         const all = this.o.items.map((_, i) => i);
         if (this.query.trim()) {
             const words = this.query.toLowerCase().split(/\s+/).filter(Boolean);
-            const label = (id) => this.o.categories?.find((c) => c.id === id)?.label ?? '';
-            return all.filter((i) => {
-                const it = this.o.items[i];
-                const hay = [it.label, Text.strip(it.hint ?? ''), it.description, it.keywords, it.section, label(it.category)]
-                    .join(' ')
-                    .toLowerCase();
-                return words.every((w) => hay.includes(w));
-            });
+            const hays = (this.haystacks ??= this.o.items.map((it) => [it.label, Text.strip(it.hint ?? ''), it.description, it.keywords, it.section, this.categoryLabel(it.category)]
+                .join(' ')
+                .toLowerCase()));
+            return all.filter((i) => words.every((w) => hays[i].includes(w)));
         }
         const cat = this.o.categories?.[this.category];
         return cat ? all.filter((i) => this.o.items[i].category === cat.id) : all;
     }
+    categoryLabel(id) {
+        return this.o.categories?.find((c) => c.id === id)?.label ?? '';
+    }
     rows(visible) {
         const rows = [];
         let section;
@@ -49,7 +59,7 @@ export class ListScreen {
         for (const index of visible) {
             const it = this.o.items[index];
             const heading = searchAll
-                ? [this.o.categories?.find((c) => c.id === it.category)?.label, it.section].filter(Boolean).join(' › ')
+                ? [this.categoryLabel(it.category), it.section].filter(Boolean).join(' › ')
                 : it.section;
             if (heading && heading !== section)
                 rows.push({ kind: 'section', text: heading });
@@ -68,6 +78,35 @@ export class ListScreen {
         const detailsRight = rest >= 100;
         const detailsWidth = detailsRight ? Math.min(52, Math.floor(rest * 0.38)) : rest;
         const listWidth = detailsRight ? rest - detailsWidth - 3 : rest;
+        const top = this.topLines(size.width, visible.length);
+        const details = this.detailsLines(visible[this.cursor], detailsWidth);
+        const bottomDetails = !detailsRight && size.height - top.length >= 14 ? details.slice(0, 6) : [];
+        const rows = this.rows(visible);
+        const room = size.height - top.length - (bottomDetails.length ? bottomDetails.length + 1 : 0);
+        // A list longer than the room keeps one row for "▲ / ▼ more".
+        const listHeight = rows.length > room ? room - 1 : room;
+        const listLines = this.listLines(visible, rows, listHeight, listWidth);
+        const sideLines = sideWidth ? this.sideLines(sideWidth) : [];
+        const body = [...top];
+        const height = Math.max(listLines.length, detailsRight ? details.length : 0, sideLines.length);
+        for (let i = 0; i < Math.min(height, size.height - top.length); i++) {
+            const side = sideWidth ? Text.fit(sideLines[i] ?? '', sideWidth) + ' ' + Theme.dim(Theme.glyph.vline) + ' ' : '';
+            const main = Text.fit(listLines[i] ?? '', listWidth);
+            const right = detailsRight ? ' ' + Theme.dim(Theme.glyph.vline) + ' ' + (details[i] ?? '') : '';
+            body.push(side + main + right);
+        }
+        if (bottomDetails.length) {
+            // The details sit at the bottom, whatever the length of the list.
+            while (body.length < size.height - bottomDetails.length - 1)
+                body.push(sideWidth
+                    ? Text.fit(sideLines[body.length - top.length] ?? '', sideWidth) + ' ' + Theme.dim(Theme.glyph.vline)
+                    : '');
+            body.push(Theme.dim(' ' + Theme.glyph.line.repeat(size.width - 3)), ...bottomDetails.map((l) => ' ' + l));
+        }
+        return { path: this.o.path, status: this.o.status, body, keys: this.keys(), notice: this.notice };
+    }
+    /** The rows above the list: the tabs, the intro, the search box (with a blank row after them). */
+    topLines(width, matches) {
         const top = [];
         if (this.o.tabs) {
             const row = ' ' +
@@ -77,26 +116,24 @@ export class ListScreen {
                     : Theme.muted('  ' + tab.label + '  '))
                     .join(' ') +
                 Theme.muted('   tab switches');
-            top.push(Text.truncate(row, size.width - 1), '');
+            top.push(Text.truncate(row, width - 1), '');
         }
         const intro = typeof this.o.intro === 'string' ? [this.o.intro] : (this.o.intro ?? []);
         for (const line of intro)
-            top.push(...Text.wrap(line, size.width - 3).map((l) => ' ' + Theme.muted(l)));
+            top.push(...Text.wrap(line, width - 3).map((l) => ' ' + Theme.muted(l)));
         if (this.searching || this.query)
             top.push(' ' +
                 Theme.accent(Theme.glyph.search) +
                 ' ' +
                 this.query +
                 (this.searching ? Theme.accent('▏') : '') +
-                Theme.muted('   ' + visible.length + ' match' + (visible.length === 1 ? '' : 'es')));
+                Theme.muted('   ' + matches + ' match' + (matches === 1 ? '' : 'es')));
         if (top.length)
             top.push('');
-        const details = this.detailsLines(visible[this.cursor], detailsWidth);
-        const bottomDetails = !detailsRight && size.height - top.length >= 14 ? details.slice(0, 6) : [];
-        const rows = this.rows(visible);
-        const room = size.height - top.length - (bottomDetails.length ? bottomDetails.length + 1 : 0);
-        // A list longer than the room keeps one row for "▲ / ▼ more".
-        const listHeight = rows.length > room ? room - 1 : room;
+        return top;
+    }
+    /** The rows of the list that fit: scrolled to keep the cursor in view, with "▲ above / ▼ more" under them. */
+    listLines(visible, rows, listHeight, listWidth) {
         const cursorRow = rows.findIndex((r) => r.kind === 'item' && r.index === visible[this.cursor]);
         if (cursorRow >= 0) {
             // Keep the heading above the first entry in view, and the cursor inside the window.
@@ -122,24 +159,7 @@ export class ListScreen {
                 (below > 0 ? '▼ ' + below + ' more' : '') +
                 (this.searching || this.query ? '' : '   / search')));
         }
-        const sideLines = sideWidth ? this.sideLines(sideWidth) : [];
-        const body = [...top];
-        const height = Math.max(listLines.length, detailsRight ? details.length : 0, sideLines.length);
-        for (let i = 0; i < Math.min(height, size.height - top.length); i++) {
-            const side = sideWidth ? Text.fit(sideLines[i] ?? '', sideWidth) + ' ' + Theme.dim(Theme.glyph.vline) + ' ' : '';
-            const main = Text.fit(listLines[i] ?? '', listWidth);
-            const right = detailsRight ? ' ' + Theme.dim(Theme.glyph.vline) + ' ' + (details[i] ?? '') : '';
-            body.push(side + main + right);
-        }
-        if (bottomDetails.length) {
-            // The details sit at the bottom, whatever the length of the list.
-            while (body.length < size.height - bottomDetails.length - 1)
-                body.push(sideWidth
-                    ? Text.fit(sideLines[body.length - top.length] ?? '', sideWidth) + ' ' + Theme.dim(Theme.glyph.vline)
-                    : '');
-            body.push(Theme.dim(' ' + Theme.glyph.line.repeat(size.width - 3)), ...bottomDetails.map((l) => ' ' + l));
-        }
-        return { path: this.o.path, status: this.o.status, body, keys: this.keys(), notice: this.notice };
+        return listLines;
     }
     rowLine(row, visible, width) {
         if (row.kind === 'section')
@@ -283,6 +303,14 @@ export class ListScreen {
         const all = typeof actions === 'function' ? actions(this.currentCategory) : (actions ?? []);
         return all.filter((a) => !a.applies || (value !== undefined && a.applies(value)));
     }
+    /** The value under the cursor (undefined: the list is empty). */
+    get current() {
+        return this.valueAt(this.visible()[this.cursor]);
+    }
+    /** The text of the search (empty: none). */
+    get searchText() {
+        return this.query;
+    }
     /** Keys are going into the search box (digits and letters are text, not shortcuts). */
     get isSearching() {
         return this.searching;

package/dist/cli/tui/list/list-types.d.ts

@@ -71,6 +71,8 @@ export interface ListOptions<T> {
     /** Start on this entry (and its category). */
     startAt?: T;
     startCategory?: string;
+    /** Start with this search typed (it shows every match in all categories; Esc clears it). */
+    startQuery?: string;
     /** Extra keys; a function picks them by the open category. */
     actions?: ListAction<T>[] | ((category: string | undefined) => ListAction<T>[]);
     notice?: string;

package/dist/cli/tui/terminal.d.ts

@@ -10,6 +10,8 @@ export interface Key {
 export declare class ExitRequested extends Error {
     constructor();
 }
+/** Whether this terminal is known to take synchronized updates (AGENT_SANDBOX_SYNC_UPDATE=1 or 0 overrides). */
+export declare function supportsSyncUpdate(env?: NodeJS.ProcessEnv): boolean;
 export declare class Terminal {
     private readonly stdin;
     private readonly stdout;
@@ -18,17 +20,22 @@ export declare class Terminal {
     private queue;
     private waiting;
     private resizeHandler;
+    private readonly sync;
     private readonly onKeypress;
     private readonly onResize;
     constructor(stdin?: NodeJS.ReadStream, stdout?: NodeJS.WriteStream);
     get width(): number;
     get height(): number;
+    /** Keys can be read from a real terminal here (the menu refuses to open without one). */
+    get interactive(): boolean;
     /** Called after the window was resized (the screen draws itself again). */
     onResized(handler: (() => void) | null): void;
     start(): void;
     /** Gives the terminal back exactly as it was (also on errors: callers use try/finally). */
     stop(): void;
     get running(): boolean;
+    /** Key presses are waiting to be read (the screen may skip a draw and show the result of the last one). */
+    get hasKeys(): boolean;
     /** Draws a whole screen: `lines` are cut to the width and padded to the height; unchanged rows are not rewritten. */
     render(lines: string[]): void;
     /** The next key press. Ctrl+C rejects with ExitRequested. */

package/dist/cli/tui/terminal.js

@@ -1,6 +1,7 @@
 // The terminal while the menu owns it: the alternate screen (your scrollback stays as it was), raw keys, a cursor that
-// is hidden, and redraws that only rewrite the rows that changed (no flicker). suspend() hands the terminal back for
-// a command's own output; resume() takes it again.
+// is hidden, and redraws that only rewrite the rows that changed, in one write (inside a synchronized update where the
+// terminal has one), so nothing flickers. stop() hands the terminal back for a command's own output; start() takes it
+// again.
 import readline from 'node:readline';
 import { Text } from './text.js';
 /** Ctrl+C: leave the menu at once (callers let it propagate to the top). */
@@ -10,6 +11,17 @@ export class ExitRequested extends Error {
         this.name = 'ExitPromptError';
     }
 }
+/** DEC 2026: the terminal shows a frame only when it is complete. Others ignore it, so only these are asked. */
+const SYNC_BEGIN = '\x1b[?2026h';
+const SYNC_END = '\x1b[?2026l';
+/** Whether this terminal is known to take synchronized updates (AGENT_SANDBOX_SYNC_UPDATE=1 or 0 overrides). */
+export function supportsSyncUpdate(env = process.env) {
+    const forced = env.AGENT_SANDBOX_SYNC_UPDATE;
+    if (forced === '1' || forced === '0')
+        return forced === '1';
+    const program = env.TERM_PROGRAM ?? '';
+    return Boolean(env.WT_SESSION) || ['vscode', 'WezTerm', 'iTerm.app', 'ghostty', 'contour'].includes(program);
+}
 export class Terminal {
     stdin;
     stdout;
@@ -18,6 +30,7 @@ export class Terminal {
     queue = [];
     waiting = null;
     resizeHandler = null;
+    sync = supportsSyncUpdate();
     onKeypress = (str, key) => this.push(str, key);
     onResize = () => {
         this.frame = [];
@@ -33,6 +46,10 @@ export class Terminal {
     get height() {
         return Math.max(12, this.stdout.rows ?? 30);
     }
+    /** Keys can be read from a real terminal here (the menu refuses to open without one). */
+    get interactive() {
+        return Boolean(this.stdin.isTTY);
+    }
     /** Called after the window was resized (the screen draws itself again). */
     onResized(handler) {
         this.resizeHandler = handler;
@@ -66,21 +83,24 @@ export class Terminal {
     get running() {
         return this.active;
     }
+    /** Key presses are waiting to be read (the screen may skip a draw and show the result of the last one). */
+    get hasKeys() {
+        return this.queue.length > 0;
+    }
     /** Draws a whole screen: `lines` are cut to the width and padded to the height; unchanged rows are not rewritten. */
     render(lines) {
         const { width, height } = this;
         // One column is left free: writing the last column can scroll older consoles.
         const rows = Array.from({ length: height }, (_, i) => Text.fit(lines[i] ?? '', width - 1));
-        let out = '';
-        rows.forEach((row, i) => {
-            if (this.frame[i] !== row)
-                out += '\x1b[' + (i + 1) + ';1H' + row + '\x1b[0m';
-        });
-        if (this.frame.length !== rows.length)
-            out = '\x1b[H\x1b[2J' + rows.map((r, i) => '\x1b[' + (i + 1) + ';1H' + r + '\x1b[0m').join('');
+        // A different height (or nothing drawn yet: after a resize or a start) repaints everything.
+        const repaint = this.frame.length !== rows.length;
+        const out = (repaint ? '\x1b[H\x1b[2J' : '') +
+            rows
+                .map((row, i) => (repaint || this.frame[i] !== row ? '\x1b[' + (i + 1) + ';1H' + row + '\x1b[0m' : ''))
+                .join('');
         this.frame = rows;
         if (out)
-            this.stdout.write(out);
+            this.stdout.write(this.sync ? SYNC_BEGIN + out + SYNC_END : out);
     }
     /** The next key press. Ctrl+C rejects with ExitRequested. */
     key() {

package/dist/core/config/defaults.js

@@ -6,12 +6,15 @@ export const DEFAULTS = {
     audit: { enabled: false, days: 14, maxMb: 100, processes: true, files: true },
     mappings: [],
     sandbox: {
+        engine: 'windows-sandbox',
         memoryMb: 'auto',
         maxMemoryMb: 32768,
         maxMemoryPercent: 80,
         cpuLimit: 80,
         pageFileMb: 16384,
         reserveHostMb: 8192,
+        agentMemoryHeadroomMb: 'auto',
+        pressureResponse: true,
         vGpu: false,
         networking: true,
         clipboard: true,
@@ -28,6 +31,8 @@ export const DEFAULTS = {
         persistAgentState: true,
         dataName: 'default',
         markSandboxFiles: true,
+        contained: 'off',
+        containedMaxGb: 64,
         warnDataGb: 50,
     },
     network: { blockPrivateRanges: true, allowOnly: [], blockHosts: [], forwardPorts: [], dns: [], proxy: '' },
@@ -89,7 +94,7 @@ export const DEFAULTS = {
         sqlserver: { enabled: 'auto' },
     },
     attach: { enabled: true, reuseSession: true, auto: false, autoHide: false },
-    web: { enabled: false, port: 47800 },
+    web: { enabled: false, port: 47800, openOnLaunch: false },
     agentCommands: { enabled: false, agents: 'auto' },
     secrets: { strip: true, allow: [], patterns: [], warnFiles: true },
     personalization: { enabled: true },
@@ -126,6 +131,9 @@ export const DEFAULTS = {
             environment: {},
             home: { env: { CODEX_HOME: 'codex' }, loginFiles: ['auth.json'], hostDir: '~/.codex' },
             localState: { CODEX_SQLITE_HOME: 'sqlite' },
+            // Its own command sandbox keeps local users' passwords sealed with DPAPI: unreadable in the next sandbox
+            // ("CryptUnprotectData" on every command), so it sets that sandbox up again at each boot.
+            bootReset: ['.sandbox-secrets', '.sandbox\\setup_marker.json', '.sandbox\\deny_read_acl_state.json'],
             resumeArguments: ['resume', '--last'],
         },
         gemini: {

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

@@ -23,12 +23,18 @@ export declare const ConfigSchema: z.ZodObject<{
         optional: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>>;
     sandbox: z.ZodObject<{
+        engine: z.ZodEnum<{
+            "windows-sandbox": "windows-sandbox";
+            hcs: "hcs";
+        }>;
         memoryMb: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodNumber]>;
         maxMemoryMb: z.ZodNumber;
         maxMemoryPercent: z.ZodNumber;
         cpuLimit: z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodNumber]>;
         pageFileMb: z.ZodNumber;
         reserveHostMb: z.ZodNumber;
+        agentMemoryHeadroomMb: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodNumber]>;
+        pressureResponse: z.ZodBoolean;
         vGpu: z.ZodBoolean;
         networking: z.ZodBoolean;
         clipboard: z.ZodBoolean;
@@ -47,6 +53,11 @@ export declare const ConfigSchema: z.ZodObject<{
         persistAgentState: z.ZodBoolean;
         dataName: z.ZodString;
         markSandboxFiles: z.ZodBoolean;
+        contained: z.ZodEnum<{
+            off: "off";
+            vhdx: "vhdx";
+        }>;
+        containedMaxGb: z.ZodNumber;
         warnDataGb: z.ZodNumber;
     }, z.core.$strict>;
     network: z.ZodObject<{
@@ -65,6 +76,7 @@ export declare const ConfigSchema: z.ZodObject<{
         provider: z.ZodEnum<{
             nordvpn: "nordvpn";
             "openvpn-file": "openvpn-file";
+            "wireguard-file": "wireguard-file";
         }>;
         protocol: z.ZodEnum<{
             udp: "udp";
@@ -235,6 +247,7 @@ export declare const ConfigSchema: z.ZodObject<{
     web: z.ZodObject<{
         enabled: z.ZodBoolean;
         port: z.ZodNumber;
+        openOnLaunch: z.ZodBoolean;
     }, z.core.$strict>;
     agentCommands: z.ZodObject<{
         enabled: z.ZodBoolean;
@@ -301,6 +314,7 @@ export declare const ConfigSchema: z.ZodObject<{
             hostDir: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         localState: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        bootReset: z.ZodOptional<z.ZodArray<z.ZodString>>;
         resumeArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
         resumeOneArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;

package/dist/core/schema/config.js

@@ -34,6 +34,15 @@ export const ConfigSchema = z
         markSandboxFiles: z
             .boolean()
             .describe('Programs and scripts (.exe, .ps1, .bat, .cmd, .msi, .lnk ...) that appear or change in your project while a sandbox runs get Windows\' "downloaded from the internet" mark, so SmartScreen and PowerShell ask before they run on this PC.'),
+        contained: z
+            .enum(['off', 'vhdx'])
+            .describe('(beta) Keep the sandbox tools, state and logs inside one disk image file (vhdx) instead of loose folders, so scanning programs on this PC see one file. Not yet tried on a real PC. Turn it on with sandbox storage contained on (it moves your files and asks first); Windows asks for permission to mount the image when a sandbox starts. "off" = loose folders, as always. Yours only: a project file (.sandbox-config.json) cannot set it.'),
+        containedMaxGb: z
+            .number()
+            .int()
+            .min(8)
+            .max(4096)
+            .describe('(beta) Largest size, in GB, the disk image of storage.contained may grow to.'),
         warnDataGb: z
             .number()
             .min(0)
@@ -78,7 +87,13 @@ export const LocalOverridesSchema = z
         .describe('Extra folders (relative paths are relative to this file), e.g. a read-only data folder at another place in the sandbox. Folders outside the project are used only as your projects.allowOutsideMappings setting allows (by default you are asked once).'),
     scripts: StringsSchema.describe('Scripts (.ps1 / .mjs / .cmd, relative to this file) run inside the sandbox before the agent.'),
     // This PC's resources are yours to share: CPU and paging file (this PC's disk) are not a project's to set.
-    sandbox: SandboxSchema.omit({ cpuLimit: true, pageFileMb: true }).partial(),
+    sandbox: SandboxSchema.omit({
+        cpuLimit: true,
+        pageFileMb: true,
+        engine: true,
+        agentMemoryHeadroomMb: true,
+        pressureResponse: true,
+    }).partial(),
     // A project may block more (the LAN, hosts); it never opens hosts, ports, DNS or a proxy.
     network: NetworkSchema.pick({ blockPrivateRanges: true, blockHosts: true }).partial(),
     // A project may turn the kill switch on, never off, and never choose a VPN, a server, a file or a login.

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

@@ -22,6 +22,7 @@ export declare const HarnessSchema: z.ZodObject<{
         hostDir: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     localState: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    bootReset: z.ZodOptional<z.ZodArray<z.ZodString>>;
     resumeArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
     resumeOneArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;

package/dist/core/schema/harness.js

@@ -49,6 +49,11 @@ export const HarnessSchema = z
         .record(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), SubfolderSchema)
         .optional()
         .describe("Environment variable -> folder below the agent's own state folder (state\\<agent>) for SQLite databases. SQLite cannot run in a mapped folder, so the agent runs from a copy on the sandbox's disk (the variable points to it) that is copied from and back to that folder."),
+    bootReset: z
+        .array(SubfolderSchema)
+        .max(32)
+        .optional()
+        .describe("Files and folders below the agent's own state folder (state\\<agent>) that only work on the machine that wrote them (keys sealed with Windows DPAPI, local accounts it created). Every sandbox is a new machine, so they are deleted at each boot and the agent sets them up again."),
     resumeArguments: StringsSchema.optional().describe('Arguments used when the agent is restarted in place (e.g. after an account switch) so it resumes the conversation.'),
     resumeOneArguments: StringsSchema.optional().describe('Arguments that reopen one conversation, with {id} where its id goes (claude: --resume {id}). Used instead of resumeArguments when the conversation of a session is known.'),
 })

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

@@ -7,12 +7,18 @@ export declare const MappingSchema: z.ZodObject<{
     optional: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 export declare const SandboxSchema: z.ZodObject<{
+    engine: z.ZodEnum<{
+        "windows-sandbox": "windows-sandbox";
+        hcs: "hcs";
+    }>;
     memoryMb: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodNumber]>;
     maxMemoryMb: z.ZodNumber;
     maxMemoryPercent: z.ZodNumber;
     cpuLimit: z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodNumber]>;
     pageFileMb: z.ZodNumber;
     reserveHostMb: z.ZodNumber;
+    agentMemoryHeadroomMb: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodNumber]>;
+    pressureResponse: z.ZodBoolean;
     vGpu: z.ZodBoolean;
     networking: z.ZodBoolean;
     clipboard: z.ZodBoolean;

package/dist/core/schema/sandbox.js

@@ -16,6 +16,9 @@ export const MappingSchema = z.strictObject({
     optional: z.boolean().optional().describe('true = skip it quietly when the host folder does not exist.'),
 });
 export const SandboxSchema = z.strictObject({
+    engine: z
+        .enum(['windows-sandbox', 'hcs'])
+        .describe('(alpha) What runs the sandbox. "windows-sandbox" = Windows Sandbox (the default: desktop, Windows Terminal, GPU, clipboard, audio, printers). "hcs" = a headless Hyper-V isolated Server Core container for agents (no desktop, GPU or clipboard); it needs Windows features and an image on this PC (sandbox engine check hcs lists what is missing), and starting it is not enabled yet in this alpha. sandbox engine shows what each engine can do. Yours only: a project file (.sandbox-config.json) cannot set it.'),
     memoryMb: z
         .union([z.literal('auto'), z.number().int().min(2048)])
         .describe('Sandbox RAM in MB (>= 2048), or "auto": free RAM minus reserveHostMb, capped at maxMemoryMb.'),
@@ -35,10 +38,24 @@ export const SandboxSchema = z.strictObject({
         .min(0)
         .max(262144)
         .describe('Size of the sandbox\'s paging file in MB, created at full size when it starts so it never grows while builds run (8 GB of its disk always stays free). Windows Sandbox starts with about 1 GB: parallel builds then fail with "The paging file is too small", and Windows grows the file under load. 0 = leave Windows\' own.'),
-    reserveHostMb: z.number().int().nonnegative().describe('RAM always left for this PC when memoryMb is "auto".'),
-    vGpu: z.boolean().describe('Virtual GPU. Off by default: Microsoft notes it widens the sandbox attack surface.'),
+    reserveHostMb: z
+        .number()
+        .int()
+        .nonnegative()
+        .describe('Memory always left for this PC when memoryMb is "auto": the sandbox gets at most (free RAM, and RAM plus paging file still unused) minus this.'),
+    agentMemoryHeadroomMb: z
+        .union([z.literal('auto'), z.literal('none'), z.number().int().min(0)])
+        .describe('Memory kept out of the agents reach inside the sandbox, in MB: everything the agents start (their builds, tests, tools) together may use at most the sandbox memory minus this; a runaway parallel build then gets out-of-memory errors in its own session instead of freezing or crashing the whole sandbox. "auto" = the larger of 2048 MB and 10 % of the sandbox memory; "none" = no limit. Yours only: a project file cannot change it.'),
+    pressureResponse: z
+        .boolean()
+        .describe('When the sandbox (or this PC) runs low on memory, slow the heaviest build programs down (lower priority) and, if that is not enough, pause the biggest compiler for a few seconds at a time, so heavy parallel builds slow down instead of closing the sandbox. Never touches the agents themselves. Yours only: a project file cannot change it.'),
+    vGpu: z
+        .boolean()
+        .describe("Virtual GPU. Off by default: Microsoft notes it widens the sandbox attack surface. The sandbox then uses this PC's graphics card, and with some graphics drivers heavy use can freeze the whole PC: turn it on only when a program in the sandbox needs the GPU (the mesa toolchain gives software OpenGL without it)."),
     networking: z.boolean().describe('Internet access. false is the only hard network isolation Windows Sandbox offers.'),
-    clipboard: z.boolean().describe('Shared clipboard between this PC and the sandbox.'),
+    clipboard: z
+        .boolean()
+        .describe("Shared clipboard between this PC and the sandbox. Also lets an agent's copy (in sandbox attach) reach this PC's clipboard."),
     audioInput: z.boolean().describe('Microphone access.'),
     videoInput: z.boolean().describe('Camera access.'),
     printerRedirection: z.boolean().describe('Printers from this PC.'),

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

@@ -1,10 +1,11 @@
 import { z } from 'zod';
-export declare const VPN_PROVIDERS: readonly ["nordvpn", "openvpn-file"];
+export declare const VPN_PROVIDERS: readonly ["nordvpn", "openvpn-file", "wireguard-file"];
 export declare const VpnSchema: z.ZodObject<{
     enabled: z.ZodBoolean;
     provider: z.ZodEnum<{
         nordvpn: "nordvpn";
         "openvpn-file": "openvpn-file";
+        "wireguard-file": "wireguard-file";
     }>;
     protocol: z.ZodEnum<{
         udp: "udp";