zeitlich 0.2.33 → 0.2.35

package/package.json

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

package/src/adapters/sandbox/bedrock/index.ts

@@ -237,6 +237,10 @@ export class BedrockSandboxProvider
     throw new SandboxNotSupportedError("pause");
   }
 
+  async resume(_sandboxId: string): Promise<void> {
+    // Bedrock sandboxes don't support pause, so resume is a no-op
+  }
+
   async snapshot(_sandboxId: string): Promise<SandboxSnapshot> {
     throw new SandboxNotSupportedError("snapshot");
   }

package/src/adapters/sandbox/bedrock/proxy.ts

@@ -50,6 +50,7 @@ export function proxyBedrockSandboxOps(
     createSandbox: acts[p("createSandbox")],
     destroySandbox: acts[p("destroySandbox")],
     pauseSandbox: acts[p("pauseSandbox")],
+    resumeSandbox: acts[p("resumeSandbox")],
     snapshotSandbox: acts[p("snapshotSandbox")],
     forkSandbox: acts[p("forkSandbox")],
   } as SandboxOps<BedrockSandboxCreateOptions>;

package/src/adapters/sandbox/daytona/index.ts

@@ -145,6 +145,10 @@ export class DaytonaSandboxProvider implements SandboxProvider<
     throw new SandboxNotSupportedError("pause");
   }
 
+  async resume(_sandboxId: string): Promise<void> {
+    // Daytona sandboxes don't support pause, so resume is a no-op
+  }
+
   async fork(_sandboxId: string): Promise<Sandbox> {
     throw new Error("Not implemented");
   }

package/src/adapters/sandbox/daytona/proxy.ts

@@ -50,6 +50,7 @@ export function proxyDaytonaSandboxOps(
     createSandbox: acts[p("createSandbox")],
     destroySandbox: acts[p("destroySandbox")],
     pauseSandbox: acts[p("pauseSandbox")],
+    resumeSandbox: acts[p("resumeSandbox")],
     snapshotSandbox: acts[p("snapshotSandbox")],
     forkSandbox: acts[p("forkSandbox")],
   } as SandboxOps<DaytonaSandboxCreateOptions>;

package/src/adapters/sandbox/e2b/index.ts

@@ -136,6 +136,10 @@ export class E2bSandboxProvider
     await sdkSandbox.pause();
   }
 
+  async resume(sandboxId: string): Promise<void> {
+    await E2bSdkSandbox.connect(sandboxId);
+  }
+
   async snapshot(_sandboxId: string): Promise<SandboxSnapshot> {
     throw new SandboxNotSupportedError("snapshot");
   }

package/src/adapters/sandbox/e2b/proxy.ts

@@ -50,6 +50,7 @@ export function proxyE2bSandboxOps(
     createSandbox: acts[p("createSandbox")],
     destroySandbox: acts[p("destroySandbox")],
     pauseSandbox: acts[p("pauseSandbox")],
+    resumeSandbox: acts[p("resumeSandbox")],
     snapshotSandbox: acts[p("snapshotSandbox")],
     forkSandbox: acts[p("forkSandbox")],
   } as SandboxOps<E2bSandboxCreateOptions>;

package/src/adapters/sandbox/inmemory/index.ts

@@ -163,6 +163,10 @@ export class InMemorySandboxProvider implements SandboxProvider {
     // In-memory: nothing to pause
   }
 
+  async resume(_sandboxId: string): Promise<void> {
+    // In-memory: nothing to resume
+  }
+
   async create(options?: SandboxCreateOptions): Promise<SandboxCreateResult> {
     const id = options?.id ?? getShortId();
     const initialFiles: InitialFiles = {};

package/src/adapters/sandbox/inmemory/proxy.ts

@@ -47,6 +47,7 @@ export function proxyInMemorySandboxOps(
     createSandbox: acts[p("createSandbox")],
     destroySandbox: acts[p("destroySandbox")],
     pauseSandbox: acts[p("pauseSandbox")],
+    resumeSandbox: acts[p("resumeSandbox")],
     snapshotSandbox: acts[p("snapshotSandbox")],
     forkSandbox: acts[p("forkSandbox")],
   } as SandboxOps;

package/src/adapters/thread/anthropic/activities.ts

@@ -15,6 +15,7 @@ import type { ModelInvoker } from "../../../lib/model";
 import {
   createAnthropicThreadManager,
   type AnthropicContent,
+  type AnthropicSystemContent,
   type AnthropicThreadManagerHooks,
 } from "./thread-manager";
 import {
@@ -152,7 +153,7 @@ export function createAnthropicAdapter(
     async appendSystemMessage(
       threadId: string,
       id: string,
-      content: string,
+      content: AnthropicSystemContent,
       threadKey?: string,
     ): Promise<void> {
       const thread = createAnthropicThreadManager({ redis, threadId, key: threadKey });

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

@@ -13,6 +13,11 @@ export type AnthropicContent =
   | string
   | Anthropic.Messages.ContentBlockParam[];
 
+/** SDK-native content type for Anthropic system prompts (supports cache_control blocks) */
+export type AnthropicSystemContent =
+  | string
+  | Anthropic.Messages.TextBlockParam[];
+
 /** A MessageParam with a unique ID for idempotent Redis storage */
 export interface StoredMessage {
   id: string;
@@ -34,12 +39,12 @@ export interface AnthropicThreadManagerConfig {
 /** Prepared payload ready to send to the Anthropic API */
 export interface AnthropicInvocationPayload {
   messages: Anthropic.Messages.MessageParam[];
-  system?: string;
+  system?: string | Anthropic.Messages.TextBlockParam[];
 }
 
 /** Thread manager with Anthropic MessageParam convenience helpers */
 export interface AnthropicThreadManager
-  extends ProviderThreadManager<StoredMessage, AnthropicContent> {
+  extends ProviderThreadManager<StoredMessage, AnthropicContent, JsonValue, AnthropicSystemContent> {
   appendAssistantMessage(
     id: string,
     content: Anthropic.Messages.ContentBlock[],
@@ -120,11 +125,19 @@ export function createAnthropicThreadManager(
       }]);
     },
 
-    async appendSystemMessage(id: string, content: string): Promise<void> {
+    async appendSystemMessage(
+      id: string,
+      content: AnthropicSystemContent,
+    ): Promise<void> {
       await base.initialize();
       await base.append([{
         id,
-        message: { role: "user", content },
+        // Stored under a user-role placeholder to satisfy the MessageParam
+        // shape; the `isSystem` flag steers extraction in prepareForInvocation.
+        message: {
+          role: "user",
+          content: content as Anthropic.Messages.MessageParam["content"],
+        },
         isSystem: true,
       }]);
     },
@@ -174,15 +187,14 @@ export function createAnthropicThreadManager(
         ? stored.map((msg, i) => onPrepareMessage(msg, i, stored))
         : stored;
 
-      let system: string | undefined;
+      let system: string | Anthropic.Messages.TextBlockParam[] | undefined;
       const conversationMessages: Anthropic.Messages.MessageParam[] = [];
 
       for (const item of mapped) {
         if (item.isSystem) {
-          system =
-            typeof item.message.content === "string"
-              ? item.message.content
-              : undefined;
+          system = item.message.content as
+            | string
+            | Anthropic.Messages.TextBlockParam[];
         } else {
           conversationMessages.push(item.message);
         }

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

@@ -15,6 +15,7 @@ import type { ModelInvoker } from "../../../lib/model";
 import {
   createGoogleGenAIThreadManager,
   type GoogleGenAIContent,
+  type GoogleGenAISystemContent,
   type GoogleGenAIThreadManagerHooks,
 } from "./thread-manager";
 import { createGoogleGenAIModelInvoker } from "./model-invoker";
@@ -169,7 +170,7 @@ export function createGoogleGenAIAdapter(
     async appendSystemMessage(
       threadId: string,
       id: string,
-      content: string,
+      content: GoogleGenAISystemContent,
       threadKey?: string
     ): Promise<void> {
       const thread = createGoogleGenAIThreadManager({

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

@@ -55,7 +55,7 @@ describe("Google GenAI thread manager hooks", () => {
 
       expect(hook).toHaveBeenCalledTimes(3);
       expect(hook).toHaveBeenCalledWith(systemContent, 0, [systemContent, userContent, modelContent]);
-      expect(systemInstruction).toBe("You are helpful.");
+      expect(systemInstruction).toEqual([{ text: "You are helpful." }]);
       expect(contents[0]?.parts?.[0]?.text).toBe("[modified] Hello");
       expect(contents[1]?.parts?.[0]?.text).toBe("[modified] Hi there!");
     });

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

@@ -11,6 +11,9 @@ import type { GoogleGenAIToolResponse } from "./activities";
 /** SDK-native content type for Google GenAI human messages */
 export type GoogleGenAIContent = string | Part[];
 
+/** SDK-native content type for Google GenAI system instructions */
+export type GoogleGenAISystemContent = string | Part[];
+
 /** A Content with a unique ID for idempotent Redis storage */
 export interface StoredContent {
   id: string;
@@ -30,12 +33,12 @@ export interface GoogleGenAIThreadManagerConfig {
 /** Prepared payload ready to send to the Google GenAI API */
 export interface GoogleGenAIInvocationPayload {
   contents: Content[];
-  systemInstruction?: string;
+  systemInstruction?: Part[];
 }
 
 /** Thread manager with Google GenAI Content convenience helpers */
 export interface GoogleGenAIThreadManager
-  extends ProviderThreadManager<StoredContent, GoogleGenAIContent, GoogleGenAIToolResponse> {
+  extends ProviderThreadManager<StoredContent, GoogleGenAIContent, GoogleGenAIToolResponse, GoogleGenAISystemContent> {
   appendModelContent(id: string, parts: Part[]): Promise<void>;
   prepareForInvocation(): Promise<GoogleGenAIInvocationPayload>;
 }
@@ -106,11 +109,16 @@ export function createGoogleGenAIThreadManager(
       }]);
     },
 
-    async appendSystemMessage(id: string, content: string): Promise<void> {
+    async appendSystemMessage(
+      id: string,
+      content: GoogleGenAISystemContent,
+    ): Promise<void> {
+      const parts: Part[] =
+        typeof content === "string" ? [{ text: content }] : content;
       await base.initialize();
       await base.append([{
         id,
-        content: { role: "system", parts: [{ text: content }] },
+        content: { role: "system", parts },
       }]);
     },
 
@@ -150,12 +158,12 @@ export function createGoogleGenAIThreadManager(
         ? stored.map((msg, i) => onPrepareMessage(msg, i, stored))
         : stored;
 
-      let systemInstruction: string | undefined;
+      let systemInstruction: Part[] | undefined;
       const conversationContents: Content[] = [];
 
       for (const item of mapped) {
         if (item.content.role === "system") {
-          systemInstruction = item.content.parts?.[0]?.text;
+          systemInstruction = item.content.parts ?? [];
         } else {
           conversationContents.push(item.content);
         }
@@ -166,7 +174,7 @@ export function createGoogleGenAIThreadManager(
         contents: onPreparedMessage
           ? contents.map((msg, i) => onPreparedMessage(msg, i, contents))
           : contents,
-        ...(systemInstruction ? { systemInstruction } : {}),
+        ...(systemInstruction && systemInstruction.length > 0 ? { systemInstruction } : {}),
       };
     },
   };

package/src/adapters/thread/langchain/activities.ts

@@ -17,6 +17,7 @@ import type { BaseChatModel } from "@langchain/core/language_models/chat_models"
 import {
   createLangChainThreadManager,
   type LangChainContent,
+  type LangChainSystemContent,
   type LangChainThreadManagerHooks,
 } from "./thread-manager";
 import { createLangChainModelInvoker } from "./model-invoker";
@@ -135,7 +136,7 @@ export function createLangChainAdapter(
     async appendSystemMessage(
       threadId: string,
       id: string,
-      content: string,
+      content: LangChainSystemContent,
       threadKey?: string,
     ): Promise<void> {
       const thread = createLangChainThreadManager({ redis, threadId, key: threadKey });

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

@@ -20,6 +20,9 @@ import type {
 /** SDK-native content type for LangChain human messages */
 export type LangChainContent = string | MessageContent;
 
+/** SDK-native content type for LangChain system messages */
+export type LangChainSystemContent = string | MessageContent;
+
 export type LangChainThreadManagerHooks = ThreadManagerHooks<StoredMessage, BaseMessage>;
 
 export interface LangChainThreadManagerConfig {
@@ -37,7 +40,7 @@ export interface LangChainInvocationPayload {
 
 /** Thread manager with LangChain StoredMessage convenience helpers */
 export interface LangChainThreadManager
-  extends ProviderThreadManager<StoredMessage, LangChainContent> {
+  extends ProviderThreadManager<StoredMessage, LangChainContent, JsonValue, LangChainSystemContent> {
   appendAIMessage(id: string, content: string | MessageContent): Promise<void>;
   prepareForInvocation(): Promise<LangChainInvocationPayload>;
 }
@@ -81,10 +84,16 @@ export function createLangChainThreadManager(
       ]);
     },
 
-    async appendSystemMessage(id: string, content: string): Promise<void> {
+    async appendSystemMessage(
+      id: string,
+      content: LangChainSystemContent,
+    ): Promise<void> {
       await base.initialize();
       await base.append([
-        new SystemMessage({ id, content }).toDict(),
+        new SystemMessage({
+          id,
+          content: content as MessageContent,
+        }).toDict(),
       ]);
     },
 

package/src/lib/lifecycle.ts

@@ -25,8 +25,9 @@ export type ThreadInit =
  * - `"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).
+ * - `"continue"` — take ownership of an existing sandbox (paused or running).
+ *   Paused sandboxes are automatically resumed. The shutdown policy applies
+ *   on exit.
  * - `"fork"` — fork from an existing (or paused) sandbox; a new sandbox is
  *   created and owned by this session.
  * - `"inherit"` — use a sandbox owned by someone else (e.g. a parent agent).
@@ -56,7 +57,10 @@ export type SandboxShutdown = "destroy" | "pause" | "keep";
  * Includes all base {@link SandboxShutdown} values plus:
  * - `"pause-until-parent-close"` — pause the sandbox on exit, then wait for
  *   the parent workflow to signal when to destroy it.
+ * - `"keep-until-parent-close"` — leave the sandbox running on exit, then
+ *   wait for the parent workflow to signal when to destroy it.
  */
 export type SubagentSandboxShutdown =
   | SandboxShutdown
-  | "pause-until-parent-close";
+  | "pause-until-parent-close"
+  | "keep-until-parent-close";

package/src/lib/sandbox/manager.ts

@@ -166,6 +166,10 @@ export class SandboxManager<
     await this.provider.pause(id, ttlSeconds);
   }
 
+  async resume(id: string): Promise<void> {
+    await this.provider.resume(id);
+  }
+
   async snapshot(id: string): Promise<SandboxSnapshot> {
     return this.provider.snapshot(id);
   }
@@ -222,6 +226,9 @@ export class SandboxManager<
       ): Promise<void> => {
         await this.pause(sandboxId, ttlSeconds);
       },
+      resumeSandbox: async (sandboxId: string): Promise<void> => {
+        await this.resume(sandboxId);
+      },
       snapshotSandbox: async (sandboxId: string): Promise<SandboxSnapshot> => {
         return this.snapshot(sandboxId);
       },

package/src/lib/sandbox/types.ts

@@ -131,6 +131,8 @@ export interface SandboxProvider<
   get(sandboxId: string): Promise<TSandbox>;
   destroy(sandboxId: string): Promise<void>;
   pause(sandboxId: string, ttlSeconds?: number): Promise<void>;
+  /** Resume a paused sandbox. No-op if already running. */
+  resume(sandboxId: string): Promise<void>;
   snapshot(sandboxId: string): Promise<SandboxSnapshot>;
   restore(snapshot: SandboxSnapshot): Promise<Sandbox>;
   fork(sandboxId: string): Promise<Sandbox>;
@@ -150,6 +152,8 @@ export interface SandboxOps<
   ): Promise<{ sandboxId: string } | null>;
   destroySandbox(sandboxId: string): Promise<void>;
   pauseSandbox(sandboxId: string): Promise<void>;
+  /** Resume a paused sandbox. No-op if already running. */
+  resumeSandbox(sandboxId: string): Promise<void>;
   snapshotSandbox(sandboxId: string): Promise<SandboxSnapshot>;
   forkSandbox(sandboxId: string): Promise<string>;
 }

package/src/lib/session/session-edge-cases.integration.test.ts

@@ -434,6 +434,7 @@ describe("createSession edge cases", () => {
       }),
       forkSandbox: async () => "forked-sandbox-id",
       pauseSandbox: async () => {},
+      resumeSandbox: async () => {},
     };
 
     const session = await createSession({
@@ -476,6 +477,7 @@ describe("createSession edge cases", () => {
       }),
       forkSandbox: async () => "forked-sandbox-id",
       pauseSandbox: async () => {},
+      resumeSandbox: async () => {},
     };
 
     const session = await createSession({
@@ -939,6 +941,7 @@ describe("createSession edge cases", () => {
       snapshotSandbox: snapshotSpy,
       forkSandbox: async () => "forked-sandbox-id",
       pauseSandbox: async () => {},
+      resumeSandbox: async () => {},
     };
 
     const session = await createSession({
@@ -1029,6 +1032,7 @@ describe("createSession edge cases", () => {
       createSandbox: async () => ({ sandboxId: "sb-created" }),
       destroySandbox: async () => {},
       pauseSandbox: async () => {},
+      resumeSandbox: async () => {},
       snapshotSandbox: async () => ({
         sandboxId: "sb-1",
         providerId: "test",
@@ -1062,6 +1066,7 @@ describe("createSession edge cases", () => {
       createSandbox: async () => ({ sandboxId: "sb" }),
       destroySandbox: async () => {},
       pauseSandbox: async () => {},
+      resumeSandbox: async () => {},
       snapshotSandbox: async () => ({
         sandboxId: "sb",
         providerId: "test",
@@ -1106,6 +1111,7 @@ describe("createSession edge cases", () => {
       pauseSandbox: async (id: string) => {
         sandboxLog.push(`pause:${id}`);
       },
+      resumeSandbox: async () => {},
       snapshotSandbox: async () => ({
         sandboxId: "sb-1",
         providerId: "test",
@@ -1149,6 +1155,7 @@ describe("createSession edge cases", () => {
         sandboxLog.push(`destroy:${id}`);
       },
       pauseSandbox: async () => {},
+      resumeSandbox: async () => {},
       snapshotSandbox: async () => ({
         sandboxId: "sb-1",
         providerId: "test",
@@ -1195,6 +1202,7 @@ describe("createSession edge cases", () => {
         sandboxLog.push(`destroy:${id}`);
       },
       pauseSandbox: async () => {},
+      resumeSandbox: async () => {},
       snapshotSandbox: async () => ({
         sandboxId: "sb-1",
         providerId: "test",
@@ -1237,6 +1245,7 @@ describe("createSession edge cases", () => {
       pauseSandbox: async (id: string) => {
         sandboxLog.push(`pause:${id}`);
       },
+      resumeSandbox: async () => {},
       snapshotSandbox: async () => ({
         sandboxId: "sb-1",
         providerId: "test",
@@ -1280,6 +1289,7 @@ describe("createSession edge cases", () => {
       pauseSandbox: async (id: string) => {
         sandboxLog.push(`pause:${id}`);
       },
+      resumeSandbox: async () => {},
       snapshotSandbox: async () => ({
         sandboxId: "sb-1",
         providerId: "test",
@@ -1395,6 +1405,7 @@ describe("createSession edge cases", () => {
       pauseSandbox: async (id: string) => {
         sandboxLog.push(`pause:${id}`);
       },
+      resumeSandbox: async () => {},
       snapshotSandbox: async () => ({
         sandboxId: "sb-1",
         providerId: "test",
@@ -1427,4 +1438,187 @@ describe("createSession edge cases", () => {
     expect(sandboxLog).toContain("pause:sb-err");
     expect(sandboxLog).not.toContain("destroy:sb-err");
   });
+
+  // --- sandboxShutdown: "keep-until-parent-close" ---
+
+  it("keeps sandbox running on exit when sandboxShutdown is keep-until-parent-close", async () => {
+    const { ops } = createMockThreadOps();
+    const sandboxLog: string[] = [];
+
+    const sandboxOps: SandboxOps = {
+      createSandbox: async () => ({ sandboxId: "sb-keep-parent" }),
+      destroySandbox: async (id: string) => {
+        sandboxLog.push(`destroy:${id}`);
+      },
+      pauseSandbox: async (id: string) => {
+        sandboxLog.push(`pause:${id}`);
+      },
+      resumeSandbox: async () => {},
+      snapshotSandbox: async () => ({
+        sandboxId: "sb-1",
+        providerId: "test",
+        data: null,
+        createdAt: new Date().toISOString(),
+      }),
+      forkSandbox: async () => "forked-sb",
+    };
+
+    const session = await createSession({
+      agentName: "TestAgent",
+      thread: { mode: "new", threadId: "thread-1" },
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
+      threadOps: ops,
+      buildContextMessage: () => "go",
+      sandboxOps,
+      sandboxShutdown: "keep-until-parent-close",
+    });
+
+    const stateManager = createAgentStateManager({
+      initialState: { systemPrompt: "test" },
+    });
+
+    await session.runSession({ stateManager });
+
+    expect(sandboxLog).not.toContain("pause:sb-keep-parent");
+    expect(sandboxLog).not.toContain("destroy:sb-keep-parent");
+  });
+
+  it("keeps sandbox running on error when sandboxShutdown is keep-until-parent-close", async () => {
+    const { ops } = createMockThreadOps();
+    const sandboxLog: string[] = [];
+
+    const sandboxOps: SandboxOps = {
+      createSandbox: async () => ({ sandboxId: "sb-keep-err" }),
+      destroySandbox: async (id: string) => {
+        sandboxLog.push(`destroy:${id}`);
+      },
+      pauseSandbox: async (id: string) => {
+        sandboxLog.push(`pause:${id}`);
+      },
+      resumeSandbox: async () => {},
+      snapshotSandbox: async () => ({
+        sandboxId: "sb-1",
+        providerId: "test",
+        data: null,
+        createdAt: new Date().toISOString(),
+      }),
+      forkSandbox: async () => "forked-sb",
+    };
+
+    const session = await createSession({
+      agentName: "TestAgent",
+      thread: { mode: "new", threadId: "thread-1" },
+      runAgent: async () => {
+        throw new Error("crash");
+      },
+      threadOps: ops,
+      buildContextMessage: () => "go",
+      sandboxOps,
+      sandboxShutdown: "keep-until-parent-close",
+    });
+
+    const stateManager = createAgentStateManager({
+      initialState: { systemPrompt: "test" },
+    });
+
+    await expect(session.runSession({ stateManager })).rejects.toThrow(
+      "crash"
+    );
+
+    expect(sandboxLog).not.toContain("pause:sb-keep-err");
+    expect(sandboxLog).not.toContain("destroy:sb-keep-err");
+  });
+
+  // --- sandbox continue calls resumeSandbox only for pause-until-parent-close ---
+
+  it("calls resumeSandbox when sandbox mode is continue with pause-until-parent-close", async () => {
+    const { ops } = createMockThreadOps();
+    const sandboxLog: string[] = [];
+
+    const sandboxOps: SandboxOps = {
+      createSandbox: async () => ({ sandboxId: "new-sb" }),
+      destroySandbox: async (id: string) => {
+        sandboxLog.push(`destroy:${id}`);
+      },
+      pauseSandbox: async (id: string) => {
+        sandboxLog.push(`pause:${id}`);
+      },
+      resumeSandbox: async (id: string) => {
+        sandboxLog.push(`resume:${id}`);
+      },
+      snapshotSandbox: async () => ({
+        sandboxId: "sb-1",
+        providerId: "test",
+        data: null,
+        createdAt: new Date().toISOString(),
+      }),
+      forkSandbox: async () => "forked-sb",
+    };
+
+    const session = await createSession({
+      agentName: "TestAgent",
+      thread: { mode: "new", threadId: "thread-1" },
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
+      threadOps: ops,
+      buildContextMessage: () => "go",
+      sandboxOps,
+      sandbox: { mode: "continue", sandboxId: "paused-sb" },
+      sandboxShutdown: "pause-until-parent-close",
+    });
+
+    const stateManager = createAgentStateManager({
+      initialState: { systemPrompt: "test" },
+    });
+
+    await session.runSession({ stateManager });
+
+    expect(sandboxLog).toContain("resume:paused-sb");
+    expect(sandboxLog).toContain("pause:paused-sb");
+  });
+
+  it("skips resumeSandbox when sandbox mode is continue with keep-until-parent-close", async () => {
+    const { ops } = createMockThreadOps();
+    const sandboxLog: string[] = [];
+
+    const sandboxOps: SandboxOps = {
+      createSandbox: async () => ({ sandboxId: "new-sb" }),
+      destroySandbox: async (id: string) => {
+        sandboxLog.push(`destroy:${id}`);
+      },
+      pauseSandbox: async (id: string) => {
+        sandboxLog.push(`pause:${id}`);
+      },
+      resumeSandbox: async (id: string) => {
+        sandboxLog.push(`resume:${id}`);
+      },
+      snapshotSandbox: async () => ({
+        sandboxId: "sb-1",
+        providerId: "test",
+        data: null,
+        createdAt: new Date().toISOString(),
+      }),
+      forkSandbox: async () => "forked-sb",
+    };
+
+    const session = await createSession({
+      agentName: "TestAgent",
+      thread: { mode: "new", threadId: "thread-1" },
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
+      threadOps: ops,
+      buildContextMessage: () => "go",
+      sandboxOps,
+      sandbox: { mode: "continue", sandboxId: "kept-sb" },
+      sandboxShutdown: "keep-until-parent-close",
+    });
+
+    const stateManager = createAgentStateManager({
+      initialState: { systemPrompt: "test" },
+    });
+
+    await session.runSession({ stateManager });
+
+    expect(sandboxLog).not.toContain("resume:kept-sb");
+    expect(sandboxLog).not.toContain("pause:kept-sb");
+    expect(sandboxLog).not.toContain("destroy:kept-sb");
+  });
 });