windows-development-sandbox 1.4.0 → 1.4.3

package/dist/sync/history.js

@@ -15,25 +15,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import _ from 'lodash';
-import { z } from 'zod';
-import { guestWorkspaceAliases, isSafeFileName, projectFolderName, translatePaths } from '../shared/paths.js';
-import { readValid, writeJsonAtomic } from '../shared/rundir.js';
+import { guestWorkspaceAliases, isSafeFileName, projectFolderName, translatePaths } from '../shared/paths/index.js';
 import { assertTestWritable } from '../host/test-guard.js';
-import { dirExists, ensureDir, fileExists, isLink, removeLink } from '../core/util.js';
+import { dirExists, ensureDir, fileExists, isLink, removeLink } from '../core/util/index.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');
@@ -86,30 +74,40 @@ const copyNewer = (from, to, options = {}) => {
         return 1;
     });
 };
-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;
-} };
+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());
+        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;
-} };
+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);
@@ -122,17 +120,28 @@ export const syncHistoryIn = (p, options = {}) => {
     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) => isSafeFileName(name) && (all ? !guestNames.has(name) || byHost.has(name) : byHost.has(name))) : [];
+    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', byHost.get(name)), {
+            transform,
+        })
         : copyNewer(path.join(hostProjects, name), path.join(p.guestClaudeDir, 'projects', name)));
     // 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;
+    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')).filter((l) => all || inProjects(l, pairs.map((x) => x.hostWorkspace))).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) {
@@ -150,27 +159,30 @@ export const syncHistoryOut = (p) => {
     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).filter(isSafeFileName) : [];
+    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 }));
+    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 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));
     // 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));
+    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');
     }
     return projects + sessions + missing.length;
 };
-/**
- * Host-only: <storage>\sync\<dataName>.json. It records which folder on this PC history flows back into, so it must
- * 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');
-/** 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/index.d.ts

@@ -0,0 +1,5 @@
+export * from './claude-mem.js';
+export * from './history.js';
+export * from './sync-state.js';
+export * from './sync-cycle.js';
+export * from './watcher.js';

package/dist/sync/index.js

@@ -0,0 +1,5 @@
+export * from './claude-mem.js';
+export * from './history.js';
+export * from './sync-state.js';
+export * from './sync-cycle.js';
+export * from './watcher.js';

package/dist/sync/sync-cycle.d.ts

@@ -0,0 +1,18 @@
+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';
+}
+/** Before launch: finish syncing the previous run out, then bring this PC's history (and claude-mem) in. */
+export declare const syncBeforeLaunch: (config: Config, dataPath: string, hostWorkspace: string) => SyncSummary;
+/** Syncs the sandbox's history (and, when `final`, claude-mem) back to this PC, as configured for the last launch. */
+export declare const syncBack: (dataPath: string, final: boolean) => SyncSummary;

package/dist/sync/sync-cycle.js

@@ -0,0 +1,85 @@
+import path from 'node:path';
+import { assertNoLinks } from '../core/util/index.js';
+import { hostClaudeDir } from '../host/profile/index.js';
+import { hostClaudeMemDir, syncClaudeMem } from './claude-mem.js';
+import { readSyncState, writeSyncState } from './sync-state.js';
+import { syncHistoryIn, syncHistoryOut } from './history.js';
+const guestClaude = (dataPath) => path.join(dataPath, 'state', 'claude');
+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,
+        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));
+    return syncClaudeMem(hostClaudeMemDir(), guestMem(dataPath), state, direction);
+};
+/** Before launch: finish syncing the previous run out, then bring this PC's history (and claude-mem) in. */
+export const syncBeforeLaunch = (config, dataPath, hostWorkspace) => {
+    const profile = config.claudeProfile;
+    const summary = { history: 0, claudeMem: 'disabled' };
+    if (!config.storage.persistAgentState)
+        return summary;
+    const previous = readSyncState(dataPath);
+    if (previous?.syncHistory)
+        syncHistoryOut(toPaths(previous, dataPath));
+    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), { scope: profile.historyScope });
+    if (profile.syncClaudeMem) {
+        if (previous?.syncClaudeMem && previous.syncClaudeMemBack)
+            memSync(dataPath, state, 'out');
+        summary.claudeMem = memSync(dataPath, state, 'in');
+    }
+    writeSyncState(dataPath, state);
+    return summary;
+};
+/** Syncs the sandbox's history (and, when `final`, claude-mem) back to this PC, as configured for the last launch. */
+export const syncBack = (dataPath, final) => {
+    const state = readSyncState(dataPath);
+    const summary = { history: 0, claudeMem: 'disabled' };
+    if (!state)
+        return summary;
+    if (state.syncHistory)
+        summary.history = syncHistoryOut(toPaths(state, dataPath));
+    if (final && state.syncClaudeMem && state.syncClaudeMemBack)
+        summary.claudeMem = memSync(dataPath, state, 'out');
+    writeSyncState(dataPath, state);
+    return summary;
+};

package/dist/sync/sync-state.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+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>;
+/**
+ * Host-only: <storage>\sync\<dataName>.json. It records which folder on this PC history flows back into, so it must
+ * 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;
+export {};

package/dist/sync/sync-state.js

@@ -0,0 +1,37 @@
+import path from 'node:path';
+import { z } from 'zod';
+import { JsonFile } from '../shared/io/index.js';
+import { hostStateFile, storageOf } from '../host/storage/index.js';
+/** Host-only record of the last launch: which folders map to each other and what syncs (from the effective config). */
+const AbsolutePathSchema = z
+    .string()
+    .max(1024)
+    .refine((p) => path.isAbsolute(p), 'must be an absolute path');
+const SyncStateSchema = z.object({
+    hostClaudeDir: AbsolutePathSchema,
+    hostWorkspace: AbsolutePathSchema,
+    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: AbsolutePathSchema, guestWorkspace: z.string().max(1024) }))
+        .max(256)
+        .optional(),
+});
+/**
+ * Host-only: <storage>\sync\<dataName>.json. It records which folder on this PC history flows back into, so it must
+ * never live in the data folder the sandbox can write (a forged copy could redirect writes anywhere on this PC).
+ */
+export const syncStatePath = (dataPath) => hostStateFile(storageOf(dataPath), dataPath, '.json');
+/**
+ * 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) => new JsonFile(SyncStateSchema, syncStatePath(dataPath)).read();
+export const writeSyncState = (dataPath, state) => new JsonFile(SyncStateSchema, syncStatePath(dataPath)).write(state);

package/dist/sync/watcher.d.ts

@@ -1,21 +1,3 @@
-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';
-}
-/** Before launch: finish syncing the previous run out, then bring this PC's history (and claude-mem) in. */
-export declare const syncBeforeLaunch: (config: Config, dataPath: string, hostWorkspace: string) => SyncSummary;
-/** Syncs the sandbox's history (and, when `final`, claude-mem) back to this PC, as configured for the last launch. */
-export declare const syncBack: (dataPath: string, final: boolean) => SyncSummary;
 export declare const watcherRunning: (dataPath: string) => boolean;
 /** Body of the detached watcher process (`agent-sandbox _watch`). */
 export declare const watch: (dataPath: string) => Promise<void>;

package/dist/sync/watcher.js

@@ -3,92 +3,38 @@
 // 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 { writeFileAtomic } from '../shared/io/index.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 { errMsg, sleep } from '../core/util/index.js';
+import { RepoGuardStore } from '../host/guard/index.js';
+import { isSandboxRunning } from '../host/sandbox/index.js';
+import { readActiveViews } from '../host/workspace-view/index.js';
+import { WorkspaceView } from '../host/workspace-view/index.js';
+import { readForwards, sandboxAddress, startPortForwards } from '../host/network/index.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';
+import { readMarkedProjects, saveDataSize, watchAndMark } from '../host/guard/index.js';
+import { sizeWithin } from '../core/disk.js';
+import { causeSince, KeepAwake, LifeRecord, saveCrashReport } from '../host/life/index.js';
+import { storageOf } from '../host/storage/index.js';
+import { syncBack } from './sync-cycle.js';
 const WATCH_INTERVAL_MS = 60 * 1000;
-const storageOf = (dataPath) => path.dirname(path.dirname(dataPath));
-const guestClaude = (dataPath) => path.join(dataPath, 'state', 'claude');
-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, 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));
-    return syncClaudeMem(hostClaudeMemDir(), guestMem(dataPath), state, direction);
-};
-/** Before launch: finish syncing the previous run out, then bring this PC's history (and claude-mem) in. */
-export const syncBeforeLaunch = (config, dataPath, hostWorkspace) => {
-    const profile = config.claudeProfile;
-    const summary = { history: 0, claudeMem: 'disabled' };
-    if (!config.storage.persistAgentState)
-        return summary;
-    const previous = readSyncState(dataPath);
-    if (previous?.syncHistory)
-        syncHistoryOut(toPaths(previous, dataPath));
-    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), { scope: profile.historyScope });
-    if (profile.syncClaudeMem) {
-        if (previous?.syncClaudeMem && previous.syncClaudeMemBack)
-            memSync(dataPath, state, 'out');
-        summary.claudeMem = memSync(dataPath, state, 'in');
-    }
-    writeSyncState(dataPath, state);
-    return summary;
-};
-/** Syncs the sandbox's history (and, when `final`, claude-mem) back to this PC, as configured for the last launch. */
-export const syncBack = (dataPath, final) => {
-    const state = readSyncState(dataPath);
-    const summary = { history: 0, claudeMem: 'disabled' };
-    if (!state)
-        return summary;
-    if (state.syncHistory)
-        summary.history = syncHistoryOut(toPaths(state, dataPath));
-    if (final && state.syncClaudeMem && state.syncClaudeMemBack)
-        summary.claudeMem = memSync(dataPath, state, 'out');
-    writeSyncState(dataPath, state);
-    return summary;
-};
 const hostRunDir = (dataPath) => path.join(storageOf(dataPath), 'run');
+/** The longest the watcher may take after the sandbox closed (final syncs) before it stops anyway. */
+const END_DEADLINE_MS = 3 * 60 * 1000;
 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');
 // 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;
-}
-catch {
-    return false;
-} };
+const alive = (pid) => {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
 export const watcherRunning = (dataPath) => {
     try {
         return alive(Number(fs.readFileSync(watcherPidFile(dataPath), 'utf8')));
@@ -105,13 +51,17 @@ export const watch = async (dataPath) => {
     fs.mkdirSync(hostRunDir(dataPath), { recursive: true });
     fs.mkdirSync(path.dirname(watcherLog(dataPath)), { recursive: true });
     writeFileAtomic(watcherPidFile(dataPath), String(process.pid));
-    const note = (message) => { try {
-        fs.appendFileSync(watcherLog(dataPath), new Date().toISOString() + ' ' + message + '\n');
-    }
-    catch { /* ignore */ } };
+    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 new RepoGuardStore(dataPath).check()) {
                 note('SECURITY: neutralised a git ' + finding.kind + ' added inside the sandbox: ' + finding.detail);
                 audit?.guard(finding.kind + ': ' + finding.detail);
             }
@@ -133,12 +83,16 @@ export const watch = async (dataPath) => {
     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;
+    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.
@@ -154,29 +108,37 @@ export const watch = async (dataPath) => {
         }
     });
     // 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;
+    const life = new LifeRecord(storageOf(dataPath), dataPath);
+    const awake = life.read()?.keepAwake ? KeepAwake.start(process.pid) : null;
     try {
         await sleep(30000);
         while (isSandboxRunning()) {
-            beatLife(storageOf(dataPath), dataPath);
+            life.beat();
             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);
+            const last = life.read();
+            const cause = last ? causeSince(last.lastSeen) : null;
+            const report = last && cause ? saveCrashReport(storageOf(dataPath), dataPath, last.lastSeen) : null;
+            life.end(cause, new Date(), report);
             if (cause)
-                note('sandbox ended: ' + cause.text);
+                note('sandbox ended: ' + cause.text + (report ? '; crash report: ' + report : ''));
         }
         catch (e) {
             note('could not record how the sandbox ended: ' + errMsg(e));
         }
         await sleep(3000);
+        // The sandbox is gone: this process ends within minutes whatever happens below (it must never outlive the sandbox).
+        setTimeout(() => {
+            note('final work took too long; stopped.');
+            fs.rmSync(watcherPidFile(dataPath), { force: true });
+            process.exit(0);
+        }, END_DEADLINE_MS).unref();
         sync(true);
     }
     finally {
-        awake?.kill();
+        awake?.stop();
         stops.forEach((stop) => stop());
         stopForwards();
         stopMarking();
@@ -197,11 +159,15 @@ export const watch = async (dataPath) => {
                 note('workspace ' + v.host + ': final sync failed: ' + errMsg(e));
             }
         }
-        // For the next launch's storage.warnDataGb (measuring then would be slow).
+        // For the next launch's storage.warnDataGb, only when it can be measured quickly (a big data folder takes minutes).
         try {
-            saveDataSize(storageOf(dataPath), dataPath, sizeOf(dataPath));
+            const bytes = sizeWithin(dataPath, 20000);
+            if (bytes !== null)
+                saveDataSize(storageOf(dataPath), dataPath, bytes);
+        }
+        catch {
+            /* best effort */
         }
-        catch { /* best effort */ }
         fs.rmSync(watcherPidFile(dataPath), { force: true });
     }
 };

package/native/keep-awake.ps1

@@ -0,0 +1,8 @@
+#Requires -Version 5.1
+# Keeps this PC awake (the screen may still turn off) until the process -OwnerId ends: the background watcher, which
+# ends with the sandbox. Used by host/stops.ts for sandbox.keepAwake.
+param([Parameter(Mandatory = $true)][int]$OwnerId)
+$ErrorActionPreference = 'Stop'
+Add-Type -Path (Join-Path $PSScriptRoot 'power.cs')
+[AgentSandbox.Power]::StayAwake()
+Wait-Process -Id $OwnerId -ErrorAction SilentlyContinue

package/native/power.cs

@@ -0,0 +1,23 @@
+// Keeps this PC from sleeping while a sandbox runs (sandbox.keepAwake). Loaded by keep-awake.ps1 (Add-Type). C# 5.
+using System.Runtime.InteropServices;
+
+namespace AgentSandbox
+{
+    public static class Power
+    {
+        // ES_CONTINUOUS | ES_SYSTEM_REQUIRED: the system stays awake until this thread ends or clears it.
+        private const uint ContinuousSystemRequired = 0x80000001;
+
+        private static class NativeMethods
+        {
+            [DllImport("kernel32.dll")]
+            public static extern uint SetThreadExecutionState(uint flags);
+        }
+
+        /// <summary>Asks Windows not to sleep for as long as the calling thread runs.</summary>
+        public static void StayAwake()
+        {
+            NativeMethods.SetThreadExecutionState(ContinuousSystemRequired);
+        }
+    }
+}