zeitlich 0.2.37 → 0.2.39

package/dist/workflow.d.cts

@@ -1,6 +1,6 @@
-export { A as AskUserQuestionArgs, B as BashArgs, F as FileEditArgs, a as FileReadArgs, b as FileWriteArgs, G as GlobArgs, d as GrepArgs, O as ObservabilityHooks, R as ReadSkillArgs, S as SessionEndedEvent, e as SessionStartedEvent, f as SubagentArgs, T as TaskCreateArgs, g as TaskGetArgs, h as TaskListArgs, i as TaskUpdateArgs, j as ToolExecutedEvent, k as TurnCompletedEvent, W as WorkflowConfig, l as WorkflowInput, m as WorkflowSessionInput, Z as ZeitlichObservabilitySinks, n as applyVirtualTreeMutations, o as askUserQuestionTool, p as bashTool, q as composeHooks, r as createAgentStateManager, s as createAskUserQuestionHandler, t as createBashToolDescription, u as createObservabilityHooks, v as createReadSkillHandler, w as createReadSkillTool, x as createSession, y as createTaskCreateHandler, z as createTaskGetHandler, C as createTaskListHandler, D as createTaskUpdateHandler, E as createToolRouter, H as defineSubagent, I as defineSubagentWorkflow, J as defineTool, K as defineWorkflow, L as editTool, M as filesWithMimeType, N as formatVirtualFileTree, P as getShortId, Q as globTool, U as grepTool, V as hasDirectory, X as hasFileWithMimeType, Y as hasNoOtherToolCalls, _ as parseSkillFile, $ as proxyRunAgent, a0 as proxyVirtualFsOps, a1 as readFileTool, a2 as taskCreateTool, a3 as taskGetTool, a4 as taskListTool, a5 as taskUpdateTool, a6 as writeFileTool } from './workflow-Do_lzJpT.cjs';
-export { c as ActivityToolHandler, l as AgentConfig, m as AgentFile, A as AgentResponse, n as AgentState, o as AgentStateManager, p as AgentStatus, q as AppendToolResultFn, B as BaseAgentState, r as FileEntry, F as FileEntryMetadata, i as FileResolver, H as Hooks, I as InferToolResults, s as JsonPrimitive, t as JsonSerializable, J as JsonValue, a as ModelInvoker, M as ModelInvokerConfig, u as ParsedToolCall, v as ParsedToolCallUnion, w as PostHumanMessageAppendHook, x as PostHumanMessageAppendHookContext, y as PostToolUseFailureHook, z as PostToolUseFailureHookContext, C as PostToolUseFailureHookResult, D as PostToolUseHook, E as PostToolUseHookContext, G as PreHumanMessageAppendHook, K as PreHumanMessageAppendHookContext, L as PreToolUseHook, N as PreToolUseHookContext, O as PreToolUseHookResult, P as PrefixedThreadOps, k as PrefixedVirtualFsOps, Q as ProcessToolCallsContext, U as RawToolCall, R as RouterContext, W as RunAgentActivity, e as RunAgentConfig, X as SandboxInit, Y as SandboxShutdown, S as ScopedPrefix, Z as SerializableToolDefinition, _ as SessionConfig, $ as SessionEndHook, a0 as SessionEndHookContext, a1 as SessionExitReason, a2 as SessionResult, a3 as SessionStartHook, a4 as SessionStartHookContext, h as Skill, g as SkillMetadata, f as SkillProvider, a5 as SubagentConfig, a6 as SubagentDefinition, a7 as SubagentFnResult, a8 as SubagentHandlerResponse, a9 as SubagentHooks, aa as SubagentSandboxConfig, ab as SubagentSandboxShutdown, ac as SubagentSessionInput, ad as SubagentWorkflow, ae as SubagentWorkflowInput, af as TaskStatus, ag as ThreadInit, T as ThreadOps, ah as TokenUsage, ai as ToolArgs, aj as ToolCallResult, ak as ToolCallResultUnion, al as ToolDefinition, am as ToolHandler, b as ToolHandlerResponse, an as ToolHooks, ao as ToolMap, ap as ToolNames, aq as ToolResult, d as ToolResultConfig, ar as ToolRouter, as as ToolRouterHooks, at as ToolWithHandler, j as TreeMutation, av as VirtualFileTree, aw as VirtualFsOps, ax as VirtualFsState, ay as WorkflowTask, az as ZeitlichSession, aA as isTerminalStatus } from './types-BO7Yju20.cjs';
-export { h as ExecOptions, E as ExecResult, P as PrefixedSandboxOps, S as Sandbox, c as SandboxCapabilities, d as SandboxCreateOptions, e as SandboxCreateResult, D as SandboxDirentEntry, F as SandboxFileStat, a as SandboxFileSystem, i as SandboxNotFoundError, j as SandboxNotSupportedError, g as SandboxOps, b as SandboxProvider, f as SandboxSnapshot } from './types-tQL9njTu.cjs';
+export { A as AskUserQuestionArgs, B as BashArgs, D as DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT, F as FileEditArgs, a as FileReadArgs, b as FileWriteArgs, G as GlobArgs, d as GrepArgs, O as ObservabilityHooks, R as ReadSkillArgs, S as SessionEndedEvent, e as SessionStartedEvent, f as SubagentArgs, T as THREAD_TTL_SECONDS, g as TaskCreateArgs, h as TaskGetArgs, i as TaskListArgs, j as TaskUpdateArgs, k as ToolExecutedEvent, l as TurnCompletedEvent, W as WorkflowConfig, m as WorkflowInput, n as WorkflowSessionInput, Z as ZeitlichObservabilitySinks, o as applyVirtualTreeMutations, p as askUserQuestionTool, q as bashTool, r as composeHooks, s as createAgentStateManager, t as createAskUserQuestionHandler, u as createBashToolDescription, v as createObservabilityHooks, w as createReadSkillHandler, x as createReadSkillTool, y as createSession, z as createTaskCreateHandler, C as createTaskGetHandler, E as createTaskListHandler, H as createTaskUpdateHandler, I as createToolRouter, J as defineSubagent, K as defineSubagentWorkflow, L as defineTool, M as defineWorkflow, N as editTool, P as filesWithMimeType, Q as formatVirtualFileTree, U as getShortId, V as getThreadListKey, X as getThreadMetaKey, Y as globTool, _ as grepTool, $ as hasDirectory, a0 as hasFileWithMimeType, a1 as hasNoOtherToolCalls, a2 as parseSkillFile, a3 as proxyRunAgent, a4 as proxyVirtualFsOps, a5 as readFileTool, a6 as taskCreateTool, a7 as taskGetTool, a8 as taskListTool, a9 as taskUpdateTool, aa as writeFileTool } from './workflow-Bx9utBwb.cjs';
+export { d as ActivityToolHandler, m as AgentConfig, n as AgentFile, A as AgentResponse, o as AgentState, p as AgentStateManager, q as AgentStatus, r as AppendToolResultFn, B as BaseAgentState, s as FileEntry, F as FileEntryMetadata, j as FileResolver, H as Hooks, I as InferToolResults, t as JsonPrimitive, u as JsonSerializable, J as JsonValue, a as ModelInvoker, M as ModelInvokerConfig, v as ParsedToolCall, w as ParsedToolCallUnion, P as PersistedThreadState, x as PostHumanMessageAppendHook, y as PostHumanMessageAppendHookContext, z as PostToolUseFailureHook, C as PostToolUseFailureHookContext, D as PostToolUseFailureHookResult, E as PostToolUseHook, G as PostToolUseHookContext, K as PreHumanMessageAppendHook, L as PreHumanMessageAppendHookContext, N as PreToolUseHook, O as PreToolUseHookContext, Q as PreToolUseHookResult, b as PrefixedThreadOps, l as PrefixedVirtualFsOps, U as ProcessToolCallsContext, W as ProcessToolCallsResult, X as RawToolCall, Y as RewindSignal, R as RouterContext, Z as RunAgentActivity, f as RunAgentConfig, _ as SandboxInit, $ as SandboxShutdown, S as ScopedPrefix, a0 as SerializableToolDefinition, a1 as SessionConfig, a2 as SessionEndHook, a3 as SessionEndHookContext, a4 as SessionExitReason, a5 as SessionResult, a6 as SessionStartHook, a7 as SessionStartHookContext, i as Skill, h as SkillMetadata, g as SkillProvider, a8 as SubagentChildWorkflowOptions, a9 as SubagentConfig, aa as SubagentDefinition, ab as SubagentFnResult, ac as SubagentHandlerResponse, ad as SubagentHooks, ae as SubagentSandboxConfig, af as SubagentSandboxShutdown, ag as SubagentSessionInput, ah as SubagentWorkflow, ai as SubagentWorkflowInput, aj as TaskStatus, ak as ThreadInit, T as ThreadOps, al as TokenUsage, am as ToolArgs, an as ToolCallResult, ao as ToolCallResultUnion, ap as ToolDefinition, aq as ToolHandler, c as ToolHandlerResponse, ar as ToolHooks, as as ToolMap, at as ToolNames, au as ToolResult, e as ToolResultConfig, av as ToolRouter, aw as ToolRouterHooks, ax as ToolWithHandler, k as TreeMutation, az as VirtualFileTree, aA as VirtualFsOps, aB as VirtualFsState, aC as WorkflowTask, aD as ZeitlichSession, aE as isTerminalStatus } from './types-Bcbiq8iv.cjs';
+export { h as ExecOptions, E as ExecResult, P as PrefixedSandboxOps, S as Sandbox, c as SandboxCapabilities, d as SandboxCreateOptions, e as SandboxCreateResult, D as SandboxDirentEntry, F as SandboxFileStat, a as SandboxFileSystem, i as SandboxNotFoundError, j as SandboxNotSupportedError, g as SandboxOps, b as SandboxProvider, f as SandboxSnapshot } from './types-yx0LzPGn.cjs';
 import 'zod';
 import '@temporalio/workflow';
 import '@temporalio/common';

package/dist/workflow.d.ts

@@ -1,6 +1,6 @@
-export { A as AskUserQuestionArgs, B as BashArgs, F as FileEditArgs, a as FileReadArgs, b as FileWriteArgs, G as GlobArgs, d as GrepArgs, O as ObservabilityHooks, R as ReadSkillArgs, S as SessionEndedEvent, e as SessionStartedEvent, f as SubagentArgs, T as TaskCreateArgs, g as TaskGetArgs, h as TaskListArgs, i as TaskUpdateArgs, j as ToolExecutedEvent, k as TurnCompletedEvent, W as WorkflowConfig, l as WorkflowInput, m as WorkflowSessionInput, Z as ZeitlichObservabilitySinks, n as applyVirtualTreeMutations, o as askUserQuestionTool, p as bashTool, q as composeHooks, r as createAgentStateManager, s as createAskUserQuestionHandler, t as createBashToolDescription, u as createObservabilityHooks, v as createReadSkillHandler, w as createReadSkillTool, x as createSession, y as createTaskCreateHandler, z as createTaskGetHandler, C as createTaskListHandler, D as createTaskUpdateHandler, E as createToolRouter, H as defineSubagent, I as defineSubagentWorkflow, J as defineTool, K as defineWorkflow, L as editTool, M as filesWithMimeType, N as formatVirtualFileTree, P as getShortId, Q as globTool, U as grepTool, V as hasDirectory, X as hasFileWithMimeType, Y as hasNoOtherToolCalls, _ as parseSkillFile, $ as proxyRunAgent, a0 as proxyVirtualFsOps, a1 as readFileTool, a2 as taskCreateTool, a3 as taskGetTool, a4 as taskListTool, a5 as taskUpdateTool, a6 as writeFileTool } from './workflow-CjXHbZZc.js';
-export { c as ActivityToolHandler, l as AgentConfig, m as AgentFile, A as AgentResponse, n as AgentState, o as AgentStateManager, p as AgentStatus, q as AppendToolResultFn, B as BaseAgentState, r as FileEntry, F as FileEntryMetadata, i as FileResolver, H as Hooks, I as InferToolResults, s as JsonPrimitive, t as JsonSerializable, J as JsonValue, a as ModelInvoker, M as ModelInvokerConfig, u as ParsedToolCall, v as ParsedToolCallUnion, w as PostHumanMessageAppendHook, x as PostHumanMessageAppendHookContext, y as PostToolUseFailureHook, z as PostToolUseFailureHookContext, C as PostToolUseFailureHookResult, D as PostToolUseHook, E as PostToolUseHookContext, G as PreHumanMessageAppendHook, K as PreHumanMessageAppendHookContext, L as PreToolUseHook, N as PreToolUseHookContext, O as PreToolUseHookResult, P as PrefixedThreadOps, k as PrefixedVirtualFsOps, Q as ProcessToolCallsContext, U as RawToolCall, R as RouterContext, W as RunAgentActivity, e as RunAgentConfig, X as SandboxInit, Y as SandboxShutdown, S as ScopedPrefix, Z as SerializableToolDefinition, _ as SessionConfig, $ as SessionEndHook, a0 as SessionEndHookContext, a1 as SessionExitReason, a2 as SessionResult, a3 as SessionStartHook, a4 as SessionStartHookContext, h as Skill, g as SkillMetadata, f as SkillProvider, a5 as SubagentConfig, a6 as SubagentDefinition, a7 as SubagentFnResult, a8 as SubagentHandlerResponse, a9 as SubagentHooks, aa as SubagentSandboxConfig, ab as SubagentSandboxShutdown, ac as SubagentSessionInput, ad as SubagentWorkflow, ae as SubagentWorkflowInput, af as TaskStatus, ag as ThreadInit, T as ThreadOps, ah as TokenUsage, ai as ToolArgs, aj as ToolCallResult, ak as ToolCallResultUnion, al as ToolDefinition, am as ToolHandler, b as ToolHandlerResponse, an as ToolHooks, ao as ToolMap, ap as ToolNames, aq as ToolResult, d as ToolResultConfig, ar as ToolRouter, as as ToolRouterHooks, at as ToolWithHandler, j as TreeMutation, av as VirtualFileTree, aw as VirtualFsOps, ax as VirtualFsState, ay as WorkflowTask, az as ZeitlichSession, aA as isTerminalStatus } from './types-CPKDl-y_.js';
-export { h as ExecOptions, E as ExecResult, P as PrefixedSandboxOps, S as Sandbox, c as SandboxCapabilities, d as SandboxCreateOptions, e as SandboxCreateResult, D as SandboxDirentEntry, F as SandboxFileStat, a as SandboxFileSystem, i as SandboxNotFoundError, j as SandboxNotSupportedError, g as SandboxOps, b as SandboxProvider, f as SandboxSnapshot } from './types-tQL9njTu.js';
+export { A as AskUserQuestionArgs, B as BashArgs, D as DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT, F as FileEditArgs, a as FileReadArgs, b as FileWriteArgs, G as GlobArgs, d as GrepArgs, O as ObservabilityHooks, R as ReadSkillArgs, S as SessionEndedEvent, e as SessionStartedEvent, f as SubagentArgs, T as THREAD_TTL_SECONDS, g as TaskCreateArgs, h as TaskGetArgs, i as TaskListArgs, j as TaskUpdateArgs, k as ToolExecutedEvent, l as TurnCompletedEvent, W as WorkflowConfig, m as WorkflowInput, n as WorkflowSessionInput, Z as ZeitlichObservabilitySinks, o as applyVirtualTreeMutations, p as askUserQuestionTool, q as bashTool, r as composeHooks, s as createAgentStateManager, t as createAskUserQuestionHandler, u as createBashToolDescription, v as createObservabilityHooks, w as createReadSkillHandler, x as createReadSkillTool, y as createSession, z as createTaskCreateHandler, C as createTaskGetHandler, E as createTaskListHandler, H as createTaskUpdateHandler, I as createToolRouter, J as defineSubagent, K as defineSubagentWorkflow, L as defineTool, M as defineWorkflow, N as editTool, P as filesWithMimeType, Q as formatVirtualFileTree, U as getShortId, V as getThreadListKey, X as getThreadMetaKey, Y as globTool, _ as grepTool, $ as hasDirectory, a0 as hasFileWithMimeType, a1 as hasNoOtherToolCalls, a2 as parseSkillFile, a3 as proxyRunAgent, a4 as proxyVirtualFsOps, a5 as readFileTool, a6 as taskCreateTool, a7 as taskGetTool, a8 as taskListTool, a9 as taskUpdateTool, aa as writeFileTool } from './workflow-Bmf9EtDW.js';
+export { d as ActivityToolHandler, m as AgentConfig, n as AgentFile, A as AgentResponse, o as AgentState, p as AgentStateManager, q as AgentStatus, r as AppendToolResultFn, B as BaseAgentState, s as FileEntry, F as FileEntryMetadata, j as FileResolver, H as Hooks, I as InferToolResults, t as JsonPrimitive, u as JsonSerializable, J as JsonValue, a as ModelInvoker, M as ModelInvokerConfig, v as ParsedToolCall, w as ParsedToolCallUnion, P as PersistedThreadState, x as PostHumanMessageAppendHook, y as PostHumanMessageAppendHookContext, z as PostToolUseFailureHook, C as PostToolUseFailureHookContext, D as PostToolUseFailureHookResult, E as PostToolUseHook, G as PostToolUseHookContext, K as PreHumanMessageAppendHook, L as PreHumanMessageAppendHookContext, N as PreToolUseHook, O as PreToolUseHookContext, Q as PreToolUseHookResult, b as PrefixedThreadOps, l as PrefixedVirtualFsOps, U as ProcessToolCallsContext, W as ProcessToolCallsResult, X as RawToolCall, Y as RewindSignal, R as RouterContext, Z as RunAgentActivity, f as RunAgentConfig, _ as SandboxInit, $ as SandboxShutdown, S as ScopedPrefix, a0 as SerializableToolDefinition, a1 as SessionConfig, a2 as SessionEndHook, a3 as SessionEndHookContext, a4 as SessionExitReason, a5 as SessionResult, a6 as SessionStartHook, a7 as SessionStartHookContext, i as Skill, h as SkillMetadata, g as SkillProvider, a8 as SubagentChildWorkflowOptions, a9 as SubagentConfig, aa as SubagentDefinition, ab as SubagentFnResult, ac as SubagentHandlerResponse, ad as SubagentHooks, ae as SubagentSandboxConfig, af as SubagentSandboxShutdown, ag as SubagentSessionInput, ah as SubagentWorkflow, ai as SubagentWorkflowInput, aj as TaskStatus, ak as ThreadInit, T as ThreadOps, al as TokenUsage, am as ToolArgs, an as ToolCallResult, ao as ToolCallResultUnion, ap as ToolDefinition, aq as ToolHandler, c as ToolHandlerResponse, ar as ToolHooks, as as ToolMap, at as ToolNames, au as ToolResult, e as ToolResultConfig, av as ToolRouter, aw as ToolRouterHooks, ax as ToolWithHandler, k as TreeMutation, az as VirtualFileTree, aA as VirtualFsOps, aB as VirtualFsState, aC as WorkflowTask, aD as ZeitlichSession, aE as isTerminalStatus } from './types-Dt8-HBBT.js';
+export { h as ExecOptions, E as ExecResult, P as PrefixedSandboxOps, S as Sandbox, c as SandboxCapabilities, d as SandboxCreateOptions, e as SandboxCreateResult, D as SandboxDirentEntry, F as SandboxFileStat, a as SandboxFileSystem, i as SandboxNotFoundError, j as SandboxNotSupportedError, g as SandboxOps, b as SandboxProvider, f as SandboxSnapshot } from './types-yx0LzPGn.js';
 import 'zod';
 import '@temporalio/workflow';
 import '@temporalio/common';

package/dist/workflow.js

@@ -1,4 +1,4 @@
-import { defineSignal, uuid4, setHandler, defineUpdate, ApplicationFailure, log, condition, defineQuery, proxySinks, workflowInfo, proxyActivities, getExternalWorkflowHandle, executeChild } from '@temporalio/workflow';
+import { defineSignal, CancellationScope, isCancellation, uuid4, setHandler, defineUpdate, ApplicationFailure, log, condition, defineQuery, proxySinks, workflowInfo, proxyActivities, getExternalWorkflowHandle, executeChild } from '@temporalio/workflow';
 import z14, { z } from 'zod';
 import { ApplicationFailure as ApplicationFailure$1 } from '@temporalio/common';
 
@@ -107,7 +107,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);
@@ -122,7 +122,7 @@ function createToolRouter(options) {
           reason: "Skipped by PreToolUse hook"
         })
       });
-      return null;
+      return { kind: "skipped" };
     }
     const effectiveArgs = preResult.args;
     log.debug("tool call dispatched", {
@@ -134,6 +134,7 @@ function createToolRouter(options) {
     let content;
     let resultAppended = false;
     let metadata;
+    let rewindRequested = false;
     try {
       if (tool) {
         const routerContext = {
@@ -151,11 +152,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 (isCancellation(error)) {
+        throw error;
+      }
       log.warn("tool call failed", {
         toolName: toolCall.name,
         toolCallId: toolCall.id,
@@ -173,6 +178,15 @@ function createToolRouter(options) {
       result = recovery.result;
       content = recovery.content;
     }
+    if (rewindRequested) {
+      const signal = {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name
+      };
+      log.info("tool requested rewind", { ...signal });
+      onRewindRequested?.(signal);
+      return { kind: "rewind", signal };
+    }
     if (!resultAppended) {
       const config = {
         threadId: options.threadId,
@@ -209,7 +223,7 @@ function createToolRouter(options) {
       turn,
       durationMs
     );
-    return toolResult;
+    return { kind: "result", value: toolResult };
   }
   return {
     hasTools() {
@@ -244,27 +258,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 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 (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);
@@ -388,6 +434,7 @@ function createSubagentTool(subagents) {
 var childSandboxReadySignal = defineSignal("childSandboxReady");
 
 // src/lib/subagent/handler.ts
+var DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT = "1h";
 function resolveSandboxConfig(config) {
   if (!config || config === "none") {
     return { source: "none", init: "per-call", continuation: "fork" };
@@ -419,17 +466,28 @@ function createSubagentHandler(subagents) {
   const threadSandboxes = /* @__PURE__ */ new Map();
   const persistentSandboxes = /* @__PURE__ */ new Map();
   const persistentSandboxCreating = /* @__PURE__ */ new Set();
+  const persistentSandboxCreationError = /* @__PURE__ */ new Map();
   const lazyCreatorAgent = /* @__PURE__ */ new Map();
+  const snapshotBaseCreatorAgent = /* @__PURE__ */ new Map();
   const threadSnapshots = /* @__PURE__ */ new Map();
   const persistentBaseSnapshot = /* @__PURE__ */ new Map();
   const persistentBaseSnapshotCreating = /* @__PURE__ */ new Set();
-  setHandler(childSandboxReadySignal, ({ childWorkflowId, sandboxId }) => {
-    const agentName = lazyCreatorAgent.get(childWorkflowId);
-    if (agentName && !persistentSandboxes.has(agentName)) {
-      persistentSandboxes.set(agentName, sandboxId);
-      lazyCreatorAgent.delete(childWorkflowId);
+  const persistentBaseSnapshotCreationError = /* @__PURE__ */ new Map();
+  setHandler(
+    childSandboxReadySignal,
+    ({ childWorkflowId, sandboxId, baseSnapshot }) => {
+      const lazyAgent = lazyCreatorAgent.get(childWorkflowId);
+      if (lazyAgent && !persistentSandboxes.has(lazyAgent)) {
+        persistentSandboxes.set(lazyAgent, sandboxId);
+        lazyCreatorAgent.delete(childWorkflowId);
+      }
+      const snapAgent = snapshotBaseCreatorAgent.get(childWorkflowId);
+      if (snapAgent && baseSnapshot && !persistentBaseSnapshot.has(snapAgent)) {
+        persistentBaseSnapshot.set(snapAgent, baseSnapshot);
+        snapshotBaseCreatorAgent.delete(childWorkflowId);
+      }
     }
-  });
+  );
   const handler = async (args, context) => {
     const config = subagents.find((s) => s.agentName === args.subagent);
     if (!config) {
@@ -485,8 +543,20 @@ function createSubagentHandler(subagents) {
         baseSnap = persistentBaseSnapshot.get(config.agentName);
         if (!baseSnap) {
           if (persistentBaseSnapshotCreating.has(config.agentName)) {
-            await condition(() => persistentBaseSnapshot.has(config.agentName));
+            await condition(
+              () => persistentBaseSnapshot.has(config.agentName) || persistentBaseSnapshotCreationError.has(config.agentName) || !persistentBaseSnapshotCreating.has(config.agentName)
+            );
+            const creatorErr = persistentBaseSnapshotCreationError.get(
+              config.agentName
+            );
+            if (creatorErr !== void 0) {
+              throw creatorErr;
+            }
             baseSnap = persistentBaseSnapshot.get(config.agentName);
+            if (!baseSnap) {
+              persistentBaseSnapshotCreating.add(config.agentName);
+              isSnapshotBaseCreator = true;
+            }
           } else {
             persistentBaseSnapshotCreating.add(config.agentName);
             isSnapshotBaseCreator = true;
@@ -504,8 +574,20 @@ function createSubagentHandler(subagents) {
         baseSandboxId = persistentSandboxes.get(config.agentName);
         if (!baseSandboxId) {
           if (persistentSandboxCreating.has(config.agentName)) {
-            await condition(() => persistentSandboxes.has(config.agentName));
+            await condition(
+              () => persistentSandboxes.has(config.agentName) || persistentSandboxCreationError.has(config.agentName) || !persistentSandboxCreating.has(config.agentName)
+            );
+            const creatorErr = persistentSandboxCreationError.get(
+              config.agentName
+            );
+            if (creatorErr !== void 0) {
+              throw creatorErr;
+            }
             baseSandboxId = persistentSandboxes.get(config.agentName);
+            if (!baseSandboxId) {
+              persistentSandboxCreating.add(config.agentName);
+              isLazyCreator = true;
+            }
           } else {
             persistentSandboxCreating.add(config.agentName);
             isLazyCreator = true;
@@ -534,6 +616,12 @@ function createSubagentHandler(subagents) {
     };
     const resolvedContext = config.context === void 0 ? void 0 : typeof config.context === "function" ? config.context() : config.context;
     const childOpts = {
+      // Apply a bounded run timeout by default so a child workflow that
+      // fails to initialize or otherwise never reaches a terminal state
+      // cannot hang the parent's `Subagent` tool call forever. Callers can
+      // raise, lower, or disable it via `workflowOptions.workflowRunTimeout`.
+      workflowRunTimeout: DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT,
+      ...config.workflowOptions ?? {},
       workflowId: childWorkflowId,
       args: resolvedContext === void 0 ? [args.prompt, workflowInput] : [args.prompt, workflowInput, resolvedContext],
       taskQueue: config.taskQueue ?? parentTaskQueue
@@ -541,13 +629,39 @@ function createSubagentHandler(subagents) {
     if (isLazyCreator) {
       lazyCreatorAgent.set(childWorkflowId, config.agentName);
     }
+    if (isSnapshotBaseCreator) {
+      snapshotBaseCreatorAgent.set(childWorkflowId, config.agentName);
+    }
     log.info("subagent spawned", {
       subagent: config.agentName,
       childWorkflowId,
       threadMode,
       sandboxSource: sandboxCfg.source
     });
-    const childResult = await executeChild(config.workflow, childOpts);
+    let childResult;
+    try {
+      childResult = await executeChild(
+        config.workflow,
+        childOpts
+      );
+    } catch (err) {
+      log.warn("subagent failed", {
+        subagent: config.agentName,
+        childWorkflowId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      if (isLazyCreator) {
+        persistentSandboxCreating.delete(config.agentName);
+        persistentSandboxCreationError.set(config.agentName, err);
+        lazyCreatorAgent.delete(childWorkflowId);
+      }
+      if (isSnapshotBaseCreator) {
+        persistentBaseSnapshotCreating.delete(config.agentName);
+        persistentBaseSnapshotCreationError.set(config.agentName, err);
+        snapshotBaseCreatorAgent.delete(childWorkflowId);
+      }
+      throw err;
+    }
     const effectiveShutdown = sandboxShutdownOverride ?? sandboxCfg.shutdown ?? "destroy";
     log.info("subagent completed", {
       subagent: config.agentName,
@@ -591,10 +705,13 @@ function createSubagentHandler(subagents) {
     }
     if (isLazyCreator) {
       persistentSandboxCreating.delete(config.agentName);
+      persistentSandboxCreationError.delete(config.agentName);
       lazyCreatorAgent.delete(childWorkflowId);
     }
     if (isSnapshotBaseCreator) {
       persistentBaseSnapshotCreating.delete(config.agentName);
+      persistentBaseSnapshotCreationError.delete(config.agentName);
+      snapshotBaseCreatorAgent.delete(childWorkflowId);
     }
     if (!toolResponse) {
       return {
@@ -837,6 +954,7 @@ async function createSession({
   sandbox: sandboxInit,
   sandboxShutdown = "destroy",
   onSandboxReady,
+  onSessionExit,
   virtualFs: virtualFsConfig,
   virtualFsOps
 }) {
@@ -861,7 +979,9 @@ async function createSession({
     initializeThread,
     appendSystemMessage,
     appendAgentMessage,
-    forkThread
+    forkThread,
+    loadThreadState,
+    saveThreadState
   } = threadOps;
   const plugins = [];
   let destroySubagentSandboxes;
@@ -955,8 +1075,10 @@ 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") {
@@ -966,8 +1088,11 @@ async function createSession({
             nonRetryable: true
           });
         }
-        const snap = sandboxInit.snapshot;
-        sandboxId = await sandboxOps.restoreSandbox(snap);
+        const restoreInit = sandboxInit;
+        sandboxId = await sandboxOps.restoreSandbox(
+          restoreInit.snapshot,
+          restoreInit.options
+        );
         sandboxOwned = true;
       } else if (sandboxOps) {
         const skillFiles = skills ? collectSkillFiles(skills) : void 0;
@@ -984,7 +1109,10 @@ async function createSession({
         baseSnapshot = await sandboxOps.snapshotSandbox(sandboxId);
       }
       if (sandboxId && sandboxOwned && onSandboxReady) {
-        onSandboxReady(sandboxId);
+        onSandboxReady({
+          sandboxId,
+          ...baseSnapshot && { baseSnapshot }
+        });
       }
       if (virtualFsConfig) {
         if (!virtualFsOps) {
@@ -1027,9 +1155,20 @@ async function createSession({
       });
       const sessionStartMs = Date.now();
       const systemPrompt = stateManager.getSystemPrompt();
+      const rehydrateFromSlice = (slice) => {
+        stateManager.mergeUpdate({
+          tasks: new Map(slice.tasks),
+          ...slice.custom
+        });
+      };
       if (threadMode === "fork" && sourceThreadId) {
         await forkThread(sourceThreadId, threadId, threadKey);
-      } else if (threadMode === "continue") ; else {
+        const forkedSlice = await loadThreadState(threadId, threadKey);
+        if (forkedSlice) rehydrateFromSlice(forkedSlice);
+      } else if (threadMode === "continue") {
+        const continuedSlice = await loadThreadState(threadId, threadKey);
+        if (continuedSlice) rehydrateFromSlice(continuedSlice);
+      } else {
         if (appendSystemPrompt) {
           if (systemPrompt == null || typeof systemPrompt === "string" && systemPrompt.trim() === "") {
             throw ApplicationFailure.create({
@@ -1051,18 +1190,21 @@ async function createSession({
       let exitReason = "completed";
       let finalMessage = null;
       try {
+        let assistantId;
         while (stateManager.isRunning() && !stateManager.isTerminal() && stateManager.getTurns() < maxTurns) {
           stateManager.incrementTurns();
           const currentTurn = stateManager.getTurns();
           log.debug("turn started", { agentName, threadId, turn: currentTurn });
           stateManager.setTools(toolRouter.getToolDefinitions());
+          assistantId ??= uuid4();
           const { message, rawToolCalls, usage } = await runAgent({
             threadId,
             threadKey,
             agentName,
-            metadata
+            metadata,
+            assistantMessageId: assistantId
           });
-          await appendAgentMessage(threadId, uuid4(), message, threadKey);
+          await appendAgentMessage(threadId, assistantId, message, threadKey);
           if (usage) {
             stateManager.updateUsage(usage);
           }
@@ -1107,6 +1249,18 @@ async function createSession({
               stateManager.updateUsage(result.usage);
             }
           }
+          const rewind = toolCallResults.rewind;
+          if (rewind) {
+            log.info("rewinding turn", {
+              agentName,
+              threadId,
+              turn: currentTurn,
+              toolCallId: rewind.toolCallId,
+              toolName: rewind.toolName
+            });
+            continue;
+          }
+          assistantId = void 0;
           if (stateManager.getStatus() === "WAITING_FOR_INPUT") {
             const conditionMet = await condition(
               () => stateManager.getStatus() === "RUNNING",
@@ -1139,6 +1293,19 @@ async function createSession({
         });
         throw ApplicationFailure.fromError(error);
       } finally {
+        try {
+          await saveThreadState(
+            threadId,
+            stateManager.getPersistedSlice(),
+            threadKey
+          );
+        } catch (persistError) {
+          log.warn("failed to persist thread state", {
+            agentName,
+            threadId,
+            error: persistError instanceof Error ? persistError.message : String(persistError)
+          });
+        }
         await callSessionEnd(exitReason, stateManager.getTurns());
         if (sandboxOwned && sandboxId && sandboxOps) {
           switch (sandboxShutdown) {
@@ -1175,6 +1342,12 @@ async function createSession({
         ...baseSnapshot && { hasBaseSnapshot: true },
         ...exitSnapshot && { hasExitSnapshot: true }
       });
+      if (onSessionExit) {
+        onSessionExit({
+          ...sandboxId && { sandboxId },
+          ...exitSnapshot && { snapshot: exitSnapshot }
+        });
+      }
       return {
         threadId,
         finalMessage,
@@ -1203,6 +1376,15 @@ function defineWorkflow(config, fn) {
   return workflow;
 }
 
+// src/lib/thread/keys.ts
+var THREAD_TTL_SECONDS = 60 * 60 * 24 * 90;
+function getThreadListKey(threadKey, threadId) {
+  return `${threadKey}:thread:${threadId}`;
+}
+function getThreadMetaKey(threadKey, threadId) {
+  return `${threadKey}:meta:thread:${threadId}`;
+}
+
 // src/lib/types.ts
 function isTerminalStatus(status) {
   return status === "COMPLETED" || status === "FAILED" || status === "CANCELLED";
@@ -1222,11 +1404,19 @@ function createAgentStateManager({
   let systemPrompt = initialState?.systemPrompt;
   const tasks = new Map(initialState?.tasks);
   const {
-    status: _,
-    version: __,
-    turns: ___,
-    tasks: ____,
-    tools: _____,
+    status: _status,
+    version: _version,
+    turns: _turns,
+    tasks: _tasks,
+    tools: _tools,
+    systemPrompt: _systemPrompt,
+    fileTree: _fileTree,
+    inlineFiles: _inlineFiles,
+    virtualFsCtx: _virtualFsCtx,
+    totalInputTokens: _totalInputTokens,
+    totalOutputTokens: _totalOutputTokens,
+    cachedWriteTokens: _cachedWriteTokens,
+    cachedReadTokens: _cachedReadTokens,
     ...custom
   } = initialState ?? {};
   const customState = custom;
@@ -1306,7 +1496,14 @@ function createAgentStateManager({
       version++;
     },
     mergeUpdate(update) {
-      Object.assign(customState, update);
+      const { tasks: nextTasks, ...rest } = update;
+      if (nextTasks) {
+        tasks.clear();
+        for (const [id, task] of nextTasks) {
+          tasks.set(id, task);
+        }
+      }
+      Object.assign(customState, rest);
       version++;
     },
     getCurrentState() {
@@ -1344,6 +1541,12 @@ function createAgentStateManager({
       }
       return deleted;
     },
+    getPersistedSlice() {
+      return {
+        tasks: Array.from(tasks.entries()),
+        custom: { ...customState }
+      };
+    },
     updateUsage(usage) {
       totalInputTokens += usage.inputTokens ?? 0;
       totalOutputTokens += usage.outputTokens ?? 0;
@@ -1387,22 +1590,42 @@ function defineSubagentWorkflow(config, fn) {
       });
     }
     const parentHandle = getExternalWorkflowHandle(parent.workflowId);
+    let capturedSandboxId;
+    let capturedSnapshot;
+    let capturedBaseSnapshot;
+    let capturedThreadId;
     const sessionInput = {
       agentName: config.name,
       sandboxShutdown: effectiveShutdown,
       ...workflowInput.thread && { thread: workflowInput.thread },
       ...workflowInput.sandbox && { sandbox: workflowInput.sandbox },
-      onSandboxReady: (sandboxId) => {
+      onSandboxReady: ({ sandboxId, baseSnapshot }) => {
+        capturedBaseSnapshot = baseSnapshot;
         const isReuse = workflowInput.sandbox?.mode === "continue";
         if (!isReuse) {
           void parentHandle.signal(childSandboxReadySignal, {
             childWorkflowId: workflowInfo().workflowId,
-            sandboxId
+            sandboxId,
+            ...baseSnapshot && { baseSnapshot }
           });
         }
+      },
+      onSessionExit: ({ sandboxId, snapshot, threadId }) => {
+        capturedSandboxId = sandboxId;
+        capturedSnapshot = snapshot;
+        capturedThreadId = threadId;
+      }
+    };
+    const result = await fn(prompt, sessionInput, context ?? {});
+    return {
+      ...result,
+      ...capturedThreadId !== void 0 && { threadId: capturedThreadId },
+      ...capturedSandboxId !== void 0 && { sandboxId: capturedSandboxId },
+      ...capturedSnapshot !== void 0 && { snapshot: capturedSnapshot },
+      ...capturedBaseSnapshot !== void 0 && {
+        baseSnapshot: capturedBaseSnapshot
       }
     };
-    return fn(prompt, sessionInput, context ?? {});
   };
   Object.defineProperty(workflow, "name", { value: config.name });
   return Object.assign(workflow, {
@@ -2061,6 +2284,6 @@ var createAskUserQuestionHandler = () => async (args) => {
   };
 };
 
-export { SandboxNotFoundError, SandboxNotSupportedError, applyVirtualTreeMutations, askUserQuestionTool, bashTool, composeHooks, createAgentStateManager, createAskUserQuestionHandler, createBashToolDescription, createObservabilityHooks, createReadSkillHandler, createReadSkillTool, createSession, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createToolRouter, defineSubagent, defineSubagentWorkflow, defineTool, defineWorkflow, editTool, filesWithMimeType, formatVirtualFileTree, getShortId, globTool, grepTool, hasDirectory, hasFileWithMimeType, hasNoOtherToolCalls, isTerminalStatus, parseSkillFile, proxyRunAgent, proxyVirtualFsOps, readFileTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, writeFileTool };
+export { DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT, SandboxNotFoundError, SandboxNotSupportedError, THREAD_TTL_SECONDS, applyVirtualTreeMutations, askUserQuestionTool, bashTool, composeHooks, createAgentStateManager, createAskUserQuestionHandler, createBashToolDescription, createObservabilityHooks, createReadSkillHandler, createReadSkillTool, createSession, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createToolRouter, defineSubagent, defineSubagentWorkflow, defineTool, defineWorkflow, editTool, filesWithMimeType, formatVirtualFileTree, getShortId, getThreadListKey, getThreadMetaKey, globTool, grepTool, hasDirectory, hasFileWithMimeType, hasNoOtherToolCalls, isTerminalStatus, parseSkillFile, proxyRunAgent, proxyVirtualFsOps, readFileTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, writeFileTool };
 //# sourceMappingURL=workflow.js.map
 //# sourceMappingURL=workflow.js.map