windows-development-sandbox 1.0.5 → 1.1.0

package/dist/shared/schema.d.ts

@@ -20,6 +20,145 @@ export declare const SandboxStatus: z.ZodObject<{
     guestWorkspace: z.ZodString;
     headless: z.ZodBoolean;
 }, z.core.$strip>;
+/**
+ * A project the host registered after boot (sandbox claude from another folder): everything the guest needs to
+ * provision it and run its sessions with its own environment, resolved on the host exactly like a fresh launch (its
+ * approved .sandbox-config.json, version files, toolchain detection, database plan). Host -> guest only.
+ */
+export declare const ProjectSpec: z.ZodObject<{
+    name: z.ZodString;
+    workspace: z.ZodString;
+    workspaceHost: z.ZodString;
+    toolchains: z.ZodObject<{
+        node: z.ZodObject<{
+            version: z.ZodString;
+            extraVersions: z.ZodArray<z.ZodString>;
+            corepack: z.ZodBoolean;
+            volta: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            globalPackages: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        python: z.ZodObject<{
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            version: z.ZodString;
+            python2: z.ZodBoolean;
+            pyenv: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            tools: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        rust: z.ZodObject<{
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            toolchain: z.ZodString;
+            host: z.ZodString;
+            components: z.ZodArray<z.ZodString>;
+            targets: z.ZodArray<z.ZodString>;
+            crates: z.ZodArray<z.ZodString>;
+            targetDir: z.ZodString;
+        }, z.core.$strict>;
+        msvc: z.ZodObject<{
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            acceptLicense: z.ZodBoolean;
+            msvcVersion: z.ZodString;
+            sdkVersion: z.ZodString;
+        }, z.core.$strict>;
+        cpp: z.ZodObject<{
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            flexBison: z.ZodBoolean;
+        }, z.core.$strict>;
+        dotnet: z.ZodObject<{
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            channels: z.ZodArray<z.ZodString>;
+            tools: z.ZodArray<z.ZodString>;
+            workloads: z.ZodArray<z.ZodString>;
+            frameworkTargets: z.ZodArray<z.ZodString>;
+            netfx35: z.ZodBoolean;
+        }, z.core.$strict>;
+        go: z.ZodObject<{
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            version: z.ZodString;
+            tools: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        java: z.ZodObject<{
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            version: z.ZodString;
+            maven: z.ZodBoolean;
+            gradle: z.ZodBoolean;
+        }, z.core.$strict>;
+        ruby: z.ZodObject<{
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            version: z.ZodString;
+            gems: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        php: z.ZodObject<{
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            version: z.ZodString;
+            composer: z.ZodBoolean;
+        }, z.core.$strict>;
+        deno: z.ZodObject<{
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        }, z.core.$strict>;
+        pwsh: z.ZodObject<{
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        }, z.core.$strict>;
+        cli: z.ZodObject<{
+            gh: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            zstd: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            openssl: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        }, z.core.$strict>;
+        bun: z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, z.core.$strict>;
+        uv: z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, z.core.$strict>;
+        vcRuntime: z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, z.core.$strict>;
+        mesa: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            vulkan: z.ZodBoolean;
+        }, z.core.$strict>;
+        vscode: z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, z.core.$strict>;
+        environment: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>;
+    versions: z.ZodObject<{
+        node: z.ZodObject<{
+            spec: z.ZodString;
+            source: z.ZodString;
+        }, z.core.$strict>;
+        nodeExtra: z.ZodArray<z.ZodString>;
+        python: z.ZodObject<{
+            spec: z.ZodString;
+            source: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    databases: z.ZodArray<z.ZodObject<{
+        database: z.ZodEnum<{
+            postgres: "postgres";
+            mysql: "mysql";
+            mongodb: "mongodb";
+            redis: "redis";
+            dynamodb: "dynamodb";
+            sqlserver: "sqlserver";
+        }>;
+        reasons: z.ZodArray<z.ZodString>;
+        version: z.ZodString;
+        port: z.ZodNumber;
+        adminPort: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    harnesses: z.ZodRecord<z.ZodString, z.ZodObject<{
+        hostExecutable: z.ZodOptional<z.ZodString>;
+        hostDir: z.ZodOptional<z.ZodString>;
+        npmPackage: z.ZodOptional<z.ZodString>;
+        npmBin: z.ZodOptional<z.ZodString>;
+        uvPackage: z.ZodOptional<z.ZodString>;
+        uvBin: z.ZodOptional<z.ZodString>;
+        arguments: z.ZodArray<z.ZodString>;
+        environment: z.ZodRecord<z.ZodString, z.ZodString>;
+        resumeArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    hooks: z.ZodBoolean;
+}, z.core.$strict>;
 /** C:\AgentData\run\requests\<id>.json: the ONLY things the host can ask the sandbox to do. */
 export declare const GuestRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"session">;
@@ -27,6 +166,289 @@ export declare const GuestRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
     harness: z.ZodString;
     args: z.ZodArray<z.ZodString>;
     cwd: z.ZodString;
+    project: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        workspace: z.ZodString;
+        workspaceHost: z.ZodString;
+        toolchains: z.ZodObject<{
+            node: z.ZodObject<{
+                version: z.ZodString;
+                extraVersions: z.ZodArray<z.ZodString>;
+                corepack: z.ZodBoolean;
+                volta: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                globalPackages: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            python: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                version: z.ZodString;
+                python2: z.ZodBoolean;
+                pyenv: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                tools: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            rust: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                toolchain: z.ZodString;
+                host: z.ZodString;
+                components: z.ZodArray<z.ZodString>;
+                targets: z.ZodArray<z.ZodString>;
+                crates: z.ZodArray<z.ZodString>;
+                targetDir: z.ZodString;
+            }, z.core.$strict>;
+            msvc: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                acceptLicense: z.ZodBoolean;
+                msvcVersion: z.ZodString;
+                sdkVersion: z.ZodString;
+            }, z.core.$strict>;
+            cpp: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                flexBison: z.ZodBoolean;
+            }, z.core.$strict>;
+            dotnet: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                channels: z.ZodArray<z.ZodString>;
+                tools: z.ZodArray<z.ZodString>;
+                workloads: z.ZodArray<z.ZodString>;
+                frameworkTargets: z.ZodArray<z.ZodString>;
+                netfx35: z.ZodBoolean;
+            }, z.core.$strict>;
+            go: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                version: z.ZodString;
+                tools: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            java: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                version: z.ZodString;
+                maven: z.ZodBoolean;
+                gradle: z.ZodBoolean;
+            }, z.core.$strict>;
+            ruby: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                version: z.ZodString;
+                gems: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            php: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                version: z.ZodString;
+                composer: z.ZodBoolean;
+            }, z.core.$strict>;
+            deno: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            }, z.core.$strict>;
+            pwsh: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            }, z.core.$strict>;
+            cli: z.ZodObject<{
+                gh: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                zstd: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                openssl: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            }, z.core.$strict>;
+            bun: z.ZodObject<{
+                enabled: z.ZodBoolean;
+            }, z.core.$strict>;
+            uv: z.ZodObject<{
+                enabled: z.ZodBoolean;
+            }, z.core.$strict>;
+            vcRuntime: z.ZodObject<{
+                enabled: z.ZodBoolean;
+            }, z.core.$strict>;
+            mesa: z.ZodObject<{
+                enabled: z.ZodBoolean;
+                vulkan: z.ZodBoolean;
+            }, z.core.$strict>;
+            vscode: z.ZodObject<{
+                enabled: z.ZodBoolean;
+            }, z.core.$strict>;
+            environment: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>;
+        versions: z.ZodObject<{
+            node: z.ZodObject<{
+                spec: z.ZodString;
+                source: z.ZodString;
+            }, z.core.$strict>;
+            nodeExtra: z.ZodArray<z.ZodString>;
+            python: z.ZodObject<{
+                spec: z.ZodString;
+                source: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        databases: z.ZodArray<z.ZodObject<{
+            database: z.ZodEnum<{
+                postgres: "postgres";
+                mysql: "mysql";
+                mongodb: "mongodb";
+                redis: "redis";
+                dynamodb: "dynamodb";
+                sqlserver: "sqlserver";
+            }>;
+            reasons: z.ZodArray<z.ZodString>;
+            version: z.ZodString;
+            port: z.ZodNumber;
+            adminPort: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        harnesses: z.ZodRecord<z.ZodString, z.ZodObject<{
+            hostExecutable: z.ZodOptional<z.ZodString>;
+            hostDir: z.ZodOptional<z.ZodString>;
+            npmPackage: z.ZodOptional<z.ZodString>;
+            npmBin: z.ZodOptional<z.ZodString>;
+            uvPackage: z.ZodOptional<z.ZodString>;
+            uvBin: z.ZodOptional<z.ZodString>;
+            arguments: z.ZodArray<z.ZodString>;
+            environment: z.ZodRecord<z.ZodString, z.ZodString>;
+            resumeArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        hooks: z.ZodBoolean;
+    }, z.core.$strict>>;
+    harnessSpec: z.ZodOptional<z.ZodObject<{
+        hostExecutable: z.ZodOptional<z.ZodString>;
+        hostDir: z.ZodOptional<z.ZodString>;
+        npmPackage: z.ZodOptional<z.ZodString>;
+        npmBin: z.ZodOptional<z.ZodString>;
+        uvPackage: z.ZodOptional<z.ZodString>;
+        uvBin: z.ZodOptional<z.ZodString>;
+        arguments: z.ZodArray<z.ZodString>;
+        environment: z.ZodRecord<z.ZodString, z.ZodString>;
+        resumeArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    createdAt: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"project">;
+    id: z.ZodString;
+    project: z.ZodObject<{
+        name: z.ZodString;
+        workspace: z.ZodString;
+        workspaceHost: z.ZodString;
+        toolchains: z.ZodObject<{
+            node: z.ZodObject<{
+                version: z.ZodString;
+                extraVersions: z.ZodArray<z.ZodString>;
+                corepack: z.ZodBoolean;
+                volta: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                globalPackages: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            python: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                version: z.ZodString;
+                python2: z.ZodBoolean;
+                pyenv: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                tools: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            rust: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                toolchain: z.ZodString;
+                host: z.ZodString;
+                components: z.ZodArray<z.ZodString>;
+                targets: z.ZodArray<z.ZodString>;
+                crates: z.ZodArray<z.ZodString>;
+                targetDir: z.ZodString;
+            }, z.core.$strict>;
+            msvc: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                acceptLicense: z.ZodBoolean;
+                msvcVersion: z.ZodString;
+                sdkVersion: z.ZodString;
+            }, z.core.$strict>;
+            cpp: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                flexBison: z.ZodBoolean;
+            }, z.core.$strict>;
+            dotnet: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                channels: z.ZodArray<z.ZodString>;
+                tools: z.ZodArray<z.ZodString>;
+                workloads: z.ZodArray<z.ZodString>;
+                frameworkTargets: z.ZodArray<z.ZodString>;
+                netfx35: z.ZodBoolean;
+            }, z.core.$strict>;
+            go: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                version: z.ZodString;
+                tools: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            java: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                version: z.ZodString;
+                maven: z.ZodBoolean;
+                gradle: z.ZodBoolean;
+            }, z.core.$strict>;
+            ruby: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                version: z.ZodString;
+                gems: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            php: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                version: z.ZodString;
+                composer: z.ZodBoolean;
+            }, z.core.$strict>;
+            deno: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            }, z.core.$strict>;
+            pwsh: z.ZodObject<{
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            }, z.core.$strict>;
+            cli: z.ZodObject<{
+                gh: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                zstd: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+                openssl: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            }, z.core.$strict>;
+            bun: z.ZodObject<{
+                enabled: z.ZodBoolean;
+            }, z.core.$strict>;
+            uv: z.ZodObject<{
+                enabled: z.ZodBoolean;
+            }, z.core.$strict>;
+            vcRuntime: z.ZodObject<{
+                enabled: z.ZodBoolean;
+            }, z.core.$strict>;
+            mesa: z.ZodObject<{
+                enabled: z.ZodBoolean;
+                vulkan: z.ZodBoolean;
+            }, z.core.$strict>;
+            vscode: z.ZodObject<{
+                enabled: z.ZodBoolean;
+            }, z.core.$strict>;
+            environment: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>;
+        versions: z.ZodObject<{
+            node: z.ZodObject<{
+                spec: z.ZodString;
+                source: z.ZodString;
+            }, z.core.$strict>;
+            nodeExtra: z.ZodArray<z.ZodString>;
+            python: z.ZodObject<{
+                spec: z.ZodString;
+                source: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        databases: z.ZodArray<z.ZodObject<{
+            database: z.ZodEnum<{
+                postgres: "postgres";
+                mysql: "mysql";
+                mongodb: "mongodb";
+                redis: "redis";
+                dynamodb: "dynamodb";
+                sqlserver: "sqlserver";
+            }>;
+            reasons: z.ZodArray<z.ZodString>;
+            version: z.ZodString;
+            port: z.ZodNumber;
+            adminPort: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        harnesses: z.ZodRecord<z.ZodString, z.ZodObject<{
+            hostExecutable: z.ZodOptional<z.ZodString>;
+            hostDir: z.ZodOptional<z.ZodString>;
+            npmPackage: z.ZodOptional<z.ZodString>;
+            npmBin: z.ZodOptional<z.ZodString>;
+            uvPackage: z.ZodOptional<z.ZodString>;
+            uvBin: z.ZodOptional<z.ZodString>;
+            arguments: z.ZodArray<z.ZodString>;
+            environment: z.ZodRecord<z.ZodString, z.ZodString>;
+            resumeArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        hooks: z.ZodBoolean;
+    }, z.core.$strict>;
     createdAt: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"exec">;
@@ -39,6 +461,7 @@ export declare const GuestRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"restart">;
     id: z.ZodString;
     harness: z.ZodNullable<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
     createdAt: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"ping">;
@@ -61,6 +484,7 @@ export declare const SessionStatus: z.ZodObject<{
     launchId: z.ZodString;
     harness: z.ZodString;
     cwd: z.ZodString;
+    project: z.ZodOptional<z.ZodString>;
     phase: z.ZodEnum<{
         failed: "failed";
         starting: "starting";
@@ -77,6 +501,25 @@ export declare const SessionStatus: z.ZodObject<{
         token: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strip>;
+/** C:\AgentData\run\projects\<name>.json: how far a project's provisioning is (guest-written, so validated and capped). */
+export declare const ProjectStatus: z.ZodObject<{
+    name: z.ZodString;
+    workspace: z.ZodString;
+    phase: z.ZodEnum<{
+        provisioning: "provisioning";
+        ready: "ready";
+        failed: "failed";
+    }>;
+    message: z.ZodString;
+    updatedAt: z.ZodString;
+    databases: z.ZodArray<z.ZodObject<{
+        database: z.ZodString;
+        port: z.ZodNumber;
+    }, z.core.$strip>>;
+    summary: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ProjectSpecT = z.output<typeof ProjectSpec>;
+export type ProjectStatusT = z.output<typeof ProjectStatus>;
 export type AttachEndpointT = z.output<typeof AttachEndpoint>;
 export type SandboxStatusT = z.output<typeof SandboxStatus>;
 export type GuestRequestT = z.output<typeof GuestRequest>;

package/dist/shared/schema.js

@@ -1,6 +1,7 @@
 // The host <-> sandbox channel messages, defined once with zod. Both sides parse what they read: the guest only acts on
 // these request kinds, and the host treats everything the guest writes as untrusted (shapes checked, sizes capped).
 import { z } from 'zod';
+import { Harness, Toolchains } from '../core/schema.js';
 export const Id = z.string().regex(/^[A-Za-z0-9_-]{1,64}$/, 'invalid id');
 const Text = (max = 4096) => z.string().max(max);
 const Time = Text(64);
@@ -19,11 +20,37 @@ export const SandboxStatus = z.object({
     guestWorkspace: Text(),
     headless: z.boolean(),
 });
+const Version = z.strictObject({ spec: Text(128), source: Text(256) });
+const DatabasePlan = z.strictObject({
+    database: z.enum(['postgres', 'mysql', 'sqlserver', 'mongodb', 'redis', 'dynamodb']),
+    reasons: z.array(Text(1024)).max(32), version: Text(64), port: z.number().int().min(1024).max(65535), adminPort: z.number().int().min(1024).max(65535).optional(),
+});
+/**
+ * A project the host registered after boot (sandbox claude from another folder): everything the guest needs to
+ * provision it and run its sessions with its own environment, resolved on the host exactly like a fresh launch (its
+ * approved .sandbox-config.json, version files, toolchain detection, database plan). Host -> guest only.
+ */
+export const ProjectSpec = z.strictObject({
+    name: Id,
+    /** Inside the sandbox: C:\Projects\<name>. */
+    workspace: Text(1024),
+    workspaceHost: Text(1024),
+    toolchains: Toolchains,
+    versions: z.strictObject({ node: Version, nodeExtra: z.array(Text(128)).max(16), python: Version }),
+    databases: z.array(DatabasePlan).max(8),
+    /** Agents this project may start that the sandbox did not boot with (its .sandbox-config.json "harness"). */
+    harnesses: z.record(Text(64), Harness).refine((h) => Object.keys(h).length <= 8, 'at most 8 agents'),
+    /** Its hooks were staged in C:\AgentLaunch\projects\<name>\hooks. */
+    hooks: z.boolean(),
+});
 /** C:\AgentData\run\requests\<id>.json: the ONLY things the host can ask the sandbox to do. */
 export const GuestRequest = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('session'), id: Id, harness: Text(64), args: z.array(Text()).max(256), cwd: Text(), createdAt: Time }),
+    z.strictObject({ kind: z.literal('session'), id: Id, harness: Text(64), args: z.array(Text()).max(256), cwd: Text(), project: ProjectSpec.optional(), harnessSpec: Harness.optional(), createdAt: Time }),
+    /** Provision a registered project without starting an agent (sandbox start / exec / db from its folder). */
+    z.strictObject({ kind: z.literal('project'), id: Id, project: ProjectSpec, createdAt: Time }),
     z.strictObject({ kind: z.literal('exec'), id: Id, command: z.array(Text()).min(1).max(256), cwd: Text(), timeoutSeconds: z.number().positive().max(86400), createdAt: Time }),
-    z.strictObject({ kind: z.literal('restart'), id: Id, harness: Text(64).nullable(), createdAt: Time }),
+    /** cwd: only the sessions in this folder or below (one project's); omitted = every session. */
+    z.strictObject({ kind: z.literal('restart'), id: Id, harness: Text(64).nullable(), cwd: Text().optional(), createdAt: Time }),
     z.strictObject({ kind: z.literal('ping'), id: Id, createdAt: Time }),
 ]);
 /** C:\AgentData\run\responses\<id>.json: the guest's reply. */
@@ -42,6 +69,8 @@ export const SessionStatus = z.object({
     launchId: Text(64),
     harness: Text(64),
     cwd: Text(),
+    /** The project it runs in: its hub name, or the launch folder's for the first project. */
+    project: Text(64).optional(),
     phase: z.enum(['starting', 'running', 'exited', 'failed']),
     message: Text(),
     updatedAt: Time,
@@ -49,3 +78,13 @@ export const SessionStatus = z.object({
     exitCode: z.number().int().optional(),
     attach: AttachEndpoint.optional(),
 });
+/** C:\AgentData\run\projects\<name>.json: how far a project's provisioning is (guest-written, so validated and capped). */
+export const ProjectStatus = z.object({
+    name: Id,
+    workspace: Text(1024),
+    phase: z.enum(['provisioning', 'ready', 'failed']),
+    message: Text(),
+    updatedAt: Time,
+    databases: z.array(z.object({ database: Text(32), port: z.number().int() })).max(16),
+    summary: z.array(Text(512)).max(64),
+});

package/dist/shared/test-guard.d.ts

@@ -0,0 +1,4 @@
+export declare const selfTestRunning: () => boolean;
+/** Why the self-test may not write, copy or delete at `target` (anywhere but the temp folder), or null. */
+export declare const testWriteRefusal: (target: string) => string | null;
+export declare const assertTestWritable: (target: string) => void;

package/dist/shared/test-guard.js

@@ -0,0 +1,37 @@
+// Defence in depth for the self-test: while AGENT_SANDBOX_SELFTEST=1 is set, nothing may act on the real PC. Every write or
+// delete on the host is limited to the temp folder the tests use (outward actions refuse in host/test-guard.ts). The
+// self-test sets the variable for itself and its child processes. No imports from core/: the sandbox bundles this file too.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export const selfTestRunning = () => process.env.AGENT_SANDBOX_SELFTEST === '1';
+/** Resolves links in the part of the path that exists, so C:\Users\WDAGUT~1 and C:\Users\WDAGUtilityAccount compare equal. */
+const canonical = (p) => {
+    let rest = '';
+    let current = path.resolve(p);
+    for (;;) {
+        try {
+            return path.join(fs.realpathSync.native(current), rest).toLowerCase();
+        }
+        catch {
+            const parent = path.dirname(current);
+            if (parent === current)
+                return path.resolve(p).toLowerCase();
+            rest = path.join(path.basename(current), rest);
+            current = parent;
+        }
+    }
+};
+/** Why the self-test may not write, copy or delete at `target` (anywhere but the temp folder), or null. */
+export const testWriteRefusal = (target) => {
+    if (!selfTestRunning())
+        return null;
+    const temp = canonical(os.tmpdir());
+    const t = canonical(target);
+    return t === temp || t.startsWith(temp + path.sep) ? null : 'The self-test refused to change ' + target + ': it only works in temp folders, so it can never change this PC.';
+};
+export const assertTestWritable = (target) => {
+    const refusal = testWriteRefusal(target);
+    if (refusal)
+        throw new Error(refusal);
+};

package/dist/sync/claude-mem.js

@@ -9,6 +9,7 @@ import path from 'node:path';
 import _ from 'lodash';
 import { dirExists, homeDir, isLink } from '../core/util.js';
 import { safeRemove } from '../shared/safe-remove.js';
+import { assertTestWritable } from '../host/test-guard.js';
 const SKIP_IN = /(^logs$|\.pid$|\.port$|\.lock$|^worker.*\.json$|\.incoming$|\.conflict-\d+$)/i;
 /** The only files that may come back from the sandbox. */
 const DATABASE = /^claude-mem\.db(-wal|-shm)?$/i;
@@ -22,7 +23,7 @@ const stampOf = (dir) => _.max(databaseFiles(dir).map((f) => fs.statSync(path.jo
 const mirrorIn = (hostDir, store) => {
     const incoming = store + '.incoming';
     safeRemove(incoming, path.dirname(store));
-    fs.cpSync(hostDir, incoming, { recursive: true, filter: (src) => src === hostDir || !SKIP_IN.test(path.basename(src)) });
+    fs.cpSync(hostDir, incoming, { recursive: true, filter: (src) => src === hostDir || (!SKIP_IN.test(path.basename(src)) && !isLink(src)) });
     safeRemove(store, path.dirname(store));
     fs.renameSync(incoming, store);
 };
@@ -50,6 +51,7 @@ const parkHostDatabases = (hostDir) => {
  * overwritten is kept as `<dir>.conflict-<time>` first, so nothing is ever lost.
  */
 export const syncClaudeMem = (hostDir, store, state, direction) => {
+    assertTestWritable(direction === 'in' ? store : hostDir);
     if (isLink(store))
         throw new Error('Refusing to sync claude-mem: ' + store + ' is a link.');
     const hostStamp = stampOf(hostDir);

package/dist/sync/history.d.ts

@@ -1,24 +1,34 @@
+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>;
+    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;
+}) => 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 +36,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;