zeitlich 0.2.36 → 0.2.38

package/dist/index.cjs

@@ -117,7 +117,7 @@ function createToolRouter(options) {
       });
     }
   }
-  async function processToolCall(toolCall, turn, sandboxId) {
+  async function processToolCall(toolCall, turn, sandboxId, onRewindRequested) {
     const startTime = Date.now();
     const tool = toolMap.get(toolCall.name);
     const preResult = await runPreHooks(toolCall, tool, turn);
@@ -132,7 +132,7 @@ function createToolRouter(options) {
           reason: "Skipped by PreToolUse hook"
         })
       });
-      return null;
+      return { kind: "skipped" };
     }
     const effectiveArgs = preResult.args;
     workflow.log.debug("tool call dispatched", {
@@ -144,6 +144,7 @@ function createToolRouter(options) {
     let content;
     let resultAppended = false;
     let metadata;
+    let rewindRequested = false;
     try {
       if (tool) {
         const routerContext = {
@@ -161,11 +162,15 @@ function createToolRouter(options) {
         content = response.toolResponse;
         resultAppended = response.resultAppended === true;
         metadata = response.metadata;
+        rewindRequested = response.rewind === true;
       } else {
         result = { error: `Unknown tool: ${toolCall.name}` };
         content = JSON.stringify(result, null, 2);
       }
     } catch (error) {
+      if (workflow.isCancellation(error)) {
+        throw error;
+      }
       workflow.log.warn("tool call failed", {
         toolName: toolCall.name,
         toolCallId: toolCall.id,
@@ -183,6 +188,15 @@ function createToolRouter(options) {
       result = recovery.result;
       content = recovery.content;
     }
+    if (rewindRequested) {
+      const signal = {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name
+      };
+      workflow.log.info("tool requested rewind", { ...signal });
+      onRewindRequested?.(signal);
+      return { kind: "rewind", signal };
+    }
     if (!resultAppended) {
       const config = {
         threadId: options.threadId,
@@ -219,7 +233,7 @@ function createToolRouter(options) {
       turn,
       durationMs
     );
-    return toolResult;
+    return { kind: "result", value: toolResult };
   }
   return {
     hasTools() {
@@ -254,27 +268,59 @@ function createToolRouter(options) {
       }));
     },
     async processToolCalls(toolCalls, context) {
+      const attachRewind = (arr, rewind) => {
+        if (rewind) {
+          arr.rewind = rewind;
+        }
+        return arr;
+      };
       if (toolCalls.length === 0) {
-        return [];
+        return attachRewind([], void 0);
       }
       const turn = context?.turn ?? 0;
       const sandboxId = context?.sandboxId;
+      let rewindSignal;
       if (options.parallel) {
-        const results2 = await Promise.all(
-          toolCalls.map((tc) => processToolCall(tc, turn, sandboxId))
-        );
-        return results2.filter(
-          (r) => r !== null
+        const scope = new workflow.CancellationScope({ cancellable: true });
+        const onRewindRequested = (signal) => {
+          if (!rewindSignal) {
+            rewindSignal = signal;
+            scope.cancel();
+          }
+        };
+        const outcomes = await scope.run(
+          async () => Promise.allSettled(
+            toolCalls.map(
+              (tc) => processToolCall(tc, turn, sandboxId, onRewindRequested)
+            )
+          )
         );
+        const results2 = [];
+        for (const outcome of outcomes) {
+          if (outcome.status === "rejected") {
+            if (workflow.isCancellation(outcome.reason)) {
+              continue;
+            }
+            throw outcome.reason;
+          }
+          if (outcome.value.kind === "result") {
+            results2.push(outcome.value.value);
+          }
+        }
+        return attachRewind(results2, rewindSignal);
       }
       const results = [];
       for (const toolCall of toolCalls) {
-        const result = await processToolCall(toolCall, turn, sandboxId);
-        if (result !== null) {
-          results.push(result);
+        const outcome = await processToolCall(toolCall, turn, sandboxId);
+        if (outcome.kind === "rewind") {
+          rewindSignal = outcome.signal;
+          break;
+        }
+        if (outcome.kind === "result") {
+          results.push(outcome.value);
         }
       }
-      return results;
+      return attachRewind(results, rewindSignal);
     },
     async processToolCallsByName(toolCalls, toolName, handler, context) {
       const matchingCalls = toolCalls.filter((tc) => tc.name === toolName);
@@ -395,9 +441,7 @@ function createSubagentTool(subagents) {
     schema
   };
 }
-var childResultSignal = workflow.defineSignal("childResult");
 var childSandboxReadySignal = workflow.defineSignal("childSandboxReady");
-var destroySandboxSignal = workflow.defineSignal("destroySandbox");
 
 // src/lib/subagent/handler.ts
 function resolveSandboxConfig(config) {
@@ -421,25 +465,27 @@ function resolveSandboxConfig(config) {
 }
 function createSubagentHandler(subagents) {
   const { taskQueue: parentTaskQueue } = workflow.workflowInfo();
-  const childResults = /* @__PURE__ */ new Map();
+  const agentSandboxOps = /* @__PURE__ */ new Map();
+  for (const cfg of subagents) {
+    if (cfg.sandbox && cfg.sandbox !== "none") {
+      agentSandboxOps.set(cfg.agentName, cfg.sandbox.proxy(cfg.agentName));
+    }
+  }
   const pendingDestroys = /* @__PURE__ */ new Map();
   const threadSandboxes = /* @__PURE__ */ new Map();
   const persistentSandboxes = /* @__PURE__ */ new Map();
   const persistentSandboxCreating = /* @__PURE__ */ new Set();
   const lazyCreatorAgent = /* @__PURE__ */ new Map();
-  workflow.setHandler(childResultSignal, ({ childWorkflowId, result }) => {
-    childResults.set(childWorkflowId, result);
-  });
-  workflow.setHandler(
-    childSandboxReadySignal,
-    ({ childWorkflowId, sandboxId }) => {
-      const agentName = lazyCreatorAgent.get(childWorkflowId);
-      if (agentName && !persistentSandboxes.has(agentName)) {
-        persistentSandboxes.set(agentName, sandboxId);
-        lazyCreatorAgent.delete(childWorkflowId);
-      }
+  const threadSnapshots = /* @__PURE__ */ new Map();
+  const persistentBaseSnapshot = /* @__PURE__ */ new Map();
+  const persistentBaseSnapshotCreating = /* @__PURE__ */ new Set();
+  workflow.setHandler(childSandboxReadySignal, ({ childWorkflowId, sandboxId }) => {
+    const agentName = lazyCreatorAgent.get(childWorkflowId);
+    if (agentName && !persistentSandboxes.has(agentName)) {
+      persistentSandboxes.set(agentName, sandboxId);
+      lazyCreatorAgent.delete(childWorkflowId);
     }
-  );
+  });
   const handler = async (args, context) => {
     const config = subagents.find((s) => s.agentName === args.subagent);
     if (!config) {
@@ -450,6 +496,12 @@ function createSubagentHandler(subagents) {
     const childWorkflowId = `${args.subagent}-${getShortId()}`;
     const { sandboxId: parentSandboxId } = context;
     const sandboxCfg = resolveSandboxConfig(config.sandbox);
+    if (sandboxCfg.source !== "none" && !agentSandboxOps.has(config.agentName)) {
+      throw workflow.ApplicationFailure.create({
+        message: `Subagent "${config.agentName}" uses a sandbox but no \`sandbox.proxy\` is configured on its SubagentConfig`,
+        nonRetryable: true
+      });
+    }
     if (sandboxCfg.source === "inherit" && !parentSandboxId) {
       throw new Error(
         `Subagent "${config.agentName}" is configured with sandbox: "inherit" but the parent has no sandbox`
@@ -468,12 +520,39 @@ function createSubagentHandler(subagents) {
     let sandbox;
     let sandboxShutdownOverride;
     let isLazyCreator = false;
+    let isSnapshotBaseCreator = false;
     if (sandboxCfg.source === "inherit" && parentSandboxId) {
       if (sandboxCfg.continuation === "fork") {
         sandbox = { mode: "fork", sandboxId: parentSandboxId };
+      } else if (sandboxCfg.continuation === "snapshot") {
+        throw new Error(
+          `Subagent "${config.agentName}" has sandbox source "inherit" with continuation "snapshot" \u2014 snapshot continuation is only supported for source "own"`
+        );
       } else {
         sandbox = { mode: "inherit", sandboxId: parentSandboxId };
       }
+    } else if (sandboxCfg.source === "own" && sandboxCfg.continuation === "snapshot") {
+      const isLazy = sandboxCfg.init === "once";
+      let baseSnap;
+      if (continuationThreadId) {
+        baseSnap = threadSnapshots.get(continuationThreadId)?.snapshot;
+      }
+      if (!baseSnap && isLazy) {
+        baseSnap = persistentBaseSnapshot.get(config.agentName);
+        if (!baseSnap) {
+          if (persistentBaseSnapshotCreating.has(config.agentName)) {
+            await workflow.condition(() => persistentBaseSnapshot.has(config.agentName));
+            baseSnap = persistentBaseSnapshot.get(config.agentName);
+          } else {
+            persistentBaseSnapshotCreating.add(config.agentName);
+            isSnapshotBaseCreator = true;
+          }
+        }
+      }
+      if (baseSnap) {
+        sandbox = { mode: "from-snapshot", snapshot: baseSnap };
+      }
+      sandboxShutdownOverride = "snapshot";
     } else if (sandboxCfg.source === "own") {
       const isLazy = sandboxCfg.init === "once";
       let baseSandboxId;
@@ -524,31 +603,8 @@ function createSubagentHandler(subagents) {
       threadMode,
       sandboxSource: sandboxCfg.source
     });
-    const childHandle = await workflow.startChild(config.workflow, childOpts);
+    const childResult = await workflow.executeChild(config.workflow, childOpts);
     const effectiveShutdown = sandboxShutdownOverride ?? sandboxCfg.shutdown ?? "destroy";
-    if (effectiveShutdown === "pause-until-parent-close" || effectiveShutdown === "keep-until-parent-close") {
-      const key = isLazyCreator ? `persistent:${config.agentName}` : childWorkflowId;
-      pendingDestroys.set(key, childHandle);
-    }
-    await Promise.race([
-      workflow.condition(() => childResults.has(childWorkflowId)),
-      childHandle.result()
-    ]);
-    if (!childResults.has(childWorkflowId)) {
-      await workflow.condition(() => childResults.has(childWorkflowId));
-    }
-    const childResult = childResults.get(childWorkflowId);
-    childResults.delete(childWorkflowId);
-    if (!childResult) {
-      workflow.log.warn("subagent returned no result", {
-        subagent: config.agentName,
-        childWorkflowId
-      });
-      return {
-        toolResponse: "Subagent workflow did not signal a result",
-        data: null
-      };
-    }
     workflow.log.info("subagent completed", {
       subagent: config.agentName,
       childWorkflowId,
@@ -560,19 +616,42 @@ function createSubagentHandler(subagents) {
       usage,
       threadId: childThreadId,
       sandboxId: childSandboxId,
+      snapshot: childSnapshot,
+      baseSnapshot: childBaseSnapshot,
       metadata
     } = childResult;
     if (childSandboxId) {
-      if (sandboxCfg.source === "own" && sandboxCfg.init === "once" && !persistentSandboxes.has(config.agentName)) {
+      if (sandboxCfg.source === "own" && sandboxCfg.init === "once" && sandboxCfg.continuation !== "snapshot" && !persistentSandboxes.has(config.agentName)) {
         persistentSandboxes.set(config.agentName, childSandboxId);
-      } else if (allowsContinuation && childThreadId) {
+      } else if (allowsContinuation && childThreadId && sandboxCfg.source === "own" && sandboxCfg.continuation !== "snapshot") {
         threadSandboxes.set(childThreadId, childSandboxId);
       }
     }
+    if (childSandboxId && (effectiveShutdown === "pause-until-parent-close" || effectiveShutdown === "keep-until-parent-close")) {
+      const key = isLazyCreator ? `persistent:${config.agentName}` : childWorkflowId;
+      pendingDestroys.set(key, {
+        agentName: config.agentName,
+        sandboxId: childSandboxId
+      });
+    }
+    if (sandboxCfg.source === "own" && sandboxCfg.continuation === "snapshot") {
+      if (childSnapshot && childThreadId) {
+        threadSnapshots.set(childThreadId, {
+          agentName: config.agentName,
+          snapshot: childSnapshot
+        });
+      }
+      if (isSnapshotBaseCreator && childBaseSnapshot && !persistentBaseSnapshot.has(config.agentName)) {
+        persistentBaseSnapshot.set(config.agentName, childBaseSnapshot);
+      }
+    }
     if (isLazyCreator) {
       persistentSandboxCreating.delete(config.agentName);
       lazyCreatorAgent.delete(childWorkflowId);
     }
+    if (isSnapshotBaseCreator) {
+      persistentBaseSnapshotCreating.delete(config.agentName);
+    }
     if (!toolResponse) {
       return {
         toolResponse: "Subagent workflow returned no response",
@@ -608,22 +687,60 @@ function createSubagentHandler(subagents) {
     };
   };
   const destroySubagentSandboxes = async () => {
-    const handles = [...pendingDestroys.values()];
+    const entries = [...pendingDestroys.values()];
     pendingDestroys.clear();
     await Promise.all(
-      handles.map(async (handle) => {
+      entries.map(async ({ agentName, sandboxId }) => {
+        const ops = agentSandboxOps.get(agentName);
+        if (!ops) {
+          workflow.log.warn(
+            "Skipping sandbox destroy \u2014 no sandbox.proxy registered for agent",
+            { agentName, sandboxId }
+          );
+          return;
+        }
+        try {
+          await ops.destroySandbox(sandboxId);
+        } catch (err) {
+          workflow.log.warn("Failed to destroy subagent sandbox", {
+            agentName,
+            sandboxId,
+            error: err
+          });
+        }
+      })
+    );
+  };
+  const cleanupSubagentSnapshots = async () => {
+    const tagged = [];
+    for (const entry of threadSnapshots.values()) tagged.push(entry);
+    for (const [agentName, snapshot] of persistentBaseSnapshot.entries()) {
+      tagged.push({ agentName, snapshot });
+    }
+    threadSnapshots.clear();
+    persistentBaseSnapshot.clear();
+    await Promise.all(
+      tagged.map(async ({ agentName, snapshot }) => {
+        const ops = agentSandboxOps.get(agentName);
+        if (!ops) {
+          workflow.log.warn(
+            "Skipping snapshot delete \u2014 no sandbox.proxy registered for agent",
+            { agentName }
+          );
+          return;
+        }
         try {
-          await handle.signal(destroySandboxSignal);
-          await handle.result();
+          await ops.deleteSandboxSnapshot(snapshot);
         } catch (err) {
-          workflow.log.warn("Failed to signal destroySandbox to child workflow", {
+          workflow.log.warn("Failed to delete subagent snapshot", {
+            agentName,
             error: err
           });
         }
       })
     );
   };
-  return { handler, destroySubagentSandboxes };
+  return { handler, destroySubagentSandboxes, cleanupSubagentSnapshots };
 }
 
 // src/lib/subagent/register.ts
@@ -637,7 +754,7 @@ function buildSubagentRegistration(subagents) {
     if (s.hooks) subagentHooksMap.set(s.agentName, s.hooks);
   }
   const resolveSubagentName = (args) => args.subagent;
-  const { handler, destroySubagentSandboxes } = createSubagentHandler(subagents);
+  const { handler, destroySubagentSandboxes, cleanupSubagentSnapshots } = createSubagentHandler(subagents);
   const registration = {
     name: SUBAGENT_TOOL_NAME,
     enabled: () => getEnabled().length > 0,
@@ -661,7 +778,7 @@ function buildSubagentRegistration(subagents) {
       }
     }
   };
-  return { registration, destroySubagentSandboxes };
+  return { registration, destroySubagentSandboxes, cleanupSubagentSnapshots };
 }
 var READ_SKILL_TOOL_NAME = "ReadSkill";
 function buildReadSkillDescription(skills) {
@@ -734,9 +851,7 @@ function validateSkillNames(skills) {
   const names = skills.map((s) => s.name);
   const dupes = names.filter((n, i) => names.indexOf(n) !== i);
   if (dupes.length > 0) {
-    throw new Error(
-      `Duplicate skill names: ${[...new Set(dupes)].join(", ")}`
-    );
+    throw new Error(`Duplicate skill names: ${[...new Set(dupes)].join(", ")}`);
   }
 }
 function buildSkillRegistration(skills) {
@@ -802,15 +917,18 @@ async function createSession({
     initializeThread,
     appendSystemMessage,
     appendAgentMessage,
-    forkThread
+    forkThread,
+    truncateThread
   } = threadOps;
   const plugins = [];
   let destroySubagentSandboxes;
+  let cleanupSubagentSnapshots;
   if (subagents) {
     const result = buildSubagentRegistration(subagents);
     if (result) {
       plugins.push(result.registration);
       destroySubagentSandboxes = result.destroySubagentSandboxes;
+      cleanupSubagentSnapshots = result.cleanupSubagentSnapshots;
     }
   }
   if (skills) {
@@ -863,6 +981,9 @@ async function createSession({
       const sandboxMode = sandboxInit?.mode;
       let sandboxId;
       let sandboxOwned = false;
+      let baseSnapshot;
+      let exitSnapshot;
+      let freshlyCreated = false;
       if (sandboxMode === "inherit") {
         const inheritInit = sandboxInit;
         sandboxId = inheritInit.sandboxId;
@@ -891,8 +1012,23 @@ async function createSession({
             nonRetryable: true
           });
         }
+        const forkInit = sandboxInit;
         sandboxId = await sandboxOps.forkSandbox(
-          sandboxInit.sandboxId
+          forkInit.sandboxId,
+          forkInit.options
+        );
+        sandboxOwned = true;
+      } else if (sandboxMode === "from-snapshot") {
+        if (!sandboxOps) {
+          throw workflow.ApplicationFailure.create({
+            message: "No sandboxOps provided \u2014 cannot restore sandbox",
+            nonRetryable: true
+          });
+        }
+        const restoreInit = sandboxInit;
+        sandboxId = await sandboxOps.restoreSandbox(
+          restoreInit.snapshot,
+          restoreInit.options
         );
         sandboxOwned = true;
       } else if (sandboxOps) {
@@ -903,9 +1039,13 @@ async function createSession({
         if (result) {
           sandboxId = result.sandboxId;
           sandboxOwned = true;
+          freshlyCreated = true;
         }
       }
-      if (sandboxId && onSandboxReady) {
+      if (sandboxId && sandboxOwned && freshlyCreated && sandboxShutdown === "snapshot" && sandboxOps) {
+        baseSnapshot = await sandboxOps.snapshotSandbox(sandboxId);
+      }
+      if (sandboxId && sandboxOwned && onSandboxReady) {
         onSandboxReady(sandboxId);
       }
       if (virtualFsConfig) {
@@ -971,18 +1111,25 @@ async function createSession({
         threadKey
       );
       let exitReason = "completed";
+      let finalMessage = null;
       try {
         while (stateManager.isRunning() && !stateManager.isTerminal() && stateManager.getTurns() < maxTurns) {
           stateManager.incrementTurns();
           const currentTurn = stateManager.getTurns();
           workflow.log.debug("turn started", { agentName, threadId, turn: currentTurn });
           stateManager.setTools(toolRouter.getToolDefinitions());
-          const { message, rawToolCalls, usage } = await runAgent({
+          const {
+            message,
+            rawToolCalls,
+            usage,
+            threadLengthAtCall
+          } = await runAgent({
             threadId,
             threadKey,
             agentName,
             metadata
           });
+          const preAssistantLength = threadLengthAtCall;
           await appendAgentMessage(threadId, workflow.uuid4(), message, threadKey);
           if (usage) {
             stateManager.updateUsage(usage);
@@ -997,21 +1144,8 @@ async function createSession({
           if (!toolRouter.hasTools() || rawToolCalls.length === 0) {
             stateManager.complete();
             exitReason = "completed";
-            workflow.log.info("session ended", {
-              agentName,
-              threadId,
-              exitReason,
-              turns: currentTurn,
-              durationMs: Date.now() - sessionStartMs,
-              usage: stateManager.getTotalUsage()
-            });
-            return {
-              threadId,
-              finalMessage: message,
-              exitReason,
-              usage: stateManager.getTotalUsage(),
-              sandboxId
-            };
+            finalMessage = message;
+            break;
           }
           const parsedToolCalls = [];
           for (const tc of rawToolCalls) {
@@ -1041,6 +1175,24 @@ async function createSession({
               stateManager.updateUsage(result.usage);
             }
           }
+          const rewind = toolCallResults.rewind;
+          if (rewind) {
+            workflow.log.info("rewinding turn", {
+              agentName,
+              threadId,
+              turn: currentTurn,
+              toolCallId: rewind.toolCallId,
+              toolName: rewind.toolName
+            });
+            if (preAssistantLength === void 0) {
+              throw workflow.ApplicationFailure.create({
+                message: "Rewind requested but runAgent did not report `threadLengthAtCall`; the adapter must populate it to support rewinds.",
+                nonRetryable: true
+              });
+            }
+            await truncateThread(threadId, preAssistantLength, threadKey);
+            continue;
+          }
           if (stateManager.getStatus() === "WAITING_FOR_INPUT") {
             const conditionMet = await workflow.condition(
               () => stateManager.getStatus() === "RUNNING",
@@ -1083,11 +1235,21 @@ async function createSession({
             case "pause-until-parent-close":
               await sandboxOps.pauseSandbox(sandboxId);
               break;
+            case "keep":
+            case "keep-until-parent-close":
+              break;
+            case "snapshot":
+              exitSnapshot = await sandboxOps.snapshotSandbox(sandboxId);
+              await sandboxOps.destroySandbox(sandboxId);
+              break;
           }
         }
         if (destroySubagentSandboxes) {
           await destroySubagentSandboxes();
         }
+        if (cleanupSubagentSnapshots) {
+          await cleanupSubagentSnapshots();
+        }
       }
       workflow.log.info("session ended", {
         agentName,
@@ -1095,14 +1257,18 @@ async function createSession({
         exitReason,
         turns: stateManager.getTurns(),
         durationMs: Date.now() - sessionStartMs,
-        usage: stateManager.getTotalUsage()
+        usage: stateManager.getTotalUsage(),
+        ...baseSnapshot && { hasBaseSnapshot: true },
+        ...exitSnapshot && { hasExitSnapshot: true }
       });
       return {
         threadId,
-        finalMessage: null,
+        finalMessage,
         exitReason,
         usage: stateManager.getTotalUsage(),
-        sandboxId
+        sandboxId,
+        ...baseSnapshot && { baseSnapshot },
+        ...exitSnapshot && { snapshot: exitSnapshot }
       };
     }
   };
@@ -1391,44 +1557,16 @@ function defineSubagentWorkflow(config, fn) {
       ...workflowInput.thread && { thread: workflowInput.thread },
       ...workflowInput.sandbox && { sandbox: workflowInput.sandbox },
       onSandboxReady: (sandboxId) => {
-        void parentHandle.signal(childSandboxReadySignal, {
-          childWorkflowId: workflow.workflowInfo().workflowId,
-          sandboxId
-        });
+        const isReuse = workflowInput.sandbox?.mode === "continue";
+        if (!isReuse) {
+          void parentHandle.signal(childSandboxReadySignal, {
+            childWorkflowId: workflow.workflowInfo().workflowId,
+            sandboxId
+          });
+        }
       }
     };
-    const { destroySandbox, ...result } = await fn(
-      prompt,
-      sessionInput,
-      context ?? {}
-    );
-    if (effectiveShutdown === "pause-until-parent-close" || effectiveShutdown === "keep-until-parent-close") {
-      if (!destroySandbox) {
-        throw workflow.ApplicationFailure.create({
-          message: `Subagent "${config.name}" has sandboxShutdown="${effectiveShutdown}" but fn did not return a destroySandbox callback`,
-          nonRetryable: true
-        });
-      }
-      if (!result.sandboxId) {
-        throw workflow.ApplicationFailure.create({
-          message: `Subagent "${config.name}" has sandboxShutdown="${effectiveShutdown}" but fn did not return a sandboxId`,
-          nonRetryable: true
-        });
-      }
-    }
-    await parentHandle.signal(childResultSignal, {
-      childWorkflowId: workflow.workflowInfo().workflowId,
-      result
-    });
-    if (destroySandbox) {
-      let destroyRequested = false;
-      workflow.setHandler(destroySandboxSignal, () => {
-        destroyRequested = true;
-      });
-      await workflow.condition(() => destroyRequested);
-      await destroySandbox();
-    }
-    return result;
+    return fn(prompt, sessionInput, context ?? {});
   };
   Object.defineProperty(workflow$1, "name", { value: config.name });
   return Object.assign(workflow$1, {
@@ -1538,9 +1676,7 @@ function applyVirtualTreeMutations(stateManager, mutations) {
         tree = tree.filter((e) => e.path !== m.path);
         break;
       case "update":
-        tree = tree.map(
-          (e) => e.path === m.path ? { ...e, ...m.entry } : e
-        );
+        tree = tree.map((e) => e.path === m.path ? { ...e, ...m.entry } : e);
         break;
     }
   }
@@ -1599,7 +1735,9 @@ function formatVirtualFileTree(entries, opts = {}) {
 // src/lib/virtual-fs/queries.ts
 function hasFileWithMimeType(stateManager, pattern) {
   const tree = stateManager.get("fileTree");
-  const matchers = (Array.isArray(pattern) ? pattern : [pattern]).map(buildMatcher);
+  const matchers = (Array.isArray(pattern) ? pattern : [pattern]).map(
+    buildMatcher
+  );
   return tree.some((entry) => {
     const meta = entry.metadata;
     const mime = meta?.mimeType;
@@ -1660,7 +1798,9 @@ function proxyVirtualFsOps(scope, options) {
 // src/lib/skills/parse.ts
 function parseSkillFile(raw) {
   const trimmed = raw.replace(/^\uFEFF/, "");
-  const match = trimmed.match(/^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*\r?\n?([\s\S]*)$/);
+  const match = trimmed.match(
+    /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*\r?\n?([\s\S]*)$/
+  );
   if (!match) {
     throw new Error(
       "SKILL.md must start with YAML frontmatter delimited by ---"
@@ -1932,7 +2072,9 @@ function createTaskGetHandler(stateManager) {
     const task = stateManager.getTask(args.taskId) ?? null;
     if (!task) {
       return {
-        toolResponse: JSON.stringify({ error: `Task not found: ${args.taskId}` }),
+        toolResponse: JSON.stringify({
+          error: `Task not found: ${args.taskId}`
+        }),
         data: null
       };
     }
@@ -1975,7 +2117,9 @@ function createTaskUpdateHandler(stateManager) {
     const task = stateManager.getTask(args.taskId);
     if (!task) {
       return {
-        toolResponse: JSON.stringify({ error: `Task not found: ${args.taskId}` }),
+        toolResponse: JSON.stringify({
+          error: `Task not found: ${args.taskId}`
+        }),
         data: null
       };
     }
@@ -2085,6 +2229,8 @@ var FileSystemSkillProvider = class {
     this.fs = fs;
     this.baseDir = baseDir;
   }
+  fs;
+  baseDir;
   async listSkills() {
     const dirs = await this.discoverSkillDirs();
     const skills = [];
@@ -2100,9 +2246,7 @@ var FileSystemSkillProvider = class {
     return skills;
   }
   async getSkill(name) {
-    const raw = await this.fs.readFile(
-      path.join(this.baseDir, name, "SKILL.md")
-    );
+    const raw = await this.fs.readFile(path.join(this.baseDir, name, "SKILL.md"));
     const { frontmatter, body } = parseSkillFile(raw);
     if (frontmatter.name !== name) {
       throw new Error(
@@ -2111,7 +2255,10 @@ var FileSystemSkillProvider = class {
     }
     const location = path.join(this.baseDir, name);
     const resourcePaths = await this.discoverResources(name);
-    const resourceContents = await this.readResourceContents(location, resourcePaths);
+    const resourceContents = await this.readResourceContents(
+      location,
+      resourcePaths
+    );
     return {
       ...frontmatter,
       instructions: body,
@@ -2131,7 +2278,10 @@ var FileSystemSkillProvider = class {
       const { frontmatter, body } = parseSkillFile(raw);
       const location = path.join(this.baseDir, dir);
       const resourcePaths = await this.discoverResources(dir);
-      const resourceContents = await this.readResourceContents(location, resourcePaths);
+      const resourceContents = await this.readResourceContents(
+        location,
+        resourcePaths
+      );
       skills.push({
         ...frontmatter,
         instructions: body,
@@ -2264,6 +2414,20 @@ function createThreadManager(config) {
     },
     async delete() {
       await redis.del(redisKey, metaKey);
+    },
+    async length() {
+      await assertThreadExists();
+      return redis.llen(redisKey);
+    },
+    async truncate(length) {
+      await assertThreadExists();
+      if (length <= 0) {
+        await redis.del(redisKey);
+        await redis.expire(metaKey, THREAD_TTL_SECONDS);
+      } else {
+        await redis.ltrim(redisKey, 0, length - 1);
+        await redis.expire(redisKey, THREAD_TTL_SECONDS);
+      }
     }
   };
 }
@@ -2305,6 +2469,7 @@ var SandboxManager = class {
     this.provider = provider;
     this.hooks = options?.hooks ?? {};
   }
+  provider;
   hooks;
   async create(options, ctx) {
     let providerOptions = options;
@@ -2333,7 +2498,7 @@ var SandboxManager = class {
     }
     const { sandbox } = await this.provider.create(providerOptions);
     if (this.hooks.onPostCreate) {
-      await this.hooks.onPostCreate(sandbox.id);
+      await this.hooks.onPostCreate(sandbox, ctx ?? {});
     }
     return { sandboxId: sandbox.id };
   }
@@ -2349,15 +2514,18 @@ var SandboxManager = class {
   async resume(id) {
     await this.provider.resume(id);
   }
-  async snapshot(id) {
-    return this.provider.snapshot(id);
+  async snapshot(id, options) {
+    return this.provider.snapshot(id, options);
   }
-  async restore(snapshot) {
-    const sandbox = await this.provider.restore(snapshot);
+  async restore(snapshot, options) {
+    const sandbox = await this.provider.restore(snapshot, options);
     return sandbox.id;
   }
-  async fork(sandboxId) {
-    const sandbox = await this.provider.fork(sandboxId);
+  async deleteSnapshot(snapshot) {
+    await this.provider.deleteSnapshot(snapshot);
+  }
+  async fork(sandboxId, options) {
+    const sandbox = await this.provider.fork(sandboxId, options);
     return sandbox.id;
   }
   /**
@@ -2395,11 +2563,17 @@ var SandboxManager = class {
       resumeSandbox: async (sandboxId) => {
         await this.resume(sandboxId);
       },
-      snapshotSandbox: async (sandboxId) => {
-        return this.snapshot(sandboxId);
+      snapshotSandbox: async (sandboxId, options) => {
+        return this.snapshot(sandboxId, options);
+      },
+      restoreSandbox: async (snapshot, options) => {
+        return this.restore(snapshot, options);
+      },
+      deleteSandboxSnapshot: async (snapshot) => {
+        await this.deleteSnapshot(snapshot);
       },
-      forkSandbox: async (sandboxId) => {
-        return this.fork(sandboxId);
+      forkSandbox: async (sandboxId, options) => {
+        return this.fork(sandboxId, options);
       }
     };
     const cap = (s) => s.charAt(0).toUpperCase() + s.slice(1);
@@ -2513,6 +2687,8 @@ var VirtualFileSystem = class {
       ]) : []
     );
   }
+  resolver;
+  ctx;
   workspaceBase;
   entries;
   directories;