windows-development-sandbox 1.0.5 → 1.4.0

package/dist/shared/schema.d.ts

@@ -19,7 +19,150 @@ export declare const SandboxStatus: z.ZodObject<{
     workspaceHost: z.ZodString;
     guestWorkspace: z.ZodString;
     headless: z.ZodBoolean;
+    addresses: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, 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;
+            setup: z.ZodBoolean;
+            recommended: z.ZodBoolean;
+            extensions: z.ZodArray<z.ZodString>;
+        }, 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 +170,295 @@ 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;
+                setup: z.ZodBoolean;
+                recommended: z.ZodBoolean;
+                extensions: z.ZodArray<z.ZodString>;
+            }, 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;
+                setup: z.ZodBoolean;
+                recommended: z.ZodBoolean;
+                extensions: z.ZodArray<z.ZodString>;
+            }, 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 +471,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 +494,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 +511,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);
@@ -18,12 +19,40 @@ export const SandboxStatus = z.object({
     workspaceHost: Text(),
     guestWorkspace: Text(),
     headless: z.boolean(),
+    /** The sandbox's IPv4 addresses (for network.forwardPorts; the host only uses ones on its Hyper-V network). */
+    addresses: z.array(z.string().max(45)).max(8).optional(),
+});
+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 +71,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 +80,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/system.d.ts

@@ -12,4 +12,5 @@ export declare const SYSTEM: {
     readonly robocopy: () => string;
     readonly shutdown: () => string;
     readonly dism: () => string;
+    readonly msiexec: () => string;
 };

package/dist/shared/system.js

@@ -16,4 +16,5 @@ export const SYSTEM = {
     robocopy: () => system32('Robocopy.exe'),
     shutdown: () => system32('shutdown.exe'),
     dism: () => system32('Dism.exe'),
+    msiexec: () => system32('msiexec.exe'),
 };

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

@@ -1,7 +1,7 @@
 // claude-mem data (~/.claude-mem) between this PC and the sandbox's persistent store.
 //
 // IN (this PC -> sandbox): the whole folder is mirrored; nothing flows to your PC in that direction.
-// OUT (sandbox -> this PC): ONLY the SQLite database files come back. Never settings, never the Chroma vector store:
+// OUT (sandbox -> this PC), only with claudeProfile.syncClaudeMemBack: ONLY the SQLite database files come back. Never settings, never the Chroma vector store:
 // Chroma keeps Python pickle files, and a crafted pickle runs code when loaded, so copying it back would let a
 // compromised sandbox execute code on your PC. claude-mem rebuilds its vector index from the database by itself.
 import fs from 'node:fs';
@@ -9,7 +9,9 @@ import path from 'node:path';
 import _ from 'lodash';
 import { dirExists, homeDir, isLink } from '../core/util.js';
 import { safeRemove } from '../shared/safe-remove.js';
-const SKIP_IN = /(^logs$|\.pid$|\.port$|\.lock$|^worker.*\.json$|\.incoming$|\.conflict-\d+$)/i;
+import { assertTestWritable } from '../host/test-guard.js';
+// Never in: its settings (provider API keys), .env files and backups; nor run-time files that mean nothing elsewhere.
+const SKIP_IN = /(^logs$|^backups?$|^settings\.json$|^\.env|\.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;
 const MAX_DB_BYTES = 2 * 1024 * 1024 * 1024;
@@ -22,7 +24,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 +52,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);