windows-development-sandbox 1.0.5 → 1.4.0

package/dist/sync/history.d.ts

@@ -1,24 +1,40 @@
+import { z } from 'zod';
 import { projectFolderName, translatePaths } from '../shared/paths.js';
 export { projectFolderName, translatePaths };
-/** Host-only record of the last launch: which folders map to each other and what syncs (from the effective config). */
-export interface SyncState {
-    hostClaudeDir: string;
+declare const SyncStateSchema: z.ZodObject<{
+    hostClaudeDir: z.ZodString;
+    hostWorkspace: z.ZodString;
+    guestWorkspace: z.ZodString;
+    syncHistory: z.ZodOptional<z.ZodBoolean>;
+    syncClaudeMem: z.ZodOptional<z.ZodBoolean>;
+    syncClaudeMemBack: z.ZodOptional<z.ZodBoolean>;
+    historyScope: z.ZodOptional<z.ZodEnum<{
+        project: "project";
+        all: "all";
+    }>>;
+    memHostStamp: z.ZodOptional<z.ZodNumber>;
+    memGuestStamp: z.ZodOptional<z.ZodNumber>;
+    projects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        hostWorkspace: z.ZodString;
+        guestWorkspace: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SyncState = z.output<typeof SyncStateSchema>;
+export interface WorkspacePair {
     hostWorkspace: string;
     guestWorkspace: string;
-    syncHistory?: boolean;
-    syncClaudeMem?: boolean;
-    /** Newest claude-mem database time on each side right after the last sync (detects edits on both sides). */
-    memHostStamp?: number;
-    memGuestStamp?: number;
 }
-export interface SyncPaths {
+/** extra: projects registered after boot (C:\Projects\<name> -> their real folder on this PC). */
+export interface SyncPaths extends WorkspacePair {
     hostClaudeDir: string;
     guestClaudeDir: string;
-    hostWorkspace: string;
-    guestWorkspace: string;
+    extra?: WorkspacePair[];
 }
 /** Brings this PC's history into the sandbox state (run before the sandbox starts). Returns files copied. */
-export declare const syncHistoryIn: (p: SyncPaths) => number;
+export declare const syncHistoryIn: (p: SyncPaths, options?: {
+    promptHistory?: boolean;
+    scope?: "project" | "all";
+}) => number;
 /** Copies new sandbox history back to this PC (safe while the sandbox runs: transcripts are append-only). */
 export declare const syncHistoryOut: (p: SyncPaths) => number;
 /**
@@ -26,5 +42,6 @@ export declare const syncHistoryOut: (p: SyncPaths) => number;
  * never live in the data folder the sandbox can write (a forged copy could redirect writes anywhere on this PC).
  */
 export declare const syncStatePath: (dataPath: string) => string;
+/** A state file that is missing, oversized or not in this shape counts as no state (nothing syncs back until the next launch). */
 export declare const readSyncState: (dataPath: string) => SyncState | null;
 export declare const writeSyncState: (dataPath: string, state: SyncState) => void;

package/dist/sync/history.js

@@ -7,17 +7,33 @@
 //
 // Safety (the sandbox side is untrusted):
 //  - links are never followed or written through, on either side;
-//  - what comes BACK is limited to transcripts (.jsonl), prompt history and to-do lists (.json), each capped in
-//    size, and never Claude's memory folders. Nothing executable or instruction-like flows to this PC.
+//  - what comes BACK is limited to the sandbox's own projects: their transcripts (.jsonl) and prompt-history lines,
+//    plus to-do lists (.json), each capped in size, and never Claude's memory folders. A sandbox cannot plant a
+//    conversation for another project on this PC (claude --resume there would load it);
+//  - what goes IN is, by default (historyScope "project"), only the sandbox's own projects: other projects'
+//    conversations, file backups and prompts are not the agent's business.
 import fs from 'node:fs';
 import path from 'node:path';
 import _ from 'lodash';
-import { guestWorkspaceAliases, projectFolderName, translatePaths } from '../shared/paths.js';
-import { dirExists, ensureDir, fileExists, isLink, removeLink, tryReadJson, writeJson } from '../core/util.js';
+import { z } from 'zod';
+import { guestWorkspaceAliases, isSafeFileName, projectFolderName, translatePaths } from '../shared/paths.js';
+import { readValid, writeJsonAtomic } from '../shared/rundir.js';
+import { assertTestWritable } from '../host/test-guard.js';
+import { dirExists, ensureDir, fileExists, isLink, removeLink } from '../core/util.js';
 export { projectFolderName, translatePaths };
 const SESSION_DIRS = ['todos', 'plans', 'file-history'];
 const DATA_FILE = /\.(jsonl?|txt|md)$/i;
 const MAX_FILE_BYTES = 100 * 1024 * 1024;
+/** Host-only record of the last launch: which folders map to each other and what syncs (from the effective config). */
+const AbsolutePath = z.string().max(1024).refine((p) => path.isAbsolute(p), 'must be an absolute path');
+const SyncStateSchema = z.object({
+    hostClaudeDir: AbsolutePath, hostWorkspace: AbsolutePath, guestWorkspace: z.string().max(1024),
+    syncHistory: z.boolean().optional(), syncClaudeMem: z.boolean().optional(), syncClaudeMemBack: z.boolean().optional(), historyScope: z.enum(['project', 'all']).optional(),
+    /** Newest claude-mem database time on each side right after the last sync (detects edits on both sides). */
+    memHostStamp: z.number().optional(), memGuestStamp: z.number().optional(),
+    /** Projects registered while the sandbox ran (their history goes back to their own folders). */
+    projects: z.array(z.object({ hostWorkspace: AbsolutePath, guestWorkspace: z.string().max(1024) })).max(256).optional(),
+});
 const anyFile = () => true;
 const transcript = (name) => name.endsWith('.jsonl');
 const json = (name) => name.endsWith('.json');
@@ -43,6 +59,8 @@ const copyNewer = (from, to, options = {}) => {
         return 0;
     const accept = options.accept ?? anyFile;
     return _.sumBy(fs.readdirSync(from, { withFileTypes: true }), (entry) => {
+        if (!isSafeFileName(entry.name))
+            return 0;
         const source = path.join(from, entry.name);
         const destination = path.join(to, entry.name);
         if (entry.isDirectory())
@@ -69,26 +87,52 @@ const copyNewer = (from, to, options = {}) => {
     });
 };
 const readLines = (file) => fileExists(file) && !isLink(file) && fs.statSync(file).size <= MAX_FILE_BYTES ? fs.readFileSync(file, 'utf8').split(/\r?\n/).filter((l) => l.trim() !== '') : [];
+const isJsonObject = (line) => { try {
+    const v = JSON.parse(line);
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+catch {
+    return false;
+} };
+/** A prompt-history line whose project is one of `workspaces` (on this PC's side). */
+const inProjects = (line, workspaces) => {
+    try {
+        const project = JSON.parse(line).project;
+        return typeof project === 'string' && workspaces.some((w) => path.resolve(w).toLowerCase() === path.resolve(project).toLowerCase());
+    }
+    catch {
+        return false;
+    }
+};
 const lineTime = (line) => { try {
     return Number(JSON.parse(line).timestamp) || 0;
 }
 catch {
     return 0;
 } };
+/** Every workspace pair of the sandbox: the launch folder's, then the projects registered later (most specific first). */
+const pairsOf = (p) => _.sortBy([{ hostWorkspace: p.hostWorkspace, guestWorkspace: p.guestWorkspace }, ...(p.extra ?? [])], (x) => -x.hostWorkspace.length);
+const translateAll = (text, pairs) => pairs.reduce((out, [from, to]) => translatePaths(out, from, to), text);
 /** Brings this PC's history into the sandbox state (run before the sandbox starts). Returns files copied. */
-export const syncHistoryIn = (p) => {
-    const hostProject = projectFolderName(p.hostWorkspace);
-    const guestProject = projectFolderName(p.guestWorkspace);
-    const transform = (t) => translatePaths(t, p.hostWorkspace, p.guestWorkspace);
+export const syncHistoryIn = (p, options = {}) => {
+    const all = options.scope === 'all';
+    assertTestWritable(p.guestClaudeDir);
+    const pairs = pairsOf(p);
+    const byHost = new Map(pairs.map((x) => [projectFolderName(x.hostWorkspace), projectFolderName(x.guestWorkspace)]));
+    const guestNames = new Set(pairs.map((x) => projectFolderName(x.guestWorkspace)));
+    const transform = (t) => translateAll(t, pairs.map((x) => [x.hostWorkspace, x.guestWorkspace]));
     const hostProjects = path.join(p.hostClaudeDir, 'projects');
-    const names = dirExists(hostProjects) ? fs.readdirSync(hostProjects).filter((name) => name !== guestProject || hostProject === guestProject) : [];
-    const projects = _.sumBy(names, (name) => name === hostProject
-        ? copyNewer(path.join(hostProjects, name), path.join(p.guestClaudeDir, 'projects', guestProject), { transform })
+    const names = dirExists(hostProjects) ? fs.readdirSync(hostProjects).filter((name) => isSafeFileName(name) && (all ? !guestNames.has(name) || byHost.has(name) : byHost.has(name))) : [];
+    const projects = _.sumBy(names, (name) => byHost.has(name)
+        ? copyNewer(path.join(hostProjects, name), path.join(p.guestClaudeDir, 'projects', byHost.get(name)), { transform })
         : copyNewer(path.join(hostProjects, name), path.join(p.guestClaudeDir, 'projects', name)));
-    const sessions = _.sumBy(SESSION_DIRS, (dir) => copyNewer(path.join(p.hostClaudeDir, dir), path.join(p.guestClaudeDir, dir)));
+    // To-do lists, plans and file backups are kept by session, not by project: only with historyScope "all".
+    const sessions = all ? _.sumBy(SESSION_DIRS, (dir) => copyNewer(path.join(p.hostClaudeDir, dir), path.join(p.guestClaudeDir, dir))) : 0;
+    if (options.promptHistory === false)
+        return projects + sessions;
     // Prompt history: rebuild the sandbox copy from this PC's file plus anything only the sandbox has.
     const target = path.join(p.guestClaudeDir, 'history.jsonl');
-    const hostLines = readLines(path.join(p.hostClaudeDir, 'history.jsonl')).map(transform);
+    const hostLines = readLines(path.join(p.hostClaudeDir, 'history.jsonl')).filter((l) => all || inProjects(l, pairs.map((x) => x.hostWorkspace))).map(transform);
     const known = new Set(hostLines);
     const merged = _.sortBy([...hostLines, ...readLines(target).filter((l) => !known.has(l))], lineTime);
     if (merged.length) {
@@ -99,21 +143,23 @@ export const syncHistoryIn = (p) => {
 };
 /** Copies new sandbox history back to this PC (safe while the sandbox runs: transcripts are append-only). */
 export const syncHistoryOut = (p) => {
-    const hostProject = projectFolderName(p.hostWorkspace);
-    // A mirrored workspace on F: really lives at C:\Mirror\F\...; tools that resolve real paths record that one.
-    const guestNames = guestWorkspaceAliases(p.guestWorkspace);
-    const guestProjects = new Set(guestNames.map(projectFolderName));
-    const transform = (t) => guestNames.reduce((out, guest) => translatePaths(out, guest, p.hostWorkspace), t);
+    assertTestWritable(p.hostClaudeDir);
+    // A mirrored workspace on F: really lives at C:\Mirror\F\...; tools that resolve real paths record that one. A
+    // project registered later is in the hub (C:\Projects\<name>) and goes back to its real folder on this PC.
+    const pairs = pairsOf(p).flatMap((x) => guestWorkspaceAliases(x.guestWorkspace).map((guest) => [guest, x.hostWorkspace]));
+    const byGuest = new Map(pairs.map(([guest, host]) => [projectFolderName(guest), projectFolderName(host)]));
+    const transform = (t) => translateAll(t, pairs);
     const guestProjectsDir = path.join(p.guestClaudeDir, 'projects');
-    const names = dirExists(guestProjectsDir) && !isLink(guestProjectsDir) ? fs.readdirSync(guestProjectsDir) : [];
-    const projects = _.sumBy(names, (name) => guestProjects.has(name)
-        ? copyNewer(path.join(guestProjectsDir, name), path.join(p.hostClaudeDir, 'projects', hostProject), { accept: transcript, skipDirs: NO_MEMORY, transform })
-        : copyNewer(path.join(guestProjectsDir, name), path.join(p.hostClaudeDir, 'projects', name), { accept: transcript, skipDirs: NO_MEMORY }));
+    const names = dirExists(guestProjectsDir) && !isLink(guestProjectsDir) ? fs.readdirSync(guestProjectsDir).filter(isSafeFileName) : [];
+    // Only this sandbox's projects: a transcript under any other folder name would be planted into that project on this PC.
+    const projects = _.sumBy(names.filter((name) => byGuest.has(name)), (name) => copyNewer(path.join(guestProjectsDir, name), path.join(p.hostClaudeDir, 'projects', byGuest.get(name)), { accept: transcript, skipDirs: NO_MEMORY, transform }));
     // Only to-do lists come back besides transcripts; plans and file backups stay in the sandbox.
     const sessions = copyNewer(path.join(p.guestClaudeDir, 'todos'), path.join(p.hostClaudeDir, 'todos'), { accept: json });
     const hostFile = path.join(p.hostClaudeDir, 'history.jsonl');
     const known = new Set(readLines(hostFile));
-    const missing = readLines(path.join(p.guestClaudeDir, 'history.jsonl')).map(transform).filter((l) => !known.has(l));
+    // Only prompt-history entries (one JSON object per line) of this sandbox's projects come back.
+    const hostWorkspaces = pairsOf(p).map((x) => x.hostWorkspace);
+    const missing = readLines(path.join(p.guestClaudeDir, 'history.jsonl')).filter(isJsonObject).map(transform).filter((l) => inProjects(l, hostWorkspaces) && !known.has(l));
     if (missing.length) {
         ensureDir(p.hostClaudeDir);
         fs.appendFileSync(hostFile, missing.join('\n') + '\n', 'utf8');
@@ -125,5 +171,6 @@ export const syncHistoryOut = (p) => {
  * never live in the data folder the sandbox can write (a forged copy could redirect writes anywhere on this PC).
  */
 export const syncStatePath = (dataPath) => path.join(path.dirname(path.dirname(dataPath)), 'sync', path.basename(dataPath) + '.json');
-export const readSyncState = (dataPath) => tryReadJson(syncStatePath(dataPath));
-export const writeSyncState = (dataPath, state) => writeJson(syncStatePath(dataPath), state);
+/** A state file that is missing, oversized or not in this shape counts as no state (nothing syncs back until the next launch). */
+export const readSyncState = (dataPath) => readValid(SyncStateSchema, syncStatePath(dataPath));
+export const writeSyncState = (dataPath, state) => writeJsonAtomic(syncStatePath(dataPath), state);

package/dist/sync/watcher.d.ts

@@ -1,5 +1,13 @@
 import type { Config } from '../core/types.js';
 import { type MemResult } from './claude-mem.js';
+/**
+ * A project registered while the sandbox runs: its history comes in now (the sandbox's copy only gains files), and
+ * from now on syncs back to its own folder on this PC.
+ */
+export declare const syncProjectIn: (dataPath: string, project: {
+    hostWorkspace: string;
+    guestWorkspace: string;
+}) => number;
 export interface SyncSummary {
     history: number;
     claudeMem: MemResult | 'disabled';

package/dist/sync/watcher.js

@@ -3,10 +3,18 @@
 // Its pid file and log live in host-only storage, never in the data folder the sandbox can write.
 import fs from 'node:fs';
 import path from 'node:path';
+import { writeFileAtomic } from '../shared/rundir.js';
+import { refuseInSelfTest } from '../host/test-guard.js';
 import { assertNoLinks, errMsg, sleep } from '../core/util.js';
 import { hostClaudeDir } from '../host/claude-profile.js';
 import { checkRepo } from '../host/repo-guard.js';
 import { isSandboxRunning } from '../host/platform.js';
+import { readActiveViews, WorkspaceView } from '../host/workspace-view/index.js';
+import { readForwards, sandboxAddress, startPortForwards } from '../host/port-forward.js';
+import { AuditCollector, readAuditSettings } from '../host/audit/collect.js';
+import { readMarkedProjects, saveDataSize, watchAndMark } from '../host/motw.js';
+import { sizeOf } from '../core/disk.js';
+import { beatLife, causeSince, endLife, keepAwake, readLife } from '../host/stops.js';
 import { hostClaudeMemDir, syncClaudeMem } from './claude-mem.js';
 import { readSyncState, syncHistoryIn, syncHistoryOut, writeSyncState } from './history.js';
 const WATCH_INTERVAL_MS = 60 * 1000;
@@ -16,7 +24,21 @@ const guestMem = (dataPath) => path.join(dataPath, 'state', 'claude-mem');
 /** Sync paths for the sandbox side, after checking nothing on the way there is a link planted by the sandbox. */
 const toPaths = (state, dataPath) => {
     assertNoLinks(dataPath, guestClaude(dataPath));
-    return { hostClaudeDir: state.hostClaudeDir, guestClaudeDir: guestClaude(dataPath), hostWorkspace: state.hostWorkspace, guestWorkspace: state.guestWorkspace };
+    return { hostClaudeDir: state.hostClaudeDir, guestClaudeDir: guestClaude(dataPath), hostWorkspace: state.hostWorkspace, guestWorkspace: state.guestWorkspace, extra: state.projects ?? [] };
+};
+/**
+ * A project registered while the sandbox runs: its history comes in now (the sandbox's copy only gains files), and
+ * from now on syncs back to its own folder on this PC.
+ */
+export const syncProjectIn = (dataPath, project) => {
+    const state = readSyncState(dataPath);
+    if (!state)
+        return 0;
+    const projects = [...(state.projects ?? []).filter((p) => p.hostWorkspace.toLowerCase() !== project.hostWorkspace.toLowerCase()), project];
+    const next = { ...state, projects };
+    writeSyncState(dataPath, next);
+    // Prompt history is left alone: sessions are appending to the sandbox's copy right now.
+    return state.syncHistory ? syncHistoryIn(toPaths(next, dataPath), { promptHistory: false, scope: state.historyScope }) : 0;
 };
 const memSync = (dataPath, state, direction) => {
     assertNoLinks(dataPath, guestMem(dataPath));
@@ -31,11 +53,11 @@ export const syncBeforeLaunch = (config, dataPath, hostWorkspace) => {
     const previous = readSyncState(dataPath);
     if (previous?.syncHistory)
         syncHistoryOut(toPaths(previous, dataPath));
-    const state = { ...previous, hostClaudeDir: hostClaudeDir(profile), hostWorkspace, guestWorkspace: config.guestWorkspace, syncHistory: profile.syncHistory, syncClaudeMem: profile.syncClaudeMem };
+    const state = { ...previous, hostClaudeDir: hostClaudeDir(profile), hostWorkspace, guestWorkspace: config.guestWorkspace, syncHistory: profile.syncHistory, historyScope: profile.historyScope, syncClaudeMem: profile.syncClaudeMem, syncClaudeMemBack: profile.syncClaudeMemBack, projects: [] };
     if (profile.syncHistory)
-        summary.history = syncHistoryIn(toPaths(state, dataPath));
+        summary.history = syncHistoryIn(toPaths(state, dataPath), { scope: profile.historyScope });
     if (profile.syncClaudeMem) {
-        if (previous?.syncClaudeMem)
+        if (previous?.syncClaudeMem && previous.syncClaudeMemBack)
             memSync(dataPath, state, 'out');
         summary.claudeMem = memSync(dataPath, state, 'in');
     }
@@ -50,7 +72,7 @@ export const syncBack = (dataPath, final) => {
         return summary;
     if (state.syncHistory)
         summary.history = syncHistoryOut(toPaths(state, dataPath));
-    if (final && state.syncClaudeMem)
+    if (final && state.syncClaudeMem && state.syncClaudeMemBack)
         summary.claudeMem = memSync(dataPath, state, 'out');
     writeSyncState(dataPath, state);
     return summary;
@@ -58,7 +80,9 @@ export const syncBack = (dataPath, final) => {
 const hostRunDir = (dataPath) => path.join(storageOf(dataPath), 'run');
 const watcherPidFile = (dataPath) => path.join(hostRunDir(dataPath), 'watcher-' + path.basename(dataPath) + '.pid');
 const watcherLog = (dataPath) => path.join(storageOf(dataPath), 'logs', 'host-sync-' + path.basename(dataPath) + '.log');
-const alive = (pid) => { try {
+// Signal 0 only asks whether the process exists. pid 0 would mean "my own process group", so it never counts.
+const alive = (pid) => { if (!Number.isInteger(pid) || pid <= 0)
+    return false; try {
     process.kill(pid, 0);
     return true;
 }
@@ -75,19 +99,22 @@ export const watcherRunning = (dataPath) => {
 };
 /** Body of the detached watcher process (`agent-sandbox _watch`). */
 export const watch = async (dataPath) => {
+    refuseInSelfTest('start the background sync');
     if (watcherRunning(dataPath))
         return;
     fs.mkdirSync(hostRunDir(dataPath), { recursive: true });
     fs.mkdirSync(path.dirname(watcherLog(dataPath)), { recursive: true });
-    fs.writeFileSync(watcherPidFile(dataPath), String(process.pid));
+    writeFileAtomic(watcherPidFile(dataPath), String(process.pid));
     const note = (message) => { try {
         fs.appendFileSync(watcherLog(dataPath), new Date().toISOString() + ' ' + message + '\n');
     }
     catch { /* ignore */ } };
     const sync = (final) => {
         try {
-            for (const finding of checkRepo(dataPath))
+            for (const finding of checkRepo(dataPath)) {
                 note('SECURITY: neutralised a git ' + finding.kind + ' added inside the sandbox: ' + finding.detail);
+                audit?.guard(finding.kind + ': ' + finding.detail);
+            }
         }
         catch (e) {
             note('repo guard failed: ' + errMsg(e));
@@ -101,16 +128,80 @@ export const watch = async (dataPath) => {
             note('sync failed: ' + errMsg(e));
         }
     };
+    // workspaceFilter: each filtered project is kept in step with its view from now until the sandbox closes.
+    // audit.enabled: programs, files, sessions and guard findings into the host-only audit log.
+    const auditSettings = readAuditSettings(storageOf(dataPath), dataPath);
+    const audit = auditSettings?.enabled ? new AuditCollector(dataPath, storageOf(dataPath), auditSettings) : null;
+    audit?.start();
+    const auditTimer = audit ? setInterval(() => { try {
+        audit.flush();
+    }
+    catch (e) {
+        note('audit: ' + errMsg(e));
+    } }, 10000) : null;
+    // storage.markSandboxFiles: programs and scripts that appear in the projects get the "from the internet" mark.
+    const stopMarking = watchAndMark(readMarkedProjects(storageOf(dataPath), dataPath), (m) => note(m));
+    // network.forwardPorts: localhost on this PC reaches servers in the sandbox while it runs.
+    const stopForwards = startPortForwards(readForwards(storageOf(dataPath), dataPath), () => sandboxAddress(dataPath), (m) => note('port forward: ' + m));
+    const views = readActiveViews(storageOf(dataPath), dataPath);
+    const stops = views.flatMap((v) => {
+        try {
+            return [new WorkspaceView({ ...v, note: (m) => note('workspace ' + v.host + ': ' + m) }).watch()];
+        }
+        catch (e) {
+            note('workspace ' + v.host + ': could not watch: ' + errMsg(e));
+            return [];
+        }
+    });
+    // sandbox.keepAwake, and the life record that tells the next launch how this run ended (host/stops.ts).
+    const awake = readLife(storageOf(dataPath), dataPath)?.keepAwake ? keepAwake(process.pid) : null;
     try {
         await sleep(30000);
         while (isSandboxRunning()) {
+            beatLife(storageOf(dataPath), dataPath);
             sync(false);
             await sleep(WATCH_INTERVAL_MS);
         }
+        try {
+            const life = readLife(storageOf(dataPath), dataPath);
+            const cause = life ? causeSince(life.lastSeen) : null;
+            endLife(storageOf(dataPath), dataPath, cause);
+            if (cause)
+                note('sandbox ended: ' + cause.text);
+        }
+        catch (e) {
+            note('could not record how the sandbox ended: ' + errMsg(e));
+        }
         await sleep(3000);
         sync(true);
     }
     finally {
+        awake?.kill();
+        stops.forEach((stop) => stop());
+        stopForwards();
+        stopMarking();
+        if (auditTimer)
+            clearInterval(auditTimer);
+        try {
+            audit?.stop();
+        }
+        catch (e) {
+            note('audit: ' + errMsg(e));
+        }
+        for (const v of views) {
+            try {
+                const s = new WorkspaceView(v).syncAll();
+                note('workspace ' + v.host + ': final sync ' + s.toHost + ' out, ' + s.toView + ' in');
+            }
+            catch (e) {
+                note('workspace ' + v.host + ': final sync failed: ' + errMsg(e));
+            }
+        }
+        // For the next launch's storage.warnDataGb (measuring then would be slow).
+        try {
+            saveDataSize(storageOf(dataPath), dataPath, sizeOf(dataPath));
+        }
+        catch { /* best effort */ }
         fs.rmSync(watcherPidFile(dataPath), { force: true });
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windows-development-sandbox",
-  "version": "1.0.5",
+  "version": "1.4.0",
   "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",
@@ -37,14 +37,14 @@
     "hooks",
     "config.example.json",
     ".sandbox-config.example.json",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json && node scripts/bundle.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",
-    "prepare": "npm run build",
     "prepack": "npm run rebuild",
     "release:patch": "npm version patch && git push --follow-tags",
     "release:minor": "npm version minor && git push --follow-tags",
@@ -72,6 +72,7 @@
   "dependencies": {
     "@inquirer/prompts": "^7.10.1",
     "commander": "^14.0.3",
+    "ignore": "^7.0.12",
     "jsonc-parser": "^3.3.1",
     "lodash": "^4.18.1",
     "zod": "^4.6.5"
@@ -84,10 +85,10 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/JoshDiDuca/agent-sandbox.git"
+    "url": "git+https://github.com/JoshDiDuca/windows-development-sandbox.git"
   },
-  "homepage": "https://github.com/JoshDiDuca/agent-sandbox#readme",
+  "homepage": "https://github.com/JoshDiDuca/windows-development-sandbox#readme",
   "bugs": {
-    "url": "https://github.com/JoshDiDuca/agent-sandbox/issues"
+    "url": "https://github.com/JoshDiDuca/windows-development-sandbox/issues"
   }
 }