zeitlich 0.2.29 → 0.2.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeitlich",
-  "version": "0.2.29",
+  "version": "0.2.30",
   "description": "[EXPERIMENTAL] An opinionated AI agent implementation for Temporal",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/src/adapters/thread/anthropic/thread-manager.ts

@@ -1,12 +1,12 @@
 import type Redis from "ioredis";
 import type Anthropic from "@anthropic-ai/sdk";
 import type { JsonValue } from "../../../lib/state/types";
-import {
-  createThreadManager,
-  type ProviderThreadManager,
-  type ThreadManagerConfig,
-  type ThreadManagerHooks,
-} from "../../../lib/thread";
+import { createThreadManager } from "../../../lib/thread/manager";
+import type {
+  ProviderThreadManager,
+  ThreadManagerConfig,
+  ThreadManagerHooks,
+} from "../../../lib/thread/types";
 
 /** SDK-native content type for Anthropic human messages */
 export type AnthropicContent =

package/src/adapters/thread/google-genai/thread-manager.ts

@@ -1,11 +1,11 @@
 import type Redis from "ioredis";
 import type { Content, Part } from "@google/genai";
-import {
-  createThreadManager,
-  type ProviderThreadManager,
-  type ThreadManagerConfig,
-  type ThreadManagerHooks,
-} from "../../../lib/thread";
+import { createThreadManager } from "../../../lib/thread/manager";
+import type {
+  ProviderThreadManager,
+  ThreadManagerConfig,
+  ThreadManagerHooks,
+} from "../../../lib/thread/types";
 import type { GoogleGenAIToolResponse } from "./activities";
 
 /** SDK-native content type for Google GenAI human messages */

package/src/adapters/thread/langchain/thread-manager.ts

@@ -10,12 +10,12 @@ import {
   ToolMessage,
   mapStoredMessagesToChatMessages,
 } from "@langchain/core/messages";
-import {
-  createThreadManager,
-  type ProviderThreadManager,
-  type ThreadManagerConfig,
-  type ThreadManagerHooks,
-} from "../../../lib/thread";
+import { createThreadManager } from "../../../lib/thread/manager";
+import type {
+  ProviderThreadManager,
+  ThreadManagerConfig,
+  ThreadManagerHooks,
+} from "../../../lib/thread/types";
 
 /** SDK-native content type for LangChain human messages */
 export type LangChainContent = string | MessageContent;

package/src/index.ts

@@ -57,6 +57,7 @@ export type { AgentStateContext } from "./lib/activity";
 
 // Sandbox (activity-side: manager + Node.js filesystem adapter)
 export { SandboxManager } from "./lib/sandbox/manager";
+export type { SandboxManagerHooks, PreCreateHookResult } from "./lib/sandbox/manager";
 export { NodeFsSandboxFileSystem } from "./lib/sandbox/node-fs";
 
 // Virtual filesystem (activity-side)

package/src/lib/lifecycle.ts

@@ -22,7 +22,9 @@ export type ThreadInit =
 /**
  * Sandbox initialization strategy.
  *
- * - `"new"` — create a fresh sandbox.
+ * - `"new"` — create a fresh sandbox. Optionally pass `ctx` to
+ *   have the {@link SandboxManager}'s resolver produce creation options
+ *   (e.g. initial files) from workflow arguments.
  * - `"continue"` — resume a previously-paused sandbox (this session takes
  *   ownership and the shutdown policy applies on exit).
  * - `"fork"` — fork from an existing (or paused) sandbox; a new sandbox is
@@ -31,10 +33,13 @@ export type ThreadInit =
  *   The session will **not** manage its lifecycle on exit.
  */
 export type SandboxInit =
-  | { mode: "new" }
+  | { mode: "new"; ctx?: unknown }
   | { mode: "continue"; sandboxId: string }
   | { mode: "fork"; sandboxId: string }
-  | { mode: "inherit"; sandboxId: string; stateUpdate?: Record<string, unknown> };
+  | {
+      mode: "inherit";
+      sandboxId: string;
+    };
 
 /**
  * What to do with the sandbox when the session exits.

package/src/lib/sandbox/index.ts

@@ -1,4 +1,5 @@
 export { SandboxManager } from "./manager";
+export type { SandboxManagerHooks, PreCreateHookResult } from "./manager";
 export { toTree } from "./tree";
 export type {
   Sandbox,
@@ -13,7 +14,4 @@ export type {
   DirentEntry,
   FileStat,
 } from "./types";
-export {
-  SandboxNotFoundError,
-  SandboxNotSupportedError,
-} from "./types";
+export { SandboxNotFoundError, SandboxNotSupportedError } from "./types";

package/src/lib/sandbox/manager.ts

@@ -7,12 +7,64 @@ import type {
   SandboxSnapshot,
 } from "./types";
 
+/**
+ * Result returned by {@link SandboxManagerHooks.onPreCreate}.
+ *
+ * - Set `skip: true` to prevent sandbox creation entirely.
+ * - Set `modifiedOptions` to override/extend the creation options that will
+ *   be forwarded to the provider. Fields in `modifiedOptions` are merged on
+ *   top of the original options (`initialFiles` and `env` are shallow-merged;
+ *   everything else is overwritten).
+ */
+export interface PreCreateHookResult<
+  TOptions extends SandboxCreateOptions = SandboxCreateOptions,
+> {
+  skip?: boolean;
+  modifiedOptions?: Partial<TOptions>;
+}
+
+/**
+ * Lifecycle hooks for {@link SandboxManager}.
+ *
+ * Hooks run inside the existing `createSandbox` activity — no additional
+ * activity registration required.
+ */
+export interface SandboxManagerHooks<
+  TOptions extends SandboxCreateOptions = SandboxCreateOptions,
+  TCtx = unknown,
+> {
+  /**
+   * Called before sandbox creation.
+   *
+   * Receives the provider options and an opaque `ctx` value set from the
+   * workflow's {@link SandboxInit}. Use `ctx` to derive additional creation
+   * options (e.g. initial files from workflow arguments).
+   *
+   * Return `{ skip: true }` to prevent creation, or `{ modifiedOptions }`
+   * to alter the options before they reach the provider.
+   */
+  onPreCreate?: (
+    options: TOptions,
+    ctx: TCtx
+  ) => Promise<PreCreateHookResult<TOptions> | undefined>;
+
+  /**
+   * Called after a sandbox has been successfully created.
+   */
+  onPostCreate?: (sandboxId: string) => Promise<void>;
+}
+
 /**
  * Stateless facade over a {@link SandboxProvider}.
  *
  * Delegates all lifecycle operations to the provider, which is responsible
  * for its own instance management strategy (e.g. in-memory map, remote API).
  *
+ * Optional {@link SandboxManagerHooks} can be passed at construction time.
+ * The `onPreCreate` hook runs inside the `createSandbox` activity, receiving
+ * the provider options and an opaque `ctx` value from the workflow's
+ * {@link SandboxInit}. It can modify options or skip creation entirely.
+ *
  * @example
  * ```typescript
  * const manager = new SandboxManager(new InMemorySandboxProvider());
@@ -22,21 +74,84 @@ import type {
  * };
  * // registers: inMemoryCodingAgentCreateSandbox, …
  * ```
+ *
+ * @example
+ * ```typescript
+ * const manager = new SandboxManager(
+ *   new DaytonaSandboxProvider(config),
+ *   {
+ *     hooks: {
+ *       onPreCreate: async (options, ctx) => {
+ *         const { projectId, filePaths } = ctx as { projectId: string; filePaths: string[] };
+ *         const files: Record<string, string> = {};
+ *         for (const p of filePaths) files[p] = await db.readFile(projectId, p);
+ *         return { modifiedOptions: { initialFiles: files } };
+ *       },
+ *       onPostCreate: async (sandboxId) => {
+ *         console.log("Sandbox created:", sandboxId);
+ *       },
+ *     },
+ *   },
+ * );
+ * ```
  */
 export class SandboxManager<
   TOptions extends SandboxCreateOptions = SandboxCreateOptions,
   TSandbox extends Sandbox = Sandbox,
   TId extends string = string,
+  TCtx = unknown,
 > {
+  private hooks: SandboxManagerHooks<TOptions, TCtx>;
+
   constructor(
-    private provider: SandboxProvider<TOptions, TSandbox> & { readonly id: TId }
-  ) {}
+    private provider: SandboxProvider<TOptions, TSandbox> & {
+      readonly id: TId;
+    },
+    options?: { hooks?: SandboxManagerHooks<TOptions, TCtx> }
+  ) {
+    this.hooks = options?.hooks ?? {};
+  }
 
   async create(
-    options?: TOptions
-  ): Promise<{ sandboxId: string; stateUpdate?: Record<string, unknown> }> {
-    const { sandbox, stateUpdate } = await this.provider.create(options);
-    return { sandboxId: sandbox.id, ...(stateUpdate && { stateUpdate }) };
+    options?: TOptions,
+    ctx?: TCtx
+  ): Promise<{
+    sandboxId: string;
+  } | null> {
+    let providerOptions = options;
+
+    if (this.hooks.onPreCreate) {
+      const hookResult = await this.hooks.onPreCreate(
+        options ?? ({} as TOptions),
+        ctx ?? ({} as TCtx)
+      );
+      if (hookResult?.skip) return null;
+
+      if (hookResult?.modifiedOptions) {
+        const orig = options ?? ({} as TOptions);
+        const mod = hookResult.modifiedOptions;
+        providerOptions = {
+          ...mod,
+          ...orig,
+          initialFiles: {
+            ...mod.initialFiles,
+            ...orig.initialFiles,
+          },
+          env: {
+            ...mod.env,
+            ...orig.env,
+          },
+        } as TOptions;
+      }
+    }
+
+    const { sandbox } = await this.provider.create(providerOptions);
+
+    if (this.hooks.onPostCreate) {
+      await this.hooks.onPostCreate(sandbox.id);
+    }
+
+    return { sandboxId: sandbox.id };
   }
 
   async getSandbox(id: string): Promise<TSandbox> {
@@ -87,16 +202,16 @@ export class SandboxManager<
    */
   createActivities<S extends string>(
     scope: S
-  ): PrefixedSandboxOps<`${TId}${Capitalize<S>}`, TOptions> {
+  ): PrefixedSandboxOps<`${TId}${Capitalize<S>}`, TOptions, TCtx> {
     const prefix = `${this.provider.id}${scope.charAt(0).toUpperCase()}${scope.slice(1)}`;
-    const ops: SandboxOps<TOptions> = {
+    const ops: SandboxOps<TOptions, TCtx> = {
       createSandbox: async (
-        options?: TOptions
+        options?: TOptions,
+        ctx?: TCtx
       ): Promise<{
         sandboxId: string;
-        stateUpdate?: Record<string, unknown>;
-      }> => {
-        return this.create(options);
+      } | null> => {
+        return this.create(options, ctx);
       },
       destroySandbox: async (sandboxId: string): Promise<void> => {
         await this.destroy(sandboxId);
@@ -117,6 +232,6 @@ export class SandboxManager<
     const cap = (s: string): string => s.charAt(0).toUpperCase() + s.slice(1);
     return Object.fromEntries(
       Object.entries(ops).map(([k, v]) => [`${prefix}${cap(k)}`, v])
-    ) as PrefixedSandboxOps<`${TId}${Capitalize<S>}`, TOptions>;
+    ) as PrefixedSandboxOps<`${TId}${Capitalize<S>}`, TOptions, TCtx>;
   }
 }

package/src/lib/sandbox/sandbox.test.ts

@@ -1,7 +1,20 @@
 import { describe, expect, it, beforeEach } from "vitest";
 import { SandboxManager } from "./manager";
 import { InMemorySandboxProvider } from "../../adapters/sandbox/inmemory/index";
-import { SandboxNotFoundError, type Sandbox, type SandboxCreateOptions } from "./types";
+import {
+  SandboxNotFoundError,
+  type Sandbox,
+  type SandboxCreateOptions,
+} from "./types";
+
+async function mustCreate<T extends SandboxCreateOptions, TId extends string>(
+  mgr: SandboxManager<T, Sandbox, TId>,
+  options?: T
+): Promise<{ sandboxId: string }> {
+  const result = await mgr.create(options);
+  expect(result).not.toBeNull();
+  return result as NonNullable<typeof result>;
+}
 
 describe("SandboxManager", () => {
   let manager: SandboxManager<SandboxCreateOptions, Sandbox, "inMemory">;
@@ -11,34 +24,36 @@ describe("SandboxManager", () => {
   });
 
   it("creates a sandbox and returns an id", async () => {
-    const { sandboxId } = await manager.create();
+    const { sandboxId } = await mustCreate(manager);
     expect(sandboxId).toBeTruthy();
     const sandbox = await manager.getSandbox(sandboxId);
     expect(sandbox.id).toBe(sandboxId);
   });
 
   it("creates a sandbox with a custom id", async () => {
-    const { sandboxId } = await manager.create({ id: "my-sandbox" });
+    const { sandboxId } = await mustCreate(manager, { id: "my-sandbox" });
     expect(sandboxId).toBe("my-sandbox");
   });
 
   it("gets an existing sandbox", async () => {
-    const { sandboxId } = await manager.create();
+    const { sandboxId } = await mustCreate(manager);
     const sandbox = await manager.getSandbox(sandboxId);
     expect(sandbox.id).toBe(sandboxId);
   });
 
   it("throws SandboxNotFoundError for unknown id", async () => {
     await expect(manager.getSandbox("nonexistent")).rejects.toThrow(
-      SandboxNotFoundError,
+      SandboxNotFoundError
     );
   });
 
   it("destroys a sandbox", async () => {
-    const { sandboxId } = await manager.create();
+    const { sandboxId } = await mustCreate(manager);
     await manager.getSandbox(sandboxId);
     await manager.destroy(sandboxId);
-    await expect(manager.getSandbox(sandboxId)).rejects.toThrow(SandboxNotFoundError);
+    await expect(manager.getSandbox(sandboxId)).rejects.toThrow(
+      SandboxNotFoundError
+    );
   });
 
   it("destroy is idempotent for unknown ids", async () => {
@@ -46,7 +61,7 @@ describe("SandboxManager", () => {
   });
 
   it("snapshots and restores a sandbox", async () => {
-    const { sandboxId } = await manager.create({
+    const { sandboxId } = await mustCreate(manager, {
       initialFiles: { "/data.txt": "hello" },
     });
     const sandbox = await manager.getSandbox(sandboxId);
@@ -57,7 +72,9 @@ describe("SandboxManager", () => {
     expect(snapshot.providerId).toBe("inMemory");
 
     await manager.destroy(sandboxId);
-    await expect(manager.getSandbox(sandboxId)).rejects.toThrow(SandboxNotFoundError);
+    await expect(manager.getSandbox(sandboxId)).rejects.toThrow(
+      SandboxNotFoundError
+    );
 
     const restoredId = await manager.restore(snapshot);
     expect(restoredId).toBe(sandboxId);
@@ -68,6 +85,107 @@ describe("SandboxManager", () => {
     expect(extra).toBe("world");
   });
 
+  it("onPreCreate hook merges modifiedOptions into create options", async () => {
+    const mgr = new SandboxManager(new InMemorySandboxProvider(), {
+      hooks: {
+        onPreCreate: async (_options, ctx) => {
+          const { paths } = ctx as { paths: string[] };
+          const files: Record<string, string> = {};
+          for (const p of paths) files[p] = `content of ${p}`;
+          return {
+            modifiedOptions: { initialFiles: files, env: { RESOLVED: "true" } },
+          };
+        },
+      },
+    });
+
+    const result = await mgr.create(
+      { initialFiles: { "/extra.txt": "extra" } },
+      { paths: ["/a.txt", "/b.txt"] }
+    );
+    expect(result).not.toBeNull();
+    const { sandboxId } = result as NonNullable<typeof result>;
+
+    const sandbox = await mgr.getSandbox(sandboxId);
+    expect(await sandbox.fs.readFile("/a.txt")).toBe("content of /a.txt");
+    expect(await sandbox.fs.readFile("/b.txt")).toBe("content of /b.txt");
+    expect(await sandbox.fs.readFile("/extra.txt")).toBe("extra");
+  });
+
+  it("ctx is not forwarded to provider when no hooks registered", async () => {
+    const result = await manager.create(
+      { initialFiles: { "/test.txt": "ok" } },
+      { foo: "bar" }
+    );
+    expect(result).not.toBeNull();
+    const { sandboxId } = result as NonNullable<typeof result>;
+    const sandbox = await manager.getSandbox(sandboxId);
+    expect(await sandbox.fs.readFile("/test.txt")).toBe("ok");
+  });
+
+  it("onPreCreate hook can skip sandbox creation", async () => {
+    const mgr = new SandboxManager(new InMemorySandboxProvider(), {
+      hooks: {
+        onPreCreate: async () => ({ skip: true }),
+      },
+    });
+
+    const result = await mgr.create(undefined, { skip: true });
+    expect(result).toBeNull();
+  });
+
+  it("original options take precedence over hook modifiedOptions", async () => {
+    const mgr = new SandboxManager(new InMemorySandboxProvider(), {
+      hooks: {
+        onPreCreate: async () => ({
+          modifiedOptions: {
+            initialFiles: { "/file.txt": "from-hook" },
+            env: { KEY: "hook" },
+          },
+        }),
+      },
+    });
+
+    const result = await mgr.create(
+      { initialFiles: { "/file.txt": "explicit" } },
+      {}
+    );
+    expect(result).not.toBeNull();
+    const { sandboxId } = result as NonNullable<typeof result>;
+
+    const sandbox = await mgr.getSandbox(sandboxId);
+    expect(await sandbox.fs.readFile("/file.txt")).toBe("explicit");
+  });
+
+  it("onPostCreate hook receives sandboxId", async () => {
+    let capturedId: string | undefined;
+    const mgr = new SandboxManager(new InMemorySandboxProvider(), {
+      hooks: {
+        onPostCreate: async (sandboxId) => {
+          capturedId = sandboxId;
+        },
+      },
+    });
+
+    const { sandboxId } = await mustCreate(mgr);
+    expect(capturedId).toBe(sandboxId);
+  });
+
+  it("onPostCreate hook does not run when creation is skipped", async () => {
+    let postCalled = false;
+    const mgr = new SandboxManager(new InMemorySandboxProvider(), {
+      hooks: {
+        onPreCreate: async () => ({ skip: true }),
+        onPostCreate: async () => {
+          postCalled = true;
+        },
+      },
+    });
+
+    await mgr.create();
+    expect(postCalled).toBe(false);
+  });
+
   it("createActivities returns prefixed SandboxOps-shaped object", async () => {
     // provider.id is "inMemory", scope is "Test" → prefix "inMemoryTest"
     const activities = manager.createActivities("Test");
@@ -75,12 +193,14 @@ describe("SandboxManager", () => {
     expect(activities.inMemoryTestDestroySandbox).toBeTypeOf("function");
     expect(activities.inMemoryTestSnapshotSandbox).toBeTypeOf("function");
 
-    const { sandboxId } = await activities.inMemoryTestCreateSandbox();
+    const result = await activities.inMemoryTestCreateSandbox();
+    expect(result).not.toBeNull();
+    const { sandboxId } = result as NonNullable<typeof result>;
     await expect(manager.getSandbox(sandboxId)).resolves.toBeTruthy();
 
     await activities.inMemoryTestDestroySandbox(sandboxId);
     await expect(manager.getSandbox(sandboxId)).rejects.toThrow(
-      SandboxNotFoundError,
+      SandboxNotFoundError
     );
   });
 });
@@ -93,7 +213,7 @@ describe("InMemorySandboxProvider", () => {
   });
 
   it("creates sandbox with initial files", async () => {
-    const { sandboxId } = await manager.create({
+    const { sandboxId } = await mustCreate(manager, {
       initialFiles: {
         "/src/index.ts": 'console.log("hello");',
         "/README.md": "# Hello",
@@ -105,7 +225,7 @@ describe("InMemorySandboxProvider", () => {
   });
 
   it("supports filesystem operations", async () => {
-    const { sandboxId } = await manager.create();
+    const { sandboxId } = await mustCreate(manager);
     const { fs } = await manager.getSandbox(sandboxId);
 
     await fs.writeFile("/test.txt", "hello");
@@ -124,7 +244,7 @@ describe("InMemorySandboxProvider", () => {
   });
 
   it("supports shell execution", async () => {
-    const { sandboxId } = await manager.create({
+    const { sandboxId } = await mustCreate(manager, {
       initialFiles: { "/data.txt": "hello world" },
     });
     const sandbox = await manager.getSandbox(sandboxId);
@@ -135,7 +255,7 @@ describe("InMemorySandboxProvider", () => {
   });
 
   it("reports correct capabilities", async () => {
-    const { sandboxId } = await manager.create();
+    const { sandboxId } = await mustCreate(manager);
     const sandbox = await manager.getSandbox(sandboxId);
     expect(sandbox.capabilities).toEqual({
       filesystem: true,
@@ -145,7 +265,7 @@ describe("InMemorySandboxProvider", () => {
   });
 
   it("readdirWithFileTypes works", async () => {
-    const { sandboxId } = await manager.create({
+    const { sandboxId } = await mustCreate(manager, {
       initialFiles: {
         "/dir/a.txt": "a",
         "/dir/b.txt": "b",

package/src/lib/sandbox/types.ts

@@ -118,8 +118,6 @@ export interface SandboxCreateOptions {
 
 export interface SandboxCreateResult {
   sandbox: Sandbox;
-  /** Optional state to merge into the workflow's `AgentState` via the session. */
-  stateUpdate?: Record<string, unknown>;
 }
 
 export interface SandboxProvider<
@@ -144,10 +142,12 @@ export interface SandboxProvider<
 
 export interface SandboxOps<
   TOptions extends SandboxCreateOptions = SandboxCreateOptions,
+  TCtx = unknown,
 > {
   createSandbox(
-    options?: TOptions
-  ): Promise<{ sandboxId: string; stateUpdate?: Record<string, unknown> }>;
+    options?: TOptions,
+    ctx?: TCtx
+  ): Promise<{ sandboxId: string } | null>;
   destroySandbox(sandboxId: string): Promise<void>;
   pauseSandbox(sandboxId: string): Promise<void>;
   snapshotSandbox(sandboxId: string): Promise<SandboxSnapshot>;
@@ -166,8 +166,9 @@ export interface SandboxOps<
 export type PrefixedSandboxOps<
   TPrefix extends string,
   TOptions extends SandboxCreateOptions = SandboxCreateOptions,
+  TCtx = unknown,
 > = {
-  [K in keyof SandboxOps<TOptions> as `${TPrefix}${Capitalize<K & string>}`]: SandboxOps<TOptions>[K];
+  [K in keyof SandboxOps<TOptions, TCtx> as `${TPrefix}${Capitalize<K & string>}`]: SandboxOps<TOptions, TCtx>[K];
 };
 
 // ============================================================================

package/src/lib/session/session.integration.test.ts

@@ -46,7 +46,13 @@ vi.mock("@temporalio/workflow", () => {
     uuid4: () =>
       `00000000-0000-0000-0000-${String(++idCounter).padStart(12, "0")}`,
     ApplicationFailure: MockApplicationFailure,
-    log: { trace: () => {}, debug: () => {}, info: () => {}, warn: () => {}, error: () => {} },
+    log: {
+      trace: () => {},
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+    },
   };
 });
 
@@ -791,45 +797,6 @@ describe("createSession integration", () => {
     expect(at(humanOps, 0).args[2]).toBe("async context");
   });
 
-  // --- Sandbox stateUpdate merge ---
-
-  it("merges sandbox stateUpdate into state manager", async () => {
-    const { ops } = createMockThreadOps();
-
-    const sandboxOps: SandboxOps = {
-      createSandbox: async () => ({
-        sandboxId: "sb-1",
-        stateUpdate: { customField: "from-sandbox" },
-      }),
-      destroySandbox: async () => {},
-      snapshotSandbox: async () => ({
-        sandboxId: "sb-1",
-        providerId: "test",
-        data: null,
-        createdAt: new Date().toISOString(),
-      }),
-      forkSandbox: async () => "forked-sandbox-id",
-      pauseSandbox: async () => {},
-    };
-
-    const session = await createSession({
-      agentName: "TestAgent",
-      thread: { mode: "new", threadId: "thread-1" },
-      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
-      threadOps: ops,
-      buildContextMessage: () => "go",
-      sandboxOps,
-    });
-
-    const stateManager = createAgentStateManager<{ customField: string }>({
-      initialState: { systemPrompt: "test", customField: "" },
-    });
-
-    await session.runSession({ stateManager });
-
-    expect(stateManager.get("customField")).toBe("from-sandbox");
-  });
-
   // --- Skill resourceContents seeded as initialFiles ---
 
   it("passes skill resourceContents as initialFiles to createSandbox", async () => {