windows-development-sandbox 1.11.3 → 1.11.4

package/dist/app/features/data/data.def.d.ts

@@ -113,7 +113,7 @@ export declare const pruneStorage: import("../../kernel/define.js").OperationDef
     message: z.ZodString;
     removed: z.ZodBoolean;
 }, z.core.$strip>, "data.prune">;
-/** The data page: disks, then one section per area, the total, and clean-up. */
+/** The data page: the disks, then every kept folder in one table (its total as the summary, clean-up as its action). */
 export declare function dataPage(o: DataShow): Page;
 export declare const dataView: import("../../kernel/define.js").ViewDef<{
     data: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{

package/dist/app/features/data/data.def.js

@@ -103,7 +103,7 @@ export const pruneStorage = defineOperation({
     },
 });
 const DAYS_FIELD = fieldOf(new SchemaNode(PruneInputSchema).child('days'), ['days']);
-/** The data page: disks, then one section per area, the total, and clean-up. */
+/** The data page: the disks, then every kept folder in one table (its total as the summary, clean-up as its action). */
 export function dataPage(o) {
     const disks = {
         id: 'disks',
@@ -132,44 +132,44 @@ export function dataPage(o) {
         })),
         notes: [{ text: 'Persistent data for the sandbox: ' + o.dataPath + ' (C:\\AgentData inside)' }],
     };
-    const areas = DATA_AREAS.flatMap((area) => {
-        const rows = o.entries.filter((e) => e.area === area);
-        if (!rows.length)
-            return [];
-        return [
-            {
-                id: 'area:' + area,
-                title: AREA_LABEL[area],
-                summary: o.areaTotals[area] ?? '',
-                columns: [
-                    { key: 'name', label: '' },
-                    { key: 'size', label: '' },
-                    { key: 'path', label: '' },
-                ],
-                columnsOn: 'cli',
-                items: rows.map((e) => ({
-                    id: 'entry:' + e.name,
-                    label: e.name,
-                    hint: e.size,
-                    ...(e.target
-                        ? { keys: 'x deletes it.' }
-                        : { description: 'Kept on this PC on purpose; it is not deleted here.' }),
-                    details: ['Folder  ' + e.path],
-                    cells: { name: '  ' + e.name, size: e.size, path: e.path },
-                    actions: e.target
-                        ? [action(cleanData, { targets: [e.target] }, { label: 'Delete', key: 'x', verb: 'delete' })]
-                        : [],
-                })),
-            },
-        ];
-    });
-    const total = {
-        id: 'total',
-        facts: [{ id: 'total', label: 'Total', value: o.total }],
+    // Every folder in one table, grouped by kind (the order of DATA_AREAS), biggest first within a kind.
+    const kindRank = (area) => DATA_AREAS.indexOf(area);
+    const rows = [...o.entries].sort((a, b) => kindRank(a.area) - kindRank(b.area) || b.bytes - a.bytes);
+    const kept = {
+        id: 'kept',
+        title: 'What the sandbox keeps',
+        summary: o.total + ' in all',
+        columns: [
+            { key: 'kind', label: 'KIND' },
+            { key: 'name', label: 'NAME' },
+            { key: 'size', label: 'SIZE' },
+            { key: 'folder', label: 'FOLDER' },
+        ],
+        items: rows.map((e) => {
+            const del = e.target
+                ? action(cleanData, { targets: [e.target] }, { label: 'Delete', key: 'x', verb: 'delete' })
+                : undefined;
+            return {
+                id: 'entry:' + e.name,
+                label: e.name,
+                hint: e.size,
+                cells: { kind: AREA_LABEL[e.area], name: e.name, size: e.size, folder: e.path },
+                ...(del ? { primary: del } : {}),
+            };
+        }),
+        actions: [
+            action(pruneStorage, {}, {
+                label: 'Clean up…',
+                verb: 'choose what',
+                description: 'Delete caches, old sandboxes and other leftovers (the clean command, with its options).',
+                fields: [DAYS_FIELD],
+            }),
+        ],
         notes: [
             ...(o.entries.length
                 ? []
                 : [{ text: 'Nothing stored yet. Toolchains, databases and agent logins appear here after the first start.' }]),
+            ...keptNote(o),
             {
                 text: 'Free space with: sandbox data clean <target...>  (e.g. tools/go, databases/postgres-18, logs, launches)',
                 tone: 'muted',
@@ -177,19 +177,12 @@ export function dataPage(o) {
             },
         ],
     };
-    const clean = {
-        id: 'clean',
-        title: 'Clean up',
-        actions: [
-            action(pruneStorage, {}, {
-                label: 'Clean up…',
-                verb: 'choose what',
-                description: 'Delete caches, old sandboxes and other leftovers (the clean command, with its options).',
-                fields: [DAYS_FIELD],
-            }),
-        ],
-    };
-    return { title: 'Data', sections: [disks, ...areas, total, clean] };
+    return { title: 'Data', sections: [disks, kept] };
+}
+/** The folders kept on purpose (not deleted here), named in one note. */
+function keptNote(o) {
+    const names = o.entries.filter((e) => !e.target).map((e) => e.name);
+    return names.length ? [{ text: 'Kept on this PC on purpose, not deleted here: ' + names.join(', ') + '.' }] : [];
 }
 export const dataView = defineView({
     id: 'data',

package/dist/app/features/defs.d.ts

@@ -1262,9 +1262,16 @@ export interface NavSection {
     readonly elsewhere?: string;
     /** Entries under this one (Sandbox: Status, Projects). */
     readonly children?: readonly NavSection[];
+    /** Views shown as more categories inside this entry's page (Settings: VPN, GitHub), not as entries of their own. */
+    readonly embeds?: readonly {
+        readonly label: string;
+        readonly view: ViewId;
+    }[];
 }
 /** Every entry of the navigation, children included, in order. */
 export declare function navSections(nav: readonly NavSection[]): NavSection[];
 /** Every view the web's navigation opens. */
 export declare function navViews(nav: readonly NavSection[]): ViewId[];
+/** The entry whose page shows this view as one of its categories (VPN: Settings), if any. */
+export declare function embeddingOf(nav: readonly NavSection[], view: string): NavSection | undefined;
 export declare const NAV: readonly NavSection[];

package/dist/app/features/defs.js

@@ -125,7 +125,11 @@ export function navSections(nav) {
 }
 /** Every view the web's navigation opens. */
 export function navViews(nav) {
-    return navSections(nav).flatMap((n) => (n.view ? [n.view] : []));
+    return navSections(nav).flatMap((n) => [...(n.view ? [n.view] : []), ...(n.embeds ?? []).map((e) => e.view)]);
+}
+/** The entry whose page shows this view as one of its categories (VPN: Settings), if any. */
+export function embeddingOf(nav, view) {
+    return navSections(nav).find((n) => n.embeds?.some((e) => e.view === view));
 }
 export const NAV = [
     { label: 'Agents', view: 'agents' },
@@ -140,8 +144,8 @@ export const NAV = [
     { label: 'Apps', view: 'apps' },
     {
         label: 'Settings',
-        children: [
-            { label: 'All settings', view: 'settings' },
+        view: 'settings',
+        embeds: [
             { label: 'VPN', view: 'vpn' },
             { label: 'GitHub', view: 'github' },
         ],

package/dist/app/features/health/health.def.js

@@ -165,22 +165,32 @@ export const enableSandbox = defineOperation({
         },
     },
 });
+/** A repair row: what it means is the description; what was found and the fix are the detail lines. */
 function checkItems(last) {
     return last.checks.map((r, i) => {
-        const lines = resultLines(r)
+        const found = r.detail + (r.timedOut ? ' (took too long)' : '');
+        const rest = resultLines(r)
             .slice(1)
-            .map((l) => l.text.trim());
+            .map((l) => l.text.trim())
+            .filter((l) => !l.startsWith('What it means: '));
+        const details = r.means ? [found, ...rest] : rest;
         return {
             id: 'repair:' + i,
             label: r.name,
             hint: BADGE[r.status],
             ...(TONE[r.status] ? { tone: TONE[r.status] } : {}),
             badges: [{ text: BADGE[r.status], ...(TONE[r.status] ? { tone: TONE[r.status] } : {}) }],
-            description: r.detail,
-            ...(lines.length ? { details: lines } : {}),
+            description: r.means ?? found,
+            ...(details.length ? { details } : {}),
         };
     });
 }
+/** A "Set up this PC" row: the real value is the hint; OK or action needed is the tone and the badge. */
+const SETUP_BADGE = {
+    ok: 'OK',
+    warn: 'WARNING',
+    action: 'NEEDS YOU',
+};
 /** The health page: before any check, the two things to do; after one, what it found. Pure. */
 export function healthPage(o) {
     const last = o.last;
@@ -223,8 +233,8 @@ export function healthPage(o) {
     const sections = [
         {
             id: 'status',
-            summary: (last.mode === 'repair' ? 'Repaired ' : 'Checked ') + ago(last.at),
-            facts: last.log ? [{ id: 'log', label: 'Log', value: last.log }] : [],
+            summary: (last.mode === 'repair' ? 'Last repair ' : 'Last check ') + ago(last.at),
+            ...(last.log ? { notes: [{ text: 'Log: ' + last.log, tone: 'muted' }] } : {}),
         },
         {
             id: 'doctor',
@@ -232,8 +242,9 @@ export function healthPage(o) {
             items: last.details.map(([name, detail], i) => ({
                 id: 'doctor:' + i,
                 label: name,
+                // The hint is the whole value; only a long one is cut, and then the description keeps all of it.
                 hint: cut(detail, 50),
-                details: [detail],
+                ...(detail.length > 50 ? { description: detail } : {}),
             })),
         },
         {
@@ -252,9 +263,14 @@ export function healthPage(o) {
                 : setup.checks.map((c, i) => ({
                     id: 'setup:' + i,
                     label: c.name,
-                    hint: c.status === 'ok' ? 'OK' : c.status === 'warn' ? 'WARNING' : 'ACTION NEEDED',
+                    hint: c.detail,
                     tone: c.status === 'ok' ? 'ok' : c.status === 'warn' ? 'warn' : 'danger',
-                    description: c.detail,
+                    badges: [
+                        {
+                            text: SETUP_BADGE[c.status],
+                            tone: c.status === 'ok' ? 'ok' : c.status === 'warn' ? 'warn' : 'danger',
+                        },
+                    ],
                 })),
             notes: canEnable
                 ? [{ text: 'Turn Windows Sandbox on from the menu or with sandbox setup.', tone: 'muted', only: 'web' }]

package/dist/app/features/storage/storage.def.js

@@ -160,22 +160,17 @@ export const containedOff = defineOperation({
 });
 /** The Storage page: the data folder (change, move, use another), then contained storage (beta). */
 export function storagePage(o, c) {
-    const folder = {
-        id: '@data-folder',
-        label: 'Data folder',
-        hint: o.root,
-        description: 'Where your tools, logins, history and logs are kept between sandboxes. Press Enter to move them to another folder or drive, or to use a different folder.',
-        details: [
-            o.size,
-            'Default folder: ' + o.defaultRoot + (o.defaultInUse ? ' (in use)' : ''),
-            ...o.otherFoldersWithData.map((f) => 'Another folder with data: ' + f),
-        ],
-        primary: action(changeDataFolder, {}, { label: 'Data folder', verb: 'change' }),
-    };
+    // Move and use another folder are the two ways to change it (the same choice as the Data folder setting).
     const data = {
         id: 'folder',
         title: 'Data folder',
-        items: [folder],
+        description: 'Where your tools, logins, history and logs are kept between sandboxes.',
+        facts: [
+            { id: 'folder', label: 'Folder', value: o.root },
+            { id: 'size', label: 'Size', value: o.size },
+            { id: 'default', label: 'Default folder', value: o.defaultRoot + (o.defaultInUse ? ' (in use)' : '') },
+            ...o.otherFoldersWithData.map((f, i) => ({ id: 'other:' + i, label: 'Other folder with data', value: f })),
+        ],
         actions: [action(moveStorage, {}), action(useStorage, {})],
     };
     const contained = {

package/dist/app/features/updates/updates.def.js

@@ -159,7 +159,6 @@ export function updatesPage(s, latest) {
                                 hint: 'off',
                                 tone: 'warn',
                                 description: s.autoOffText,
-                                details: [s.autoOffText],
                             }),
                         ]
                         : []),
@@ -178,8 +177,8 @@ export function updatesPage(s, latest) {
                             row('failed', 'Last failed update', {
                                 hint: s.failed.version,
                                 tone: 'danger',
-                                description: s.failed.reason,
-                                details: [s.failed.reason, 'It is not tried again until a newer version is released.'],
+                                description: 'It is not tried again until a newer version is released.',
+                                details: [s.failed.reason],
                             }),
                         ]
                         : []),

package/dist/guest/toolchains/tools/cli.js

@@ -30,6 +30,22 @@ export function ghExePath() {
     const dir = tool('cli', 'gh');
     return path.join(entry?.subdir ? path.join(dir, entry.subdir) : dir, entry?.exe ?? 'gh.exe');
 }
+/**
+ * gh keeps its token in Windows Credential Manager unless told otherwise, and that is wiped with the sandbox: only a
+ * login made with --insecure-storage (the token in GH_CONFIG_DIR, which persists) is still there next time.
+ */
+const GH_NOTE = ' (log in once with: gh auth login --web --insecure-storage; it is kept between sandboxes)';
+/** A saved gh account whose token was in Credential Manager (gone now): say how to log in so that it lasts. */
+function warnKeyringLogin() {
+    try {
+        const hosts = fs.readFileSync(path.join(ghConfigDir(), 'hosts.yml'), 'utf8');
+        if (/^\s*user:/m.test(hosts) && !/oauth_token:/.test(hosts))
+            warn('gh: the GitHub login from an earlier sandbox was kept in Windows Credential Manager, which is wiped with each sandbox. Log in again with: gh auth login --web --insecure-storage (then it lasts).');
+    }
+    catch {
+        // No saved login: nothing to say.
+    }
+}
 const toolVars = {
     gh: () => ({
         GH_CONFIG_DIR: exists(deliveredGhConfigDir()) ? deliveredGhConfigDir() : mkdirp(ghConfigDir()),
@@ -85,8 +101,11 @@ export async function setupCli(env, settings, gitAccess, refresh = false) {
                 refresh,
                 subdir: entry.subdir,
                 size: entry.size,
+                ...(name === 'gh' ? { note: GH_NOTE } : {}),
             });
             Object.assign(env.vars, toolVars[name]?.() ?? {});
+            if (name === 'gh')
+                warnKeyringLogin();
         }
         catch (e) {
             // One tool failing never takes the others down.

package/dist/host/life/host-memory.d.ts

@@ -17,6 +17,24 @@ export type HostMemory = z.output<typeof HostMemorySchema>;
 export declare function parseHostMemory(text: string): HostMemory | null;
 /** This PC's memory now, or null when it cannot be read (and always during the self-test: it never asks Windows). */
 export declare function readHostMemory(storageRoot: string): HostMemory | null;
+/**
+ * One long-running `HostTools memory-status --serve` for the watcher: a reading every `seconds`, instead of starting a
+ * program (and building a disk counter) for each one. Without HostTools.exe it does nothing and `latest()` stays null.
+ */
+export declare class HostMemoryStream {
+    private readonly storageRoot;
+    private readonly seconds;
+    private child;
+    private last;
+    private startedAt;
+    private stopped;
+    constructor(storageRoot: string, seconds: number);
+    start(): void;
+    /** The newest reading while it is fresh; starts the stream again when it ended (at most once a minute). */
+    latest(): HostMemory | null;
+    /** Ends it (closing its input ends HostTools). */
+    stop(): void;
+}
 /** The same without blocking: for the watcher, which must never wait on it. */
 export declare function readHostMemoryAsync(storageRoot: string): Promise<HostMemory | null>;
 /** How low this PC's memory is: what the host watchdog acts on (pure). */

package/dist/host/life/host-memory.js

@@ -47,6 +47,72 @@ export function readHostMemory(storageRoot) {
     const result = spawnSync(file, args, { encoding: 'utf8', windowsHide: true, timeout: TIMEOUT_MS });
     return parseHostMemory(result.stdout || '');
 }
+/** A reading older than this is not used (the stream stopped answering): the watcher asks once instead. */
+const STREAM_FRESH_MS = 30000;
+/** A stream that ended is started again at most this often. */
+const STREAM_RESTART_MS = 60000;
+/**
+ * One long-running `HostTools memory-status --serve` for the watcher: a reading every `seconds`, instead of starting a
+ * program (and building a disk counter) for each one. Without HostTools.exe it does nothing and `latest()` stays null.
+ */
+export class HostMemoryStream {
+    storageRoot;
+    seconds;
+    child = null;
+    last = null;
+    startedAt = 0;
+    stopped = false;
+    constructor(storageRoot, seconds) {
+        this.storageRoot = storageRoot;
+        this.seconds = seconds;
+    }
+    start() {
+        if (!isWin || selfTestRunning() || this.stopped || this.child)
+            return;
+        const tools = hostToolsExe(this.storageRoot);
+        if (!tools)
+            return;
+        this.startedAt = Date.now();
+        try {
+            const child = spawn(tools, ['memory-status', '--serve', String(this.seconds)], {
+                windowsHide: true,
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+            this.child = child;
+            let buffer = '';
+            child.stdout.setEncoding('utf8');
+            child.stdout.on('data', (chunk) => {
+                buffer = (buffer + chunk).slice(-16384);
+                let end;
+                while ((end = buffer.indexOf('\n')) >= 0) {
+                    const memory = parseHostMemory(buffer.slice(0, end).trim());
+                    buffer = buffer.slice(end + 1);
+                    if (memory)
+                        this.last = { at: Date.now(), memory };
+                }
+            });
+            child.stdin.on('error', () => undefined);
+            child.on('error', () => (this.child = null));
+            child.on('exit', () => (this.child = null));
+        }
+        catch {
+            // Could not start it: the watcher asks the old way.
+            this.child = null;
+        }
+    }
+    /** The newest reading while it is fresh; starts the stream again when it ended (at most once a minute). */
+    latest() {
+        if (!this.child && Date.now() - this.startedAt >= STREAM_RESTART_MS)
+            this.start();
+        return this.last && Date.now() - this.last.at < STREAM_FRESH_MS ? this.last.memory : null;
+    }
+    /** Ends it (closing its input ends HostTools). */
+    stop() {
+        this.stopped = true;
+        this.child?.stdin?.end();
+        this.child = null;
+    }
+}
 /** The same without blocking: for the watcher, which must never wait on it. */
 export function readHostMemoryAsync(storageRoot) {
     if (!isWin || selfTestRunning())

package/dist/runtime/daemon.js

@@ -29978,6 +29978,17 @@ function ghConfigDir() {
 function deliveredGhConfigDir() {
   return path45.join(localDir, "gh-token");
 }
+var GH_NOTE = " (log in once with: gh auth login --web --insecure-storage; it is kept between sandboxes)";
+function warnKeyringLogin() {
+  try {
+    const hosts = fs35.readFileSync(path45.join(ghConfigDir(), "hosts.yml"), "utf8");
+    if (/^\s*user:/m.test(hosts) && !/oauth_token:/.test(hosts))
+      warn(
+        "gh: the GitHub login from an earlier sandbox was kept in Windows Credential Manager, which is wiped with each sandbox. Log in again with: gh auth login --web --insecure-storage (then it lasts)."
+      );
+  } catch {
+  }
+}
 var toolVars = {
   gh: () => ({
     GH_CONFIG_DIR: exists(deliveredGhConfigDir()) ? deliveredGhConfigDir() : mkdirp(ghConfigDir()),
@@ -30018,9 +30029,11 @@ async function setupCli(env, settings, gitAccess, refresh = false) {
       await setupSingleExe(env, name, entry.repo, entry.asset(arch), entry.exe, tool("cli", name), {
         refresh,
         subdir: entry.subdir,
-        size: entry.size
+        size: entry.size,
+        ...name === "gh" ? { note: GH_NOTE } : {}
       });
       Object.assign(env.vars, toolVars[name]?.() ?? {});
+      if (name === "gh") warnKeyringLogin();
     } catch (e) {
       warn(name + " could not be set up and is skipped; the other tools are not affected. Reason: " + errMsg(e));
       env.summary.push(entry.name + ": FAILED");

package/dist/runtime/main.js

@@ -29266,6 +29266,17 @@ function ghExePath() {
   const dir = tool("cli", "gh");
   return path34.join(entry?.subdir ? path34.join(dir, entry.subdir) : dir, entry?.exe ?? "gh.exe");
 }
+var GH_NOTE = " (log in once with: gh auth login --web --insecure-storage; it is kept between sandboxes)";
+function warnKeyringLogin() {
+  try {
+    const hosts = fs28.readFileSync(path34.join(ghConfigDir(), "hosts.yml"), "utf8");
+    if (/^\s*user:/m.test(hosts) && !/oauth_token:/.test(hosts))
+      warn(
+        "gh: the GitHub login from an earlier sandbox was kept in Windows Credential Manager, which is wiped with each sandbox. Log in again with: gh auth login --web --insecure-storage (then it lasts)."
+      );
+  } catch {
+  }
+}
 var toolVars = {
   gh: () => ({
     GH_CONFIG_DIR: exists(deliveredGhConfigDir()) ? deliveredGhConfigDir() : mkdirp(ghConfigDir()),
@@ -29306,9 +29317,11 @@ async function setupCli(env, settings, gitAccess, refresh = false) {
       await setupSingleExe(env, name, entry.repo, entry.asset(arch), entry.exe, tool("cli", name), {
         refresh,
         subdir: entry.subdir,
-        size: entry.size
+        size: entry.size,
+        ...name === "gh" ? { note: GH_NOTE } : {}
       });
       Object.assign(env.vars, toolVars[name]?.() ?? {});
+      if (name === "gh") warnKeyringLogin();
     } catch (e) {
       warn(name + " could not be set up and is skipped; the other tools are not affected. Reason: " + errMsg(e));
       env.summary.push(entry.name + ": FAILED");

package/dist/selftest/app.test.js

@@ -629,12 +629,18 @@ export const appSuite = {
         const dataSample = dataPage(stored);
         const dataSectionIds = dataSample.sections.map((s) => s.id);
         const dataOps = pageActions(dataSample);
-        const accountsItem = dataSample.sections.find((s) => s.id === 'area:host')?.items?.[0];
-        t.check(dataSectionIds.includes('area:tools') &&
-            dataSectionIds.includes('area:state') &&
-            dataOps.some((a) => a.kind === 'operation' && a.op === 'data.clean' && JSON.stringify(a.input) === '{"targets":["tools/rust"]}') &&
-            (accountsItem?.actions ?? []).length === 0 &&
-            dataOps.some((a) => a.kind === 'operation' && a.op === 'data.prune'), 'data: disks, one section per area, x deletes only what may be deleted', dataSectionIds.join());
+        const keptSection = dataSample.sections.find((s) => s.id === 'kept');
+        const keptItems = keptSection?.items ?? [];
+        const accountsItem = keptItems.find((i) => i.label === 'accounts');
+        t.check(dataSectionIds.join() === 'disks,kept' &&
+            keptItems.map((i) => i.label).join() === 'rust,state/claude,accounts' &&
+            keptSection?.summary === '6.5 GB in all' &&
+            keptItems[0]?.primary?.kind === 'operation' &&
+            keptItems[0].primary.op === 'data.clean' &&
+            JSON.stringify(keptItems[0].primary.input) === '{"targets":["tools/rust"]}' &&
+            accountsItem?.primary === undefined &&
+            (keptSection?.actions ?? []).some((a) => a.kind === 'operation' && a.op === 'data.prune') &&
+            dataOps.some((a) => a.kind === 'operation' && a.op === 'data.clean'), 'data: disks, then one table of every kept folder (total in the summary); delete only where it may be deleted', dataSectionIds.join());
         const shaped = showData.cli.shapeJson(stored);
         const shapedEntries = shaped.entries;
         const shapedDisks = shaped.disks;
@@ -644,6 +650,10 @@ export const appSuite = {
         const dataLines = pageLines(dataSample);
         t.check(dataLines.some((l) => l.startsWith('Disks')) &&
             dataLines.some((l) => /^DRIVE\s+USED\s+FREE\s+SIZE/.test(l)) &&
+            dataLines.some((l) => l.startsWith('What the sandbox keeps  6.5 GB in all')) &&
+            dataLines.some((l) => /^KIND\s+NAME\s+SIZE\s+FOLDER/.test(l)) &&
+            dataLines.some((l) => /^Toolchains\s+rust\s+4\.6 GB\s+C:\\AgentData\\tools\\rust/.test(l)) &&
+            dataLines.some((l) => l.startsWith('Kept on this PC on purpose, not deleted here: accounts.')) &&
             dataLines.some((l) => l.startsWith('Persistent data for the sandbox: ')) &&
             dataLines.some((l) => l.startsWith('Free space with:')), 'data on the command line: the disks table, the data folder line and the free space line', dataLines.join('\n'));
         t.check(definitionFor('data', ['clean'])?.id === 'data.clean' &&
@@ -837,10 +847,12 @@ export const appSuite = {
             mountedNow: null,
         };
         const storagePageNow = storagePage(shownStorage, shownContained);
-        const folderPrimary = storagePageNow.sections[0]?.items?.[0]?.primary;
+        const folderSection = storagePageNow.sections[0];
+        const folderOps = (folderSection?.actions ?? []).map((a) => (a.kind === 'operation' ? a.op : a.kind));
         const containedActions = storagePageNow.sections[1]?.actions ?? [];
-        t.check(folderPrimary?.kind === 'operation' &&
-            folderPrimary.op === 'storage.change' &&
+        t.check(folderOps.join() === 'storage.move,storage.use' &&
+            (folderSection?.facts ?? []).map((f) => f.label).join() ===
+                'Folder,Size,Default folder,Other folder with data' &&
             containedActions.length === 1 &&
             containedActions[0].kind === 'operation' &&
             containedActions[0].op === 'storage.containedOn', 'the storage page: the data folder row changes it, and contained storage offers to turn it on while it is off');

package/dist/sync/watcher.d.ts

@@ -23,6 +23,8 @@ export declare class Watcher {
     private views;
     private stops;
     private watchdogTimer;
+    /** This PC's memory, read by one long-running HostTools instead of a program per sample. */
+    private memoryStream;
     private watchdog;
     private watchdogBusy;
     private lastCpu;

package/dist/sync/watcher.js

@@ -13,7 +13,7 @@ import { readForwards, sandboxAddress, startPortForwards } from '../host/network
 import { AuditCollector, readAuditSettings } from '../host/audit/collect.js';
 import { readMarkedProjects, saveDataSize, watchAndMark } from '../host/guard/index.js';
 import { sizeWithin } from '../core/disk.js';
-import { autoRestartAllowed, causeSince, appendHostMemory, cpuPercentBetween, KeepAwake, LifeRecord, readHostMemoryAsync, readLoadSettings, REQUEST_SECONDS, WATCHDOG_START, watchdogStep, saveCrashReport, SessionLedger, } from '../host/life/index.js';
+import { autoRestartAllowed, causeSince, appendHostMemory, cpuPercentBetween, KeepAwake, LifeRecord, HostMemoryStream, readHostMemoryAsync, readLoadSettings, REQUEST_SECONDS, WATCHDOG_START, watchdogStep, saveCrashReport, SessionLedger, } from '../host/life/index.js';
 import { SandboxChannel } from '../host/channel/index.js';
 import { ProjectRegistry } from '../host/projects/registry.js';
 import { ContainedStorage, setNameOf, storageOf } from '../host/storage/index.js';
@@ -85,6 +85,8 @@ export class Watcher {
     views = [];
     stops = [];
     watchdogTimer = null;
+    /** This PC's memory, read by one long-running HostTools instead of a program per sample. */
+    memoryStream = null;
     watchdog = WATCHDOG_START;
     watchdogBusy = false;
     lastCpu = os.cpus();
@@ -208,6 +210,8 @@ export class Watcher {
         });
         this.stops = [...viewStops, stopForwards, stopMarking];
         // Memory and CPU of this PC: when low, the sandbox is asked to slow its builds down (host/life/watchdog.ts).
+        this.memoryStream = new HostMemoryStream(storageRoot, WATCHDOG_MS / 1000);
+        this.memoryStream.start();
         this.watchdogTimer = setInterval(() => void this.watchHost(), WATCHDOG_MS);
         this.watchdogTimer.unref();
         // sandbox.keepAwake, and the life record that tells the next launch how this run ended (host/life).
@@ -220,7 +224,7 @@ export class Watcher {
         this.watchdogBusy = true;
         try {
             const settings = readLoadSettings(this.storageRoot, this.dataPath);
-            const memory = await readHostMemoryAsync(this.storageRoot);
+            const memory = this.memoryStream?.latest() ?? (await readHostMemoryAsync(this.storageRoot));
             const cpus = os.cpus();
             const cpuPercent = cpuPercentBetween(this.lastCpu, cpus);
             this.lastCpu = cpus;
@@ -324,6 +328,7 @@ export class Watcher {
         this.awake?.stop();
         if (this.watchdogTimer)
             clearInterval(this.watchdogTimer);
+        this.memoryStream?.stop();
         this.stops.forEach((stop) => stop());
         if (this.auditTimer)
             clearInterval(this.auditTimer);

package/dist/web/index.html

@@ -5,8 +5,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>Sandbox</title>
     <link rel="icon" href="data:," />
-    <link rel="stylesheet" href="/main-6JF3ASB5.css" />
-    <script type="module" src="/main-Z645W45E.js"></script>
+    <link rel="stylesheet" href="/main-MU5XWZMS.css" />
+    <script type="module" src="/main-SLQNJRXD.js"></script>
   </head>
   <body>
     <div id="root"></div>