zeitlich 0.2.38 → 0.2.39

package/dist/index.d.cts

@@ -1,12 +1,12 @@
-import { B as BashArgs, F as FileEditArgs, G as GlobArgs, a as FileReadArgs, b as FileWriteArgs } from './workflow-DuvMZ8Vm.cjs';
-export { A as AskUserQuestionArgs, c as FileTreeAccessor, 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-DuvMZ8Vm.cjs';
-import { R as RouterContext, d as ToolResultConfig, c as ActivityToolHandler, J as JsonValue, b as ToolHandlerResponse, B as BaseAgentState, e as RunAgentConfig, f as SkillProvider, g as SkillMetadata, h as Skill, F as FileEntryMetadata, i as FileResolver, V as VirtualFsContext, j as TreeMutation, k as PrefixedVirtualFsOps } from './types-C06FwR96.cjs';
-export { l as AgentConfig, m as AgentFile, A as AgentResponse, n as AgentState, o as AgentStateManager, p as AgentStatus, q as AppendToolResultFn, r as FileEntry, H as Hooks, I as InferToolResults, s as JsonPrimitive, t as JsonSerializable, 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, Q as ProcessToolCallsContext, U as ProcessToolCallsResult, W as RawToolCall, X as RewindSignal, Y as RunAgentActivity, Z as SandboxInit, _ as SandboxShutdown, S as ScopedPrefix, $ as SerializableToolDefinition, a0 as SessionConfig, a1 as SessionEndHook, a2 as SessionEndHookContext, a3 as SessionExitReason, a4 as SessionResult, a5 as SessionStartHook, a6 as SessionStartHookContext, a7 as SubagentConfig, a8 as SubagentDefinition, a9 as SubagentFnResult, aa as SubagentHandlerResponse, ab as SubagentHooks, ac as SubagentSandboxConfig, ad as SubagentSandboxShutdown, ae as SubagentSessionInput, af as SubagentWorkflow, ag as SubagentWorkflowInput, ah as TaskStatus, ai as ThreadInit, T as ThreadOps, aj as TokenUsage, ak as ToolArgs, al as ToolCallResult, am as ToolCallResultUnion, an as ToolDefinition, ao as ToolHandler, ap as ToolHooks, aq as ToolMap, ar as ToolNames, as as ToolResult, at as ToolRouter, au as ToolRouterHooks, av as ToolWithHandler, aw as VirtualFileSystem, ax as VirtualFileTree, ay as VirtualFsOps, az as VirtualFsState, aA as WorkflowTask, aB as ZeitlichSession, aC as isTerminalStatus } from './types-C06FwR96.cjs';
+import { B as BashArgs, F as FileEditArgs, G as GlobArgs, a as FileReadArgs, b as FileWriteArgs } from './workflow-Bx9utBwb.cjs';
+export { A as AskUserQuestionArgs, D as DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT, c as FileTreeAccessor, 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';
+import { R as RouterContext, e as ToolResultConfig, d as ActivityToolHandler, J as JsonValue, c as ToolHandlerResponse, B as BaseAgentState, f as RunAgentConfig, g as SkillProvider, h as SkillMetadata, i as Skill, F as FileEntryMetadata, j as FileResolver, V as VirtualFsContext, k as TreeMutation, l as PrefixedVirtualFsOps } from './types-Bcbiq8iv.cjs';
+export { m as AgentConfig, n as AgentFile, A as AgentResponse, o as AgentState, p as AgentStateManager, q as AgentStatus, r as AppendToolResultFn, s as FileEntry, H as Hooks, I as InferToolResults, t as JsonPrimitive, u as JsonSerializable, 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, U as ProcessToolCallsContext, W as ProcessToolCallsResult, X as RawToolCall, Y as RewindSignal, Z as RunAgentActivity, _ 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, 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, ar as ToolHooks, as as ToolMap, at as ToolNames, au as ToolResult, av as ToolRouter, aw as ToolRouterHooks, ax as ToolWithHandler, ay as VirtualFileSystem, az as VirtualFileTree, aA as VirtualFsOps, aB as VirtualFsState, aC as WorkflowTask, aD as ZeitlichSession, aE as isTerminalStatus } from './types-Bcbiq8iv.cjs';
 import { S as Sandbox, a as SandboxFileSystem, d as SandboxCreateOptions, b as SandboxProvider, f as SandboxSnapshot, P as PrefixedSandboxOps, F as FileStat, D as DirentEntry, E as ExecResult } from './types-yx0LzPGn.cjs';
 export { h as ExecOptions, c as SandboxCapabilities, e as SandboxCreateResult, i as SandboxNotFoundError, j as SandboxNotSupportedError, g as SandboxOps } from './types-yx0LzPGn.cjs';
 import { WorkflowClient } from '@temporalio/client';
-import { a as ThreadManagerConfig, B as BaseThreadManager } from './types-BaOw4hKI.cjs';
-export { P as ProviderThreadManager } from './types-BaOw4hKI.cjs';
+import { a as ThreadManagerConfig, B as BaseThreadManager } from './types-hFFi-Zd9.cjs';
+export { P as ProviderThreadManager } from './types-hFFi-Zd9.cjs';
 import 'zod';
 import '@temporalio/workflow';
 import '@temporalio/common';

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-import { B as BashArgs, F as FileEditArgs, G as GlobArgs, a as FileReadArgs, b as FileWriteArgs } from './workflow-CSCkpwAL.js';
-export { A as AskUserQuestionArgs, c as FileTreeAccessor, 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-CSCkpwAL.js';
-import { R as RouterContext, d as ToolResultConfig, c as ActivityToolHandler, J as JsonValue, b as ToolHandlerResponse, B as BaseAgentState, e as RunAgentConfig, f as SkillProvider, g as SkillMetadata, h as Skill, F as FileEntryMetadata, i as FileResolver, V as VirtualFsContext, j as TreeMutation, k as PrefixedVirtualFsOps } from './types-DNr31FzL.js';
-export { l as AgentConfig, m as AgentFile, A as AgentResponse, n as AgentState, o as AgentStateManager, p as AgentStatus, q as AppendToolResultFn, r as FileEntry, H as Hooks, I as InferToolResults, s as JsonPrimitive, t as JsonSerializable, 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, Q as ProcessToolCallsContext, U as ProcessToolCallsResult, W as RawToolCall, X as RewindSignal, Y as RunAgentActivity, Z as SandboxInit, _ as SandboxShutdown, S as ScopedPrefix, $ as SerializableToolDefinition, a0 as SessionConfig, a1 as SessionEndHook, a2 as SessionEndHookContext, a3 as SessionExitReason, a4 as SessionResult, a5 as SessionStartHook, a6 as SessionStartHookContext, a7 as SubagentConfig, a8 as SubagentDefinition, a9 as SubagentFnResult, aa as SubagentHandlerResponse, ab as SubagentHooks, ac as SubagentSandboxConfig, ad as SubagentSandboxShutdown, ae as SubagentSessionInput, af as SubagentWorkflow, ag as SubagentWorkflowInput, ah as TaskStatus, ai as ThreadInit, T as ThreadOps, aj as TokenUsage, ak as ToolArgs, al as ToolCallResult, am as ToolCallResultUnion, an as ToolDefinition, ao as ToolHandler, ap as ToolHooks, aq as ToolMap, ar as ToolNames, as as ToolResult, at as ToolRouter, au as ToolRouterHooks, av as ToolWithHandler, aw as VirtualFileSystem, ax as VirtualFileTree, ay as VirtualFsOps, az as VirtualFsState, aA as WorkflowTask, aB as ZeitlichSession, aC as isTerminalStatus } from './types-DNr31FzL.js';
+import { B as BashArgs, F as FileEditArgs, G as GlobArgs, a as FileReadArgs, b as FileWriteArgs } from './workflow-Bmf9EtDW.js';
+export { A as AskUserQuestionArgs, D as DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT, c as FileTreeAccessor, 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';
+import { R as RouterContext, e as ToolResultConfig, d as ActivityToolHandler, J as JsonValue, c as ToolHandlerResponse, B as BaseAgentState, f as RunAgentConfig, g as SkillProvider, h as SkillMetadata, i as Skill, F as FileEntryMetadata, j as FileResolver, V as VirtualFsContext, k as TreeMutation, l as PrefixedVirtualFsOps } from './types-Dt8-HBBT.js';
+export { m as AgentConfig, n as AgentFile, A as AgentResponse, o as AgentState, p as AgentStateManager, q as AgentStatus, r as AppendToolResultFn, s as FileEntry, H as Hooks, I as InferToolResults, t as JsonPrimitive, u as JsonSerializable, 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, U as ProcessToolCallsContext, W as ProcessToolCallsResult, X as RawToolCall, Y as RewindSignal, Z as RunAgentActivity, _ 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, 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, ar as ToolHooks, as as ToolMap, at as ToolNames, au as ToolResult, av as ToolRouter, aw as ToolRouterHooks, ax as ToolWithHandler, ay as VirtualFileSystem, az as VirtualFileTree, aA as VirtualFsOps, aB as VirtualFsState, aC as WorkflowTask, aD as ZeitlichSession, aE as isTerminalStatus } from './types-Dt8-HBBT.js';
 import { S as Sandbox, a as SandboxFileSystem, d as SandboxCreateOptions, b as SandboxProvider, f as SandboxSnapshot, P as PrefixedSandboxOps, F as FileStat, D as DirentEntry, E as ExecResult } from './types-yx0LzPGn.js';
 export { h as ExecOptions, c as SandboxCapabilities, e as SandboxCreateResult, i as SandboxNotFoundError, j as SandboxNotSupportedError, g as SandboxOps } from './types-yx0LzPGn.js';
 import { WorkflowClient } from '@temporalio/client';
-import { a as ThreadManagerConfig, B as BaseThreadManager } from './types-BH_IRryz.js';
-export { P as ProviderThreadManager } from './types-BH_IRryz.js';
+import { a as ThreadManagerConfig, B as BaseThreadManager } from './types-DpHTX-iO.js';
+export { P as ProviderThreadManager } from './types-DpHTX-iO.js';
 import 'zod';
 import '@temporalio/workflow';
 import '@temporalio/common';

package/dist/index.js

@@ -438,6 +438,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" };
@@ -469,17 +470,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) {
@@ -535,8 +547,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;
@@ -554,8 +578,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;
@@ -584,6 +620,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
@@ -591,13 +633,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,
@@ -641,10 +709,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 {
@@ -887,6 +958,7 @@ async function createSession({
   sandbox: sandboxInit,
   sandboxShutdown = "destroy",
   onSandboxReady,
+  onSessionExit,
   virtualFs: virtualFsConfig,
   virtualFsOps
 }) {
@@ -912,7 +984,8 @@ async function createSession({
     appendSystemMessage,
     appendAgentMessage,
     forkThread,
-    truncateThread
+    loadThreadState,
+    saveThreadState
   } = threadOps;
   const plugins = [];
   let destroySubagentSandboxes;
@@ -1040,7 +1113,10 @@ async function createSession({
         baseSnapshot = await sandboxOps.snapshotSandbox(sandboxId);
       }
       if (sandboxId && sandboxOwned && onSandboxReady) {
-        onSandboxReady(sandboxId);
+        onSandboxReady({
+          sandboxId,
+          ...baseSnapshot && { baseSnapshot }
+        });
       }
       if (virtualFsConfig) {
         if (!virtualFsOps) {
@@ -1083,9 +1159,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({
@@ -1107,24 +1194,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());
-          const {
-            message,
-            rawToolCalls,
-            usage,
-            threadLengthAtCall
-          } = await runAgent({
+          assistantId ??= uuid4();
+          const { message, rawToolCalls, usage } = await runAgent({
             threadId,
             threadKey,
             agentName,
-            metadata
+            metadata,
+            assistantMessageId: assistantId
           });
-          const preAssistantLength = threadLengthAtCall;
-          await appendAgentMessage(threadId, uuid4(), message, threadKey);
+          await appendAgentMessage(threadId, assistantId, message, threadKey);
           if (usage) {
             stateManager.updateUsage(usage);
           }
@@ -1178,15 +1262,9 @@ async function createSession({
               toolCallId: rewind.toolCallId,
               toolName: rewind.toolName
             });
-            if (preAssistantLength === void 0) {
-              throw 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;
           }
+          assistantId = void 0;
           if (stateManager.getStatus() === "WAITING_FOR_INPUT") {
             const conditionMet = await condition(
               () => stateManager.getStatus() === "RUNNING",
@@ -1219,6 +1297,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) {
@@ -1255,6 +1346,12 @@ async function createSession({
         ...baseSnapshot && { hasBaseSnapshot: true },
         ...exitSnapshot && { hasExitSnapshot: true }
       });
+      if (onSessionExit) {
+        onSessionExit({
+          ...sandboxId && { sandboxId },
+          ...exitSnapshot && { snapshot: exitSnapshot }
+        });
+      }
       return {
         threadId,
         finalMessage,
@@ -1283,6 +1380,18 @@ 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}`;
+}
+function getThreadStateKey(threadKey, threadId) {
+  return `${threadKey}:state:thread:${threadId}`;
+}
+
 // src/lib/types.ts
 function isTerminalStatus(status) {
   return status === "COMPLETED" || status === "FAILED" || status === "CANCELLED";
@@ -1302,11 +1411,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;
@@ -1386,7 +1503,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() {
@@ -1424,6 +1548,12 @@ function createAgentStateManager({
       }
       return deleted;
     },
+    getPersistedSlice() {
+      return {
+        tasks: Array.from(tasks.entries()),
+        custom: { ...customState }
+      };
+    },
     updateUsage(usage) {
       totalInputTokens += usage.inputTokens ?? 0;
       totalOutputTokens += usage.outputTokens ?? 0;
@@ -1545,22 +1675,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, {
@@ -2330,7 +2480,6 @@ var FileSystemSkillProvider = class {
 };
 
 // src/lib/thread/manager.ts
-var THREAD_TTL_SECONDS = 60 * 60 * 24 * 90;
 var APPEND_IDEMPOTENT_SCRIPT = `
 if redis.call('EXISTS', KEYS[1]) == 1 then
   return 0
@@ -2342,8 +2491,8 @@ redis.call('EXPIRE', KEYS[2], tonumber(ARGV[1]))
 redis.call('SET', KEYS[1], '1', 'EX', tonumber(ARGV[1]))
 return 1
 `;
-function getThreadKey(threadId, key) {
-  return `${key}:thread:${threadId}`;
+function getDedupKey(threadId, id) {
+  return `dedup:${id}:thread:${threadId}`;
 }
 function createThreadManager(config) {
   const {
@@ -2354,8 +2503,9 @@ function createThreadManager(config) {
     deserialize = (raw) => JSON.parse(raw),
     idOf
   } = config;
-  const redisKey = getThreadKey(threadId, key);
-  const metaKey = getThreadKey(threadId, `${key}:meta`);
+  const redisKey = getThreadListKey(key, threadId);
+  const metaKey = getThreadMetaKey(key, threadId);
+  const stateKey = getThreadStateKey(key, threadId);
   async function assertThreadExists() {
     const exists = await redis.exists(metaKey);
     if (!exists) {
@@ -2377,7 +2527,7 @@ function createThreadManager(config) {
       await assertThreadExists();
       if (idOf) {
         const dedupId = messages.map(idOf).join(":");
-        const dedupKey = getThreadKey(threadId, `dedup:${dedupId}`);
+        const dedupKey = getDedupKey(threadId, dedupId);
         await redis.eval(
           APPEND_IDEMPOTENT_SCRIPT,
           2,
@@ -2394,34 +2544,98 @@ function createThreadManager(config) {
     async fork(newThreadId) {
       await assertThreadExists();
       const data = await redis.lrange(redisKey, 0, -1);
+      const stateRaw = await redis.get(stateKey);
       const forked = createThreadManager({
         ...config,
         threadId: newThreadId
       });
       await forked.initialize();
       if (data.length > 0) {
-        const newKey = getThreadKey(newThreadId, key);
+        const newKey = getThreadListKey(key, newThreadId);
         await redis.rpush(newKey, ...data);
         await redis.expire(newKey, THREAD_TTL_SECONDS);
       }
+      if (stateRaw != null) {
+        const newStateKey = getThreadStateKey(key, newThreadId);
+        await redis.set(newStateKey, stateRaw, "EX", THREAD_TTL_SECONDS);
+      }
       return forked;
     },
+    async replaceAll(messages) {
+      await assertThreadExists();
+      if (!idOf) {
+        throw new Error(
+          "replaceAll requires the thread manager to be configured with `idOf`"
+        );
+      }
+      const existing = await redis.lrange(redisKey, 0, -1);
+      const existingIds = existing.map((raw) => idOf(deserialize(raw))).filter((id) => typeof id === "string");
+      await redis.del(redisKey);
+      if (existingIds.length > 0) {
+        await redis.del(
+          ...existingIds.map((id) => getDedupKey(threadId, id))
+        );
+      }
+      if (messages.length > 0) {
+        await redis.rpush(redisKey, ...messages.map(serialize));
+        await redis.expire(redisKey, THREAD_TTL_SECONDS);
+      }
+      await redis.expire(metaKey, THREAD_TTL_SECONDS);
+    },
     async delete() {
-      await redis.del(redisKey, metaKey);
+      await redis.del(redisKey, metaKey, stateKey);
+    },
+    async loadState() {
+      const raw = await redis.get(stateKey);
+      if (raw == null) return null;
+      return JSON.parse(raw);
+    },
+    async saveState(state) {
+      await assertThreadExists();
+      await redis.set(
+        stateKey,
+        JSON.stringify(state),
+        "EX",
+        THREAD_TTL_SECONDS
+      );
+    },
+    async deleteState() {
+      await redis.del(stateKey);
     },
     async length() {
       await assertThreadExists();
       return redis.llen(redisKey);
     },
-    async truncate(length) {
+    async truncateFromId(messageId) {
       await assertThreadExists();
-      if (length <= 0) {
+      if (!idOf) {
+        throw new Error(
+          "truncateFromId requires the thread manager to be configured with `idOf`"
+        );
+      }
+      const data = await redis.lrange(redisKey, 0, -1);
+      let idx = -1;
+      const removedIds = [];
+      for (let i = 0; i < data.length; i++) {
+        const raw = data[i];
+        if (raw === void 0) continue;
+        const id = idOf(deserialize(raw));
+        if (idx === -1 && id === messageId) idx = i;
+        if (idx !== -1) removedIds.push(id);
+      }
+      if (idx === -1) return;
+      if (idx === 0) {
         await redis.del(redisKey);
         await redis.expire(metaKey, THREAD_TTL_SECONDS);
       } else {
-        await redis.ltrim(redisKey, 0, length - 1);
+        await redis.ltrim(redisKey, 0, idx - 1);
         await redis.expire(redisKey, THREAD_TTL_SECONDS);
       }
+      if (removedIds.length > 0) {
+        await redis.del(
+          ...removedIds.map((id) => getDedupKey(threadId, id))
+        );
+      }
     }
   };
 }
@@ -3236,6 +3450,6 @@ var toTree = async (fs, opts = {}) => {
   return base + subtree;
 };
 
-export { FileSystemSkillProvider, NodeFsSandboxFileSystem, SandboxManager, SandboxNotFoundError, SandboxNotSupportedError, VirtualFileSystem, applyVirtualTreeMutations, askUserQuestionTool, bashHandler, bashTool, composeHooks, createAgentStateManager, createAskUserQuestionHandler, createBashToolDescription, createObservabilityHooks, createReadSkillHandler, createReadSkillTool, createRunAgentActivity, createSession, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createThreadManager, createToolRouter, createVirtualFsActivities, defineSubagent, defineSubagentWorkflow, defineTool, defineWorkflow, editHandler, editTool, filesWithMimeType, formatVirtualFileTree, getActivityContext, getShortId, globHandler, globTool, grepTool, hasDirectory, hasFileWithMimeType, hasNoOtherToolCalls, isTerminalStatus, parseSkillFile, proxyRunAgent, proxyVirtualFsOps, queryParentWorkflowState, readFileHandler, readFileTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, toTree, withAutoAppend, withParentWorkflowState, withSandbox, withVirtualFs, writeFileHandler, writeFileTool };
+export { DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT, FileSystemSkillProvider, NodeFsSandboxFileSystem, SandboxManager, SandboxNotFoundError, SandboxNotSupportedError, THREAD_TTL_SECONDS, VirtualFileSystem, applyVirtualTreeMutations, askUserQuestionTool, bashHandler, bashTool, composeHooks, createAgentStateManager, createAskUserQuestionHandler, createBashToolDescription, createObservabilityHooks, createReadSkillHandler, createReadSkillTool, createRunAgentActivity, createSession, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createThreadManager, createToolRouter, createVirtualFsActivities, defineSubagent, defineSubagentWorkflow, defineTool, defineWorkflow, editHandler, editTool, filesWithMimeType, formatVirtualFileTree, getActivityContext, getShortId, getThreadListKey, getThreadMetaKey, globHandler, globTool, grepTool, hasDirectory, hasFileWithMimeType, hasNoOtherToolCalls, isTerminalStatus, parseSkillFile, proxyRunAgent, proxyVirtualFsOps, queryParentWorkflowState, readFileHandler, readFileTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, toTree, withAutoAppend, withParentWorkflowState, withSandbox, withVirtualFs, writeFileHandler, writeFileTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map