zeitlich 0.2.13 → 0.2.15

package/dist/index.js

@@ -1,152 +1,10 @@
 import { uuid4, setHandler, defineUpdate, ApplicationFailure, condition, proxyActivities, defineQuery, workflowInfo, executeChild } from '@temporalio/workflow';
 import z14, { z } from 'zod';
-import { Context } from '@temporalio/activity';
-import { Bash } from 'just-bash';
-import { readFile, readdir } from 'fs/promises';
+import { ApplicationFailure as ApplicationFailure$1 } from '@temporalio/common';
 import { join } from 'path';
+import { Context } from '@temporalio/activity';
 
-// src/lib/session.ts
-var SUBAGENT_TOOL_NAME = "Subagent";
-function buildSubagentDescription(subagents) {
-  const subagentList = subagents.map((s) => {
-    const continuation = s.allowThreadContinuation ? "\n*(Supports thread continuation \u2014 pass a threadId to resume a previous conversation)*" : "";
-    return `## ${s.agentName}
-${s.description}${continuation}`;
-  }).join("\n\n");
-  return `The ${SUBAGENT_TOOL_NAME} tool launches specialized agents (subagents) that autonomously handle complex work. Each agent type has specific capabilities and tools available to it.
-
-# Available subagents:
-${subagentList}
-`;
-}
-function createSubagentTool(subagents) {
-  if (subagents.length === 0) {
-    throw new Error("createTaskTool requires at least one subagent");
-  }
-  const names = subagents.map((s) => s.agentName);
-  const hasThreadContinuation = subagents.some(
-    (s) => s.allowThreadContinuation
-  );
-  const baseFields = {
-    subagent: z14.enum(names).describe("The type of subagent to launch"),
-    description: z14.string().describe("A short (3-5 word) description of the task"),
-    prompt: z14.string().describe("The task for the agent to perform")
-  };
-  const schema = hasThreadContinuation ? z14.object({
-    ...baseFields,
-    threadId: z14.string().nullable().describe(
-      "Thread ID to continue an existing conversation, or null to start a new one"
-    )
-  }) : z14.object(baseFields);
-  return {
-    name: SUBAGENT_TOOL_NAME,
-    description: buildSubagentDescription(subagents),
-    schema
-  };
-}
-var BASE62 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-function getShortId(length = 12) {
-  const hex = uuid4().replace(/-/g, "");
-  let result = "";
-  for (let i = 0; i < length; i++) {
-    const byte = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-    result += BASE62[byte % BASE62.length];
-  }
-  return result;
-}
-
-// src/tools/subagent/handler.ts
-function createSubagentHandler(subagents) {
-  const { taskQueue: parentTaskQueue } = workflowInfo();
-  return async (args) => {
-    const config = subagents.find((s) => s.agentName === args.subagent);
-    if (!config) {
-      throw new Error(
-        `Unknown subagent: ${args.subagent}. Available: ${subagents.map((s) => s.agentName).join(", ")}`
-      );
-    }
-    const childWorkflowId = `${args.subagent}-${getShortId()}`;
-    const input = {
-      prompt: args.prompt,
-      ...config.context && { context: config.context },
-      ...args.threadId && config.allowThreadContinuation && { threadId: args.threadId }
-    };
-    const childOpts = {
-      workflowId: childWorkflowId,
-      args: [input],
-      taskQueue: config.taskQueue ?? parentTaskQueue
-    };
-    const { toolResponse, data, usage, threadId: childThreadId } = typeof config.workflow === "string" ? await executeChild(config.workflow, childOpts) : await executeChild(config.workflow, childOpts);
-    if (!toolResponse) {
-      return {
-        toolResponse: "Subagent workflow returned no response",
-        data: null,
-        ...usage && { usage }
-      };
-    }
-    const validated = config.resultSchema ? config.resultSchema.safeParse(data) : null;
-    if (validated && !validated.success) {
-      return {
-        toolResponse: `Subagent workflow returned invalid data: ${validated.error.message}`,
-        data: null,
-        ...usage && { usage }
-      };
-    }
-    let finalToolResponse = toolResponse;
-    if (config.allowThreadContinuation && childThreadId) {
-      finalToolResponse = typeof toolResponse === "string" ? `${toolResponse}
-
-[Thread ID: ${childThreadId}]` : toolResponse;
-    }
-    return {
-      toolResponse: finalToolResponse,
-      data: validated ? validated.data : data,
-      ...usage && { usage }
-    };
-  };
-}
-var READ_SKILL_TOOL_NAME = "ReadSkill";
-function buildReadSkillDescription(skills) {
-  const skillList = skills.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
-  return `Load the full instructions for a skill. Read the skill before following its instructions.
-
-# Available skills:
-${skillList}
-`;
-}
-function createReadSkillTool(skills) {
-  if (skills.length === 0) {
-    throw new Error("createReadSkillTool requires at least one skill");
-  }
-  const names = skills.map((s) => s.name);
-  return {
-    name: READ_SKILL_TOOL_NAME,
-    description: buildReadSkillDescription(skills),
-    schema: z14.object({
-      skill_name: z14.enum(names).describe("The name of the skill to load")
-    })
-  };
-}
-
-// src/tools/read-skill/handler.ts
-function createReadSkillHandler(skills) {
-  const skillMap = new Map(skills.map((s) => [s.name, s]));
-  return (args) => {
-    const skill = skillMap.get(args.skill_name);
-    if (!skill) {
-      return {
-        toolResponse: JSON.stringify({
-          error: `Skill "${args.skill_name}" not found`
-        }),
-        data: null
-      };
-    }
-    return {
-      toolResponse: skill.instructions,
-      data: null
-    };
-  };
-}
+// src/lib/session/session.ts
 function createToolRouter(options) {
   const { appendToolResult } = options;
   const toolMap = /* @__PURE__ */ new Map();
@@ -154,45 +12,12 @@ function createToolRouter(options) {
     toolMap.set(tool.name, tool);
   }
   const isEnabled = (tool) => tool.enabled ?? true;
-  if (options.subagents) {
-    if (options.subagents.length > 0) {
-      const subagentHooksMap = /* @__PURE__ */ new Map();
-      for (const s of options.subagents) {
-        if (s.hooks) subagentHooksMap.set(s.agentName, s.hooks);
-      }
-      const resolveSubagentName = (args) => args.subagent;
-      toolMap.set(SUBAGENT_TOOL_NAME, {
-        ...createSubagentTool(options.subagents),
-        handler: createSubagentHandler(options.subagents),
-        ...subagentHooksMap.size > 0 && {
-          hooks: {
-            onPreToolUse: async (ctx) => {
-              const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
-              return hooks?.onPreExecution?.(ctx) ?? {};
-            },
-            onPostToolUse: async (ctx) => {
-              const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
-              await hooks?.onPostExecution?.(ctx);
-            },
-            onPostToolUseFailure: async (ctx) => {
-              const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
-              return hooks?.onExecutionFailure?.(ctx) ?? {};
-            }
-          }
-        }
-      });
+  if (options.plugins) {
+    for (const plugin of options.plugins) {
+      toolMap.set(plugin.name, plugin);
     }
   }
-  if (options.skills && options.skills.length > 0) {
-    toolMap.set(READ_SKILL_TOOL_NAME, {
-      ...createReadSkillTool(options.skills),
-      handler: createReadSkillHandler(options.skills)
-    });
-  }
-  async function processToolCall(toolCall, turn, handlerContext) {
-    const startTime = Date.now();
-    const tool = toolMap.get(toolCall.name);
-    const toolHooks = tool?.hooks;
+  async function runPreHooks(toolCall, tool, turn) {
     let effectiveArgs = toolCall.args;
     if (options.hooks?.onPreToolUse) {
       const preResult = await options.hooks.onPreToolUse({
@@ -200,58 +25,105 @@ function createToolRouter(options) {
         threadId: options.threadId,
         turn
       });
-      if (preResult?.skip) {
-        await appendToolResult({
-          threadId: options.threadId,
-          toolCallId: toolCall.id,
-          toolName: toolCall.name,
-          content: JSON.stringify({
-            skipped: true,
-            reason: "Skipped by PreToolUse hook"
-          })
-        });
-        return null;
-      }
-      if (preResult?.modifiedArgs !== void 0) {
+      if (preResult?.skip) return { skip: true };
+      if (preResult?.modifiedArgs !== void 0)
         effectiveArgs = preResult.modifiedArgs;
-      }
     }
-    if (toolHooks?.onPreToolUse) {
-      const preResult = await toolHooks.onPreToolUse({
+    if (tool?.hooks?.onPreToolUse) {
+      const preResult = await tool.hooks.onPreToolUse({
         args: effectiveArgs,
         threadId: options.threadId,
         turn
       });
-      if (preResult?.skip) {
-        await appendToolResult({
-          threadId: options.threadId,
-          toolCallId: toolCall.id,
-          toolName: toolCall.name,
-          content: JSON.stringify({
-            skipped: true,
-            reason: "Skipped by tool PreToolUse hook"
-          })
-        });
-        return null;
-      }
-      if (preResult?.modifiedArgs !== void 0) {
+      if (preResult?.skip) return { skip: true };
+      if (preResult?.modifiedArgs !== void 0)
         effectiveArgs = preResult.modifiedArgs;
-      }
     }
+    return { skip: false, args: effectiveArgs };
+  }
+  async function runFailureHooks(toolCall, tool, error, effectiveArgs, turn) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const errorStr = String(error);
+    if (tool?.hooks?.onPostToolUseFailure) {
+      const r = await tool.hooks.onPostToolUseFailure({
+        args: effectiveArgs,
+        error: err,
+        threadId: options.threadId,
+        turn
+      });
+      if (r?.fallbackContent !== void 0)
+        return { content: r.fallbackContent, result: { error: errorStr, recovered: true } };
+      if (r?.suppress)
+        return {
+          content: JSON.stringify({ error: errorStr, suppressed: true }),
+          result: { error: errorStr, suppressed: true }
+        };
+    }
+    if (options.hooks?.onPostToolUseFailure) {
+      const r = await options.hooks.onPostToolUseFailure({
+        toolCall,
+        error: err,
+        threadId: options.threadId,
+        turn
+      });
+      if (r?.fallbackContent !== void 0)
+        return { content: r.fallbackContent, result: { error: errorStr, recovered: true } };
+      if (r?.suppress)
+        return {
+          content: JSON.stringify({ error: errorStr, suppressed: true }),
+          result: { error: errorStr, suppressed: true }
+        };
+    }
+    throw ApplicationFailure.fromError(error, { nonRetryable: true });
+  }
+  async function runPostHooks(toolCall, tool, toolResult, effectiveArgs, turn, durationMs) {
+    if (tool?.hooks?.onPostToolUse) {
+      await tool.hooks.onPostToolUse({
+        args: effectiveArgs,
+        result: toolResult.data,
+        threadId: options.threadId,
+        turn,
+        durationMs
+      });
+    }
+    if (options.hooks?.onPostToolUse) {
+      await options.hooks.onPostToolUse({
+        toolCall,
+        result: toolResult,
+        threadId: options.threadId,
+        turn,
+        durationMs
+      });
+    }
+  }
+  async function processToolCall(toolCall, turn, sandboxId) {
+    const startTime = Date.now();
+    const tool = toolMap.get(toolCall.name);
+    const preResult = await runPreHooks(toolCall, tool, turn);
+    if (preResult.skip) {
+      await appendToolResult({
+        threadId: options.threadId,
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        content: JSON.stringify({ skipped: true, reason: "Skipped by PreToolUse hook" })
+      });
+      return null;
+    }
+    const effectiveArgs = preResult.args;
     let result;
     let content;
     let resultAppended = false;
     try {
       if (tool) {
-        const enrichedContext = {
-          ...handlerContext ?? {},
+        const routerContext = {
           threadId: options.threadId,
           toolCallId: toolCall.id,
-          toolName: toolCall.name
+          toolName: toolCall.name,
+          ...sandboxId !== void 0 && { sandboxId }
         };
         const response = await tool.handler(
           effectiveArgs,
-          enrichedContext
+          routerContext
         );
         result = response.data;
         content = response.toolResponse;
@@ -261,47 +133,9 @@ function createToolRouter(options) {
         content = JSON.stringify(result, null, 2);
       }
     } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      let recovered = false;
-      if (toolHooks?.onPostToolUseFailure) {
-        const failureResult = await toolHooks.onPostToolUseFailure({
-          args: effectiveArgs,
-          error: err,
-          threadId: options.threadId,
-          turn
-        });
-        if (failureResult?.fallbackContent !== void 0) {
-          content = failureResult.fallbackContent;
-          result = { error: String(error), recovered: true };
-          recovered = true;
-        } else if (failureResult?.suppress) {
-          content = JSON.stringify({ error: String(error), suppressed: true });
-          result = { error: String(error), suppressed: true };
-          recovered = true;
-        }
-      }
-      if (!recovered && options.hooks?.onPostToolUseFailure) {
-        const failureResult = await options.hooks.onPostToolUseFailure({
-          toolCall,
-          error: err,
-          threadId: options.threadId,
-          turn
-        });
-        if (failureResult?.fallbackContent !== void 0) {
-          content = failureResult.fallbackContent;
-          result = { error: String(error), recovered: true };
-          recovered = true;
-        } else if (failureResult?.suppress) {
-          content = JSON.stringify({ error: String(error), suppressed: true });
-          result = { error: String(error), suppressed: true };
-          recovered = true;
-        }
-      }
-      if (!recovered) {
-        throw ApplicationFailure.fromError(error, {
-          nonRetryable: true
-        });
-      }
+      const recovery = await runFailureHooks(toolCall, tool, error, effectiveArgs, turn);
+      result = recovery.result;
+      content = recovery.content;
     }
     if (!resultAppended) {
       await appendToolResult({
@@ -316,29 +150,10 @@ function createToolRouter(options) {
       name: toolCall.name,
       data: result
     };
-    const durationMs = Date.now() - startTime;
-    if (toolHooks?.onPostToolUse) {
-      await toolHooks.onPostToolUse({
-        args: effectiveArgs,
-        result,
-        threadId: options.threadId,
-        turn,
-        durationMs
-      });
-    }
-    if (options.hooks?.onPostToolUse) {
-      await options.hooks.onPostToolUse({
-        toolCall,
-        result: toolResult,
-        threadId: options.threadId,
-        turn,
-        durationMs
-      });
-    }
+    await runPostHooks(toolCall, tool, toolResult, effectiveArgs, turn, Date.now() - startTime);
     return toolResult;
   }
   return {
-    // --- Methods from registry ---
     hasTools() {
       return Array.from(toolMap.values()).some(isEnabled);
     },
@@ -362,32 +177,25 @@ function createToolRouter(options) {
       return Array.from(toolMap.entries()).filter(([, tool]) => isEnabled(tool)).map(([name]) => name);
     },
     getToolDefinitions() {
-      const activeSubagents = options.subagents?.filter((subagent) => isEnabled(subagent)) ?? [];
-      const activeSkills = options.skills ?? [];
-      return [
-        ...Array.from(toolMap).filter(
-          ([, tool]) => isEnabled(tool) && tool.name !== SUBAGENT_TOOL_NAME && tool.name !== READ_SKILL_TOOL_NAME
-        ).map(([name, tool]) => ({
-          name,
-          description: tool.description,
-          schema: tool.schema,
-          strict: tool.strict,
-          max_uses: tool.max_uses
-        })),
-        ...activeSubagents.length > 0 ? [createSubagentTool(activeSubagents)] : [],
-        ...activeSkills.length > 0 ? [createReadSkillTool(activeSkills)] : []
-      ];
+      return Array.from(toolMap).filter(([, tool]) => isEnabled(tool)).map(([name, tool]) => ({
+        name,
+        description: tool.description,
+        schema: tool.schema,
+        strict: tool.strict,
+        max_uses: tool.max_uses
+      }));
     },
-    // --- Methods for processing tool calls ---
     async processToolCalls(toolCalls, context) {
       if (toolCalls.length === 0) {
         return [];
       }
       const turn = context?.turn ?? 0;
-      const handlerContext = context?.handlerContext;
+      const sandboxId = context?.sandboxId;
       if (options.parallel) {
         const results2 = await Promise.all(
-          toolCalls.map((tc) => processToolCall(tc, turn, handlerContext))
+          toolCalls.map(
+            (tc) => processToolCall(tc, turn, sandboxId)
+          )
         );
         return results2.filter(
           (r) => r !== null
@@ -395,7 +203,11 @@ function createToolRouter(options) {
       }
       const results = [];
       for (const toolCall of toolCalls) {
-        const result = await processToolCall(toolCall, turn, handlerContext);
+        const result = await processToolCall(
+          toolCall,
+          turn,
+          sandboxId
+        );
         if (result !== null) {
           results.push(result);
         }
@@ -407,17 +219,16 @@ function createToolRouter(options) {
       if (matchingCalls.length === 0) {
         return [];
       }
-      const handlerContext = context?.handlerContext ?? {};
       const processOne = async (toolCall) => {
-        const enrichedContext = {
-          ...handlerContext ?? {},
+        const routerContext = {
           threadId: options.threadId,
           toolCallId: toolCall.id,
-          toolName: toolCall.name
+          toolName: toolCall.name,
+          ...context?.sandboxId !== void 0 && { sandboxId: context.sandboxId }
         };
         const response = await handler(
           toolCall.args,
-          enrichedContext
+          routerContext
         );
         if (!response.resultAppended) {
           await appendToolResult({
@@ -433,59 +244,232 @@ function createToolRouter(options) {
           data: response.data
         };
       };
-      if (options.parallel) {
-        return Promise.all(matchingCalls.map(processOne));
-      }
-      const results = [];
-      for (const toolCall of matchingCalls) {
-        results.push(await processOne(toolCall));
-      }
-      return results;
+      if (options.parallel) {
+        return Promise.all(matchingCalls.map(processOne));
+      }
+      const results = [];
+      for (const toolCall of matchingCalls) {
+        results.push(await processOne(toolCall));
+      }
+      return results;
+    },
+    filterByName(toolCalls, name) {
+      return toolCalls.filter(
+        (tc) => tc.name === name
+      );
+    },
+    hasToolCall(toolCalls, name) {
+      return toolCalls.some((tc) => tc.name === name);
+    },
+    getResultsByName(results, name) {
+      return results.filter((r) => r.name === name);
+    }
+  };
+}
+function defineTool(tool) {
+  return tool;
+}
+function hasNoOtherToolCalls(toolCalls, excludeName) {
+  return toolCalls.filter((tc) => tc.name !== excludeName).length === 0;
+}
+var BASE62 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function getShortId(length = 12) {
+  const hex = uuid4().replace(/-/g, "");
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    const byte = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    result += BASE62[byte % BASE62.length];
+  }
+  return result;
+}
+var SUBAGENT_TOOL_NAME = "Subagent";
+function buildSubagentDescription(subagents) {
+  const subagentList = subagents.map((s) => {
+    const continuation = s.allowThreadContinuation ? "\n*(Supports thread continuation \u2014 pass a threadId to resume a previous conversation)*" : "";
+    return `## ${s.agentName}
+${s.description}${continuation}`;
+  }).join("\n\n");
+  return `The ${SUBAGENT_TOOL_NAME} tool launches specialized agents (subagents) that autonomously handle complex work. Each agent type has specific capabilities and tools available to it.
+
+# Available subagents:
+${subagentList}
+`;
+}
+function createSubagentTool(subagents) {
+  if (subagents.length === 0) {
+    throw new Error("createSubagentTool requires at least one subagent");
+  }
+  const names = subagents.map((s) => s.agentName);
+  const hasThreadContinuation = subagents.some(
+    (s) => s.allowThreadContinuation
+  );
+  const baseFields = {
+    subagent: z14.enum(names).describe("The type of subagent to launch"),
+    description: z14.string().describe("A short (3-5 word) description of the task"),
+    prompt: z14.string().describe("The task for the agent to perform")
+  };
+  const schema = hasThreadContinuation ? z14.object({
+    ...baseFields,
+    threadId: z14.string().nullable().describe(
+      "Thread ID to continue an existing conversation, or null to start a new one"
+    )
+  }) : z14.object(baseFields);
+  return {
+    name: SUBAGENT_TOOL_NAME,
+    description: buildSubagentDescription(subagents),
+    schema
+  };
+}
+function createSubagentHandler(subagents) {
+  const { taskQueue: parentTaskQueue } = workflowInfo();
+  return async (args, context) => {
+    const config = subagents.find((s) => s.agentName === args.subagent);
+    if (!config) {
+      throw new Error(
+        `Unknown subagent: ${args.subagent}. Available: ${subagents.map((s) => s.agentName).join(", ")}`
+      );
+    }
+    const childWorkflowId = `${args.subagent}-${getShortId()}`;
+    const { sandboxId: parentSandboxId } = context;
+    const inheritSandbox = config.sandbox !== "own" && !!parentSandboxId;
+    const input = {
+      prompt: args.prompt,
+      ...config.context && { context: config.context },
+      ...args.threadId && args.threadId !== null && config.allowThreadContinuation && { previousThreadId: args.threadId },
+      ...inheritSandbox && { sandboxId: parentSandboxId }
+    };
+    const childOpts = {
+      workflowId: childWorkflowId,
+      args: [input],
+      taskQueue: config.taskQueue ?? parentTaskQueue
+    };
+    const {
+      toolResponse,
+      data,
+      usage,
+      threadId: childThreadId
+    } = typeof config.workflow === "string" ? await executeChild(config.workflow, childOpts) : await executeChild(config.workflow, childOpts);
+    if (!toolResponse) {
+      return {
+        toolResponse: "Subagent workflow returned no response",
+        data: null,
+        ...usage && { usage }
+      };
+    }
+    const validated = config.resultSchema ? config.resultSchema.safeParse(data) : null;
+    if (validated && !validated.success) {
+      return {
+        toolResponse: `Subagent workflow returned invalid data: ${validated.error.message}`,
+        data: null,
+        ...usage && { usage }
+      };
+    }
+    let finalToolResponse = toolResponse;
+    if (config.allowThreadContinuation && childThreadId) {
+      finalToolResponse = typeof toolResponse === "string" ? `${toolResponse}
+
+[Thread ID: ${childThreadId}]` : toolResponse;
+    }
+    return {
+      toolResponse: finalToolResponse,
+      data: validated ? validated.data : data,
+      ...usage && { usage }
+    };
+  };
+}
+
+// src/lib/subagent/register.ts
+function buildSubagentRegistration(subagents) {
+  if (subagents.length === 0) return null;
+  const getEnabled = () => subagents.filter((s) => s.enabled ?? true);
+  const subagentHooksMap = /* @__PURE__ */ new Map();
+  for (const s of subagents) {
+    if (s.hooks) subagentHooksMap.set(s.agentName, s.hooks);
+  }
+  const resolveSubagentName = (args) => args.subagent;
+  return {
+    name: SUBAGENT_TOOL_NAME,
+    get enabled() {
+      return getEnabled().length > 0;
     },
-    // --- Utility methods ---
-    filterByName(toolCalls, name) {
-      return toolCalls.filter(
-        (tc) => tc.name === name
-      );
+    get description() {
+      return createSubagentTool(getEnabled()).description;
     },
-    hasToolCall(toolCalls, name) {
-      return toolCalls.some((tc) => tc.name === name);
+    get schema() {
+      return createSubagentTool(getEnabled()).schema;
     },
-    getResultsByName(results, name) {
-      return results.filter((r) => r.name === name);
+    handler: createSubagentHandler(subagents),
+    ...subagentHooksMap.size > 0 && {
+      hooks: {
+        onPreToolUse: async (ctx) => {
+          const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
+          return hooks?.onPreExecution?.(ctx) ?? {};
+        },
+        onPostToolUse: async (ctx) => {
+          const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
+          await hooks?.onPostExecution?.(ctx);
+        },
+        onPostToolUseFailure: async (ctx) => {
+          const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
+          return hooks?.onExecutionFailure?.(ctx) ?? {};
+        }
+      }
     }
   };
 }
-function withAutoAppend(threadHandler, handler) {
-  return async (args, context) => {
-    const response = await handler(args, context);
-    const threadId = context.threadId;
-    const toolCallId = context.toolCallId;
-    const toolName = context.toolName;
-    await threadHandler({
-      threadId,
-      toolCallId,
-      toolName,
-      content: response.toolResponse
-    });
+var READ_SKILL_TOOL_NAME = "ReadSkill";
+function buildReadSkillDescription(skills) {
+  const skillList = skills.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+  return `Load the full instructions for a skill. Read the skill before following its instructions.
+
+# Available skills:
+${skillList}
+`;
+}
+function createReadSkillTool(skills) {
+  if (skills.length === 0) {
+    throw new Error("createReadSkillTool requires at least one skill");
+  }
+  const names = skills.map((s) => s.name);
+  return {
+    name: READ_SKILL_TOOL_NAME,
+    description: buildReadSkillDescription(skills),
+    schema: z14.object({
+      skill_name: z14.enum(names).describe("The name of the skill to load")
+    })
+  };
+}
+
+// src/lib/skills/handler.ts
+function createReadSkillHandler(skills) {
+  const skillMap = new Map(skills.map((s) => [s.name, s]));
+  return (args) => {
+    const skill = skillMap.get(args.skill_name);
+    if (!skill) {
+      return {
+        toolResponse: JSON.stringify({
+          error: `Skill "${args.skill_name}" not found`
+        }),
+        data: null
+      };
+    }
     return {
-      toolResponse: "Response appended via withAutoAppend",
-      data: response.data,
-      resultAppended: true
+      toolResponse: skill.instructions,
+      data: null
     };
   };
 }
-function defineTool(tool) {
-  return tool;
-}
-function defineSubagent(config) {
-  return config;
-}
-function hasNoOtherToolCalls(toolCalls, excludeName) {
-  return toolCalls.filter((tc) => tc.name !== excludeName).length === 0;
+
+// src/lib/skills/register.ts
+function buildSkillRegistration(skills) {
+  if (skills.length === 0) return null;
+  return {
+    ...createReadSkillTool(skills),
+    handler: createReadSkillHandler(skills)
+  };
 }
 
-// src/lib/session.ts
+// src/lib/session/session.ts
 var createSession = async ({
   threadId: providedThreadId,
   agentName,
@@ -501,22 +485,34 @@ var createSession = async ({
   hooks = {},
   appendSystemPrompt = true,
   continueThread = false,
-  waitForInputTimeout = "48h"
+  waitForInputTimeout = "48h",
+  sandbox: sandboxOps,
+  sandboxId: inheritedSandboxId
 }) => {
-  const threadId = providedThreadId ?? getShortId();
+  const sourceThreadId = continueThread ? providedThreadId : void 0;
+  const threadId = continueThread && providedThreadId ? getShortId() : providedThreadId ?? getShortId();
   const {
     appendToolResult,
     appendHumanMessage,
     initializeThread,
-    appendSystemMessage
+    appendSystemMessage,
+    forkThread
   } = threadOps ?? proxyDefaultThreadOps();
+  const plugins = [];
+  if (subagents) {
+    const reg = buildSubagentRegistration(subagents);
+    if (reg) plugins.push(reg);
+  }
+  if (skills) {
+    const reg = buildSkillRegistration(skills);
+    if (reg) plugins.push(reg);
+  }
   const toolRouter = createToolRouter({
     tools,
     appendToolResult,
     threadId,
     hooks,
-    subagents,
-    skills,
+    plugins,
     parallel: processToolsInParallel
   });
   const callSessionEnd = async (exitReason, turns) => {
@@ -553,6 +549,17 @@ var createSession = async ({
           stateManager.run();
         }
       );
+      let sandboxId = inheritedSandboxId;
+      const ownsSandbox = !sandboxId && !!sandboxOps;
+      if (ownsSandbox) {
+        const result = await sandboxOps.createSandbox({ id: threadId });
+        sandboxId = result.sandboxId;
+        if (result.stateUpdate) {
+          stateManager.mergeUpdate(
+            result.stateUpdate
+          );
+        }
+      }
       if (hooks.onSessionStart) {
         await hooks.onSessionStart({
           threadId,
@@ -561,7 +568,9 @@ var createSession = async ({
         });
       }
       const systemPrompt = stateManager.getSystemPrompt();
-      if (!continueThread) {
+      if (continueThread && sourceThreadId) {
+        await forkThread(sourceThreadId, threadId);
+      } else {
         if (appendSystemPrompt) {
           if (!systemPrompt || systemPrompt.trim() === "") {
             throw ApplicationFailure.create({
@@ -593,6 +602,7 @@ var createSession = async ({
             stateManager.complete();
             exitReason = "completed";
             return {
+              threadId,
               finalMessage: message,
               exitReason,
               usage: stateManager.getTotalUsage()
@@ -616,7 +626,8 @@ var createSession = async ({
           const toolCallResults = await toolRouter.processToolCalls(
             parsedToolCalls,
             {
-              turn: currentTurn
+              turn: currentTurn,
+              ...sandboxId !== void 0 && { sandboxId }
             }
           );
           for (const result of toolCallResults) {
@@ -644,8 +655,12 @@ var createSession = async ({
         throw ApplicationFailure.fromError(error);
       } finally {
         await callSessionEnd(exitReason, stateManager.getTurns());
+        if (ownsSandbox && sandboxId && sandboxOps) {
+          await sandboxOps.destroySandbox(sandboxId);
+        }
       }
       return {
+        threadId,
         finalMessage: null,
         exitReason,
         usage: stateManager.getTotalUsage()
@@ -666,16 +681,109 @@ function proxyDefaultThreadOps(options) {
     }
   );
 }
+function proxySandboxOps(options) {
+  return proxyActivities(
+    options ?? {
+      startToCloseTimeout: "30s",
+      retry: {
+        maximumAttempts: 3,
+        initialInterval: "2s",
+        maximumInterval: "30s",
+        backoffCoefficient: 2
+      }
+    }
+  );
+}
+
+// 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
+end
+for i = 2, #ARGV do
+  redis.call('RPUSH', KEYS[2], ARGV[i])
+end
+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 `thread:${threadId}:${key}`;
+}
+function createThreadManager(config) {
+  const {
+    redis,
+    threadId,
+    key = "messages",
+    serialize = (m) => JSON.stringify(m),
+    deserialize = (raw) => JSON.parse(raw),
+    idOf
+  } = config;
+  const redisKey = getThreadKey(threadId, key);
+  const metaKey = getThreadKey(threadId, `${key}:meta`);
+  async function assertThreadExists() {
+    const exists = await redis.exists(metaKey);
+    if (!exists) {
+      throw new Error(`Thread "${threadId}" (key: ${key}) does not exist`);
+    }
+  }
+  return {
+    async initialize() {
+      await redis.del(redisKey);
+      await redis.set(metaKey, "1", "EX", THREAD_TTL_SECONDS);
+    },
+    async load() {
+      await assertThreadExists();
+      const data = await redis.lrange(redisKey, 0, -1);
+      return data.map(deserialize);
+    },
+    async append(messages) {
+      if (messages.length === 0) return;
+      await assertThreadExists();
+      if (idOf) {
+        const dedupId = messages.map(idOf).join(":");
+        const dedupKey = getThreadKey(threadId, `dedup:${dedupId}`);
+        await redis.eval(
+          APPEND_IDEMPOTENT_SCRIPT,
+          2,
+          dedupKey,
+          redisKey,
+          String(THREAD_TTL_SECONDS),
+          ...messages.map(serialize)
+        );
+      } else {
+        await redis.rpush(redisKey, ...messages.map(serialize));
+        await redis.expire(redisKey, THREAD_TTL_SECONDS);
+      }
+    },
+    async fork(newThreadId) {
+      await assertThreadExists();
+      const data = await redis.lrange(redisKey, 0, -1);
+      const forked = createThreadManager({
+        ...config,
+        threadId: newThreadId
+      });
+      await forked.initialize();
+      if (data.length > 0) {
+        const newKey = getThreadKey(newThreadId, key);
+        await redis.rpush(newKey, ...data);
+        await redis.expire(newKey, THREAD_TTL_SECONDS);
+      }
+      return forked;
+    },
+    async delete() {
+      await redis.del(redisKey, metaKey);
+    }
+  };
+}
 
 // src/lib/types.ts
-var agentQueryName = (agentName) => `get${agentName}State`;
-var agentStateChangeUpdateName = (agentName) => `waitFor${agentName}StateChange`;
 function isTerminalStatus(status) {
   return status === "COMPLETED" || status === "FAILED" || status === "CANCELLED";
 }
 function createAgentStateManager({
-  initialState,
-  agentName
+  initialState
 }) {
   let status = initialState?.status ?? "RUNNING";
   let version = initialState?.version ?? 0;
@@ -706,11 +814,9 @@ function createAgentStateManager({
       ...customState
     };
   }
-  const stateQuery = defineQuery(
-    agentQueryName(agentName)
-  );
+  const stateQuery = defineQuery("getAgentState");
   const stateChangeUpdate = defineUpdate(
-    agentStateChangeUpdateName(agentName)
+    "waitForAgentStateChange"
   );
   setHandler(stateQuery, () => buildState());
   setHandler(stateChangeUpdate, async (lastKnownVersion) => {
@@ -774,6 +880,10 @@ function createAgentStateManager({
       customState[key] = value;
       version++;
     },
+    mergeUpdate(update) {
+      Object.assign(customState, update);
+      version++;
+    },
     getCurrentState() {
       return buildState();
     },
@@ -829,6 +939,127 @@ function createAgentStateManager({
   };
 }
 
+// src/lib/tool-router/auto-append.ts
+function withAutoAppend(threadHandler, handler) {
+  return async (args, context) => {
+    const response = await handler(args, context);
+    await threadHandler({
+      threadId: context.threadId,
+      toolCallId: context.toolCallId,
+      toolName: context.toolName,
+      content: response.toolResponse
+    });
+    return {
+      toolResponse: "Response appended via withAutoAppend",
+      data: response.data,
+      resultAppended: true
+    };
+  };
+}
+
+// src/lib/tool-router/with-sandbox.ts
+function withSandbox(manager, handler) {
+  return async (args, context) => {
+    if (!context.sandboxId) {
+      return {
+        toolResponse: `Error: No sandbox configured for this agent. The ${context.toolName} tool requires a sandbox.`,
+        data: null
+      };
+    }
+    const sandbox = await manager.getSandbox(context.sandboxId);
+    return handler(args, { ...context, sandbox, sandboxId: context.sandboxId });
+  };
+}
+
+// src/lib/subagent/define.ts
+function defineSubagent(config) {
+  return config;
+}
+var SandboxNotSupportedError = class extends ApplicationFailure$1 {
+  constructor(operation) {
+    super(
+      `Sandbox does not support: ${operation}`,
+      "SandboxNotSupportedError",
+      true
+    );
+  }
+};
+var SandboxNotFoundError = class extends ApplicationFailure$1 {
+  constructor(sandboxId) {
+    super(`Sandbox not found: ${sandboxId}`, "SandboxNotFoundError", true);
+  }
+};
+
+// src/adapters/sandbox/virtual/mutations.ts
+function applyVirtualTreeMutations(stateManager, mutations) {
+  let tree = [...stateManager.get("fileTree")];
+  for (const m of mutations) {
+    switch (m.type) {
+      case "add":
+        tree.push(m.entry);
+        break;
+      case "remove":
+        tree = tree.filter((e) => e.path !== m.path);
+        break;
+      case "update":
+        tree = tree.map(
+          (e) => e.path === m.path ? { ...e, ...m.entry } : e
+        );
+        break;
+    }
+  }
+  stateManager.set("fileTree", tree);
+  return tree;
+}
+
+// src/adapters/sandbox/virtual/tree.ts
+var buildTree = (entries) => {
+  const root = { name: "/", children: /* @__PURE__ */ new Map(), isFile: false };
+  for (const entry of entries) {
+    const parts = entry.path.split("/").filter(Boolean);
+    let current = root;
+    for (const part of parts) {
+      let child = current.children.get(part);
+      if (!child) {
+        child = { name: part, children: /* @__PURE__ */ new Map(), isFile: false };
+        current.children.set(part, child);
+      }
+      current = child;
+    }
+    current.isFile = current.children.size === 0;
+  }
+  return root;
+};
+var printNode = (node, tab, sort) => {
+  const entries = [...node.children.values()];
+  if (sort) {
+    entries.sort((a, b) => {
+      if (!a.isFile && !b.isFile) return a.name.localeCompare(b.name);
+      if (!a.isFile) return -1;
+      if (!b.isFile) return 1;
+      return a.name.localeCompare(b.name);
+    });
+  }
+  let str = "";
+  for (const [i, entry] of entries.entries()) {
+    const isLast = i === entries.length - 1;
+    const branch = isLast ? "\u2514\u2500" : "\u251C\u2500";
+    const childTab = tab + (isLast ? "   " : "\u2502  ");
+    if (entry.isFile) {
+      str += "\n" + tab + branch + " " + entry.name;
+    } else {
+      const subtree = printNode(entry, childTab, sort);
+      str += "\n" + tab + branch + " " + entry.name + "/" + subtree;
+    }
+  }
+  return str;
+};
+function formatVirtualFileTree(entries, opts = {}) {
+  const sort = opts.sort ?? true;
+  const root = buildTree(entries);
+  return "/" + printNode(root, "", sort);
+}
+
 // src/lib/skills/parse.ts
 function parseSkillFile(raw) {
   const trimmed = raw.replace(/^\uFEFF/, "");
@@ -1250,197 +1481,313 @@ var createAskUserQuestionHandler = () => async (args) => {
     data: { questions: args.questions }
   };
 };
-
-// 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
-end
-for i = 2, #ARGV do
-  redis.call('RPUSH', KEYS[2], ARGV[i])
-end
-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 `thread:${threadId}:${key}`;
-}
-function createThreadManager(config) {
-  const {
-    redis,
-    threadId,
-    key = "messages",
-    serialize = (m) => JSON.stringify(m),
-    deserialize = (raw) => JSON.parse(raw),
-    idOf
-  } = config;
-  const redisKey = getThreadKey(threadId, key);
-  const metaKey = getThreadKey(threadId, `${key}:meta`);
-  async function assertThreadExists() {
-    const exists = await redis.exists(metaKey);
-    if (!exists) {
-      throw new Error(`Thread "${threadId}" (key: ${key}) does not exist`);
+var FileSystemSkillProvider = class {
+  constructor(fs, baseDir) {
+    this.fs = fs;
+    this.baseDir = baseDir;
+  }
+  async listSkills() {
+    const dirs = await this.discoverSkillDirs();
+    const skills = [];
+    for (const dir of dirs) {
+      const raw = await this.fs.readFile(join(this.baseDir, dir, "SKILL.md"));
+      const { frontmatter } = parseSkillFile(raw);
+      skills.push(frontmatter);
     }
+    return skills;
   }
-  return {
-    async initialize() {
-      await redis.del(redisKey);
-      await redis.set(metaKey, "1", "EX", THREAD_TTL_SECONDS);
-    },
-    async load() {
-      await assertThreadExists();
-      const data = await redis.lrange(redisKey, 0, -1);
-      return data.map(deserialize);
-    },
-    async append(messages) {
-      if (messages.length === 0) return;
-      await assertThreadExists();
-      if (idOf) {
-        const dedupId = messages.map(idOf).join(":");
-        const dedupKey = getThreadKey(threadId, `dedup:${dedupId}`);
-        await redis.eval(
-          APPEND_IDEMPOTENT_SCRIPT,
-          2,
-          dedupKey,
-          redisKey,
-          String(THREAD_TTL_SECONDS),
-          ...messages.map(serialize)
-        );
-      } else {
-        await redis.rpush(redisKey, ...messages.map(serialize));
-        await redis.expire(redisKey, THREAD_TTL_SECONDS);
+  async getSkill(name) {
+    const raw = await this.fs.readFile(
+      join(this.baseDir, name, "SKILL.md")
+    );
+    const { frontmatter, body } = parseSkillFile(raw);
+    if (frontmatter.name !== name) {
+      throw new Error(
+        `Skill directory "${name}" contains SKILL.md with mismatched name "${frontmatter.name}"`
+      );
+    }
+    return { ...frontmatter, instructions: body };
+  }
+  /**
+   * Convenience method to load all skills with full instructions.
+   * Returns `Skill[]` ready to pass into a workflow.
+   */
+  async loadAll() {
+    const dirs = await this.discoverSkillDirs();
+    const skills = [];
+    for (const dir of dirs) {
+      const raw = await this.fs.readFile(join(this.baseDir, dir, "SKILL.md"));
+      const { frontmatter, body } = parseSkillFile(raw);
+      skills.push({ ...frontmatter, instructions: body });
+    }
+    return skills;
+  }
+  async discoverSkillDirs() {
+    const entries = await this.fs.readdirWithFileTypes(this.baseDir);
+    const dirs = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory) continue;
+      const skillPath = join(this.baseDir, entry.name, "SKILL.md");
+      if (await this.fs.exists(skillPath)) {
+        dirs.push(entry.name);
       }
-    },
-    async delete() {
-      await redis.del(redisKey, metaKey);
     }
-  };
-}
-async function queryParentWorkflowState(client, queryName) {
+    return dirs;
+  }
+};
+async function queryParentWorkflowState(client) {
   const { workflowExecution } = Context.current().info;
   const handle = client.getHandle(
     workflowExecution.workflowId,
     workflowExecution.runId
   );
-  return handle.query(queryName);
+  return handle.query("getAgentState");
 }
-function createRunAgentActivity(client, invoker) {
+function createRunAgentActivity(client, handler) {
   return async (config) => {
-    const state = await queryParentWorkflowState(
-      client,
-      agentQueryName(config.agentName)
-    );
-    return invoker({ ...config, state });
+    const state = await queryParentWorkflowState(client);
+    return handler({ ...config, state });
   };
 }
-function createGlobHandler(fs) {
-  return async (_args) => {
-    new Bash({ fs });
-    return {
-      toolResponse: "Hello, world!",
-      data: { files: [] }
-    };
+function withParentWorkflowState(client, handler) {
+  return async (args, context) => {
+    const state = await queryParentWorkflowState(client);
+    return handler(args, { ...context, state });
   };
 }
 
+// src/lib/sandbox/manager.ts
+var SandboxManager = class {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async create(options) {
+    const { sandbox, stateUpdate } = await this.provider.create(options);
+    return { sandboxId: sandbox.id, ...stateUpdate && { stateUpdate } };
+  }
+  async getSandbox(id) {
+    return this.provider.get(id);
+  }
+  async destroy(id) {
+    await this.provider.destroy(id);
+  }
+  async snapshot(id) {
+    return this.provider.snapshot(id);
+  }
+  async restore(snapshot) {
+    const sandbox = await this.provider.restore(snapshot);
+    return sandbox.id;
+  }
+  /**
+   * Returns Temporal activity functions matching {@link SandboxOps}.
+   * Spread these into your worker's activity map.
+   */
+  createActivities() {
+    return {
+      createSandbox: async (options) => {
+        return this.create(options);
+      },
+      destroySandbox: async (sandboxId) => {
+        await this.destroy(sandboxId);
+      },
+      snapshotSandbox: async (sandboxId) => {
+        return this.snapshot(sandboxId);
+      }
+    };
+  }
+};
+
+// src/tools/bash/handler.ts
+var bashHandler = async (args, { sandbox }) => {
+  try {
+    const result = await sandbox.exec(args.command);
+    return {
+      toolResponse: `Exit code: ${result.exitCode}
+
+stdout:
+${result.stdout}
+
+stderr:
+${result.stderr}`,
+      data: result
+    };
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error("Unknown error");
+    return {
+      toolResponse: `Error executing bash command: ${err.message}`,
+      data: null
+    };
+  }
+};
+
 // src/tools/edit/handler.ts
 function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function createEditHandler(fs) {
-  return async (args) => {
-    const { file_path, old_string, new_string, replace_all = false } = args;
-    if (old_string === new_string) {
+var editHandler = async (args, { sandbox }) => {
+  const { fs } = sandbox;
+  const { file_path, old_string, new_string, replace_all = false } = args;
+  if (old_string === new_string) {
+    return {
+      toolResponse: `Error: old_string and new_string must be different.`,
+      data: { path: file_path, success: false, replacements: 0 }
+    };
+  }
+  try {
+    const exists = await fs.exists(file_path);
+    if (!exists) {
       return {
-        toolResponse: `Error: old_string and new_string must be different.`,
+        toolResponse: `Error: File "${file_path}" does not exist.`,
         data: { path: file_path, success: false, replacements: 0 }
       };
     }
-    try {
-      const exists = await fs.exists(file_path);
-      if (!exists) {
-        return {
-          toolResponse: `Error: File "${file_path}" does not exist.`,
-          data: { path: file_path, success: false, replacements: 0 }
-        };
-      }
-      const content = await fs.readFile(file_path);
-      if (!content.includes(old_string)) {
-        return {
-          toolResponse: `Error: Could not find the specified text in "${file_path}". Make sure old_string matches exactly (whitespace-sensitive).`,
-          data: { path: file_path, success: false, replacements: 0 }
-        };
-      }
-      const escapedOldString = escapeRegExp(old_string);
-      const globalRegex = new RegExp(escapedOldString, "g");
-      const occurrences = (content.match(globalRegex) || []).length;
-      if (!replace_all && occurrences > 1) {
-        return {
-          toolResponse: `Error: old_string appears ${occurrences} times in "${file_path}". Either provide more context to make it unique, or use replace_all: true.`,
-          data: { path: file_path, success: false, replacements: 0 }
-        };
-      }
-      let newContent;
-      let replacements;
-      if (replace_all) {
-        newContent = content.split(old_string).join(new_string);
-        replacements = occurrences;
-      } else {
-        const index = content.indexOf(old_string);
-        newContent = content.slice(0, index) + new_string + content.slice(index + old_string.length);
-        replacements = 1;
-      }
-      await fs.writeFile(file_path, newContent);
-      const summary = replace_all ? `Replaced ${replacements} occurrence(s)` : `Replaced 1 occurrence`;
+    const content = await fs.readFile(file_path);
+    if (!content.includes(old_string)) {
       return {
-        toolResponse: `${summary} in ${file_path}`,
-        data: { path: file_path, success: true, replacements }
+        toolResponse: `Error: Could not find the specified text in "${file_path}". Make sure old_string matches exactly (whitespace-sensitive).`,
+        data: { path: file_path, success: false, replacements: 0 }
       };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
+    }
+    const escapedOldString = escapeRegExp(old_string);
+    const globalRegex = new RegExp(escapedOldString, "g");
+    const occurrences = (content.match(globalRegex) || []).length;
+    if (!replace_all && occurrences > 1) {
       return {
-        toolResponse: `Error editing file "${file_path}": ${message}`,
+        toolResponse: `Error: old_string appears ${occurrences} times in "${file_path}". Either provide more context to make it unique, or use replace_all: true.`,
         data: { path: file_path, success: false, replacements: 0 }
       };
     }
-  };
+    let newContent;
+    let replacements;
+    if (replace_all) {
+      newContent = content.split(old_string).join(new_string);
+      replacements = occurrences;
+    } else {
+      const index = content.indexOf(old_string);
+      newContent = content.slice(0, index) + new_string + content.slice(index + old_string.length);
+      replacements = 1;
+    }
+    await fs.writeFile(file_path, newContent);
+    const summary = replace_all ? `Replaced ${replacements} occurrence(s)` : `Replaced 1 occurrence`;
+    return {
+      toolResponse: `${summary} in ${file_path}`,
+      data: { path: file_path, success: true, replacements }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      toolResponse: `Error editing file "${file_path}": ${message}`,
+      data: { path: file_path, success: false, replacements: 0 }
+    };
+  }
+};
+
+// src/tools/glob/handler.ts
+function matchGlob(pattern, path) {
+  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  return new RegExp(`^${regex}$`).test(path);
 }
-var createBashHandler = (bashOptions) => async (args, _context) => {
-  const { command } = args;
-  const mergedOptions = {
-    ...bashOptions,
-    executionLimits: {
-      maxStringLength: 52428800,
-      // 50MB default
-      ...bashOptions.executionLimits
+async function walk(fs, dir) {
+  const results = [];
+  const entries = await fs.readdirWithFileTypes(dir);
+  for (const entry of entries) {
+    const full = dir === "/" ? `/${entry.name}` : `${dir}/${entry.name}`;
+    if (entry.isDirectory) {
+      results.push(...await walk(fs, full));
+    } else {
+      results.push(full);
     }
-  };
-  const bash = new Bash(mergedOptions);
+  }
+  return results;
+}
+var globHandler = async (args, { sandbox }) => {
+  const { fs } = sandbox;
+  const { pattern, root = "/" } = args;
   try {
-    const { exitCode, stderr, stdout } = await bash.exec(command);
-    const bashExecOut = { exitCode, stderr, stdout };
+    const allFiles = await walk(fs, root);
+    const relativeTo = root.endsWith("/") ? root : `${root}/`;
+    const matched = allFiles.map((f) => f.startsWith(relativeTo) ? f.slice(relativeTo.length) : f).filter((f) => matchGlob(pattern, f));
     return {
-      toolResponse: `Exit code: ${exitCode}
-
-stdout:
-${stdout}
+      toolResponse: matched.length > 0 ? `Found ${matched.length} file(s):
+${matched.join("\n")}` : `No files matched pattern "${pattern}"`,
+      data: { files: matched }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      toolResponse: `Error running glob: ${message}`,
+      data: { files: [] }
+    };
+  }
+};
 
-stderr:
-${stderr}`,
-      data: bashExecOut
+// src/tools/read-file/handler.ts
+var readFileHandler = async (args, { sandbox }) => {
+  const { fs } = sandbox;
+  const { path, offset, limit } = args;
+  try {
+    const exists = await fs.exists(path);
+    if (!exists) {
+      return {
+        toolResponse: `Error: File "${path}" does not exist.`,
+        data: null
+      };
+    }
+    const raw = await fs.readFile(path);
+    const lines = raw.split("\n");
+    const totalLines = lines.length;
+    if (offset !== void 0 || limit !== void 0) {
+      const start = Math.max(0, (offset ?? 1) - 1);
+      const end = limit !== void 0 ? start + limit : lines.length;
+      const slice = lines.slice(start, end);
+      const numbered2 = slice.map((line, i) => `${String(start + i + 1).padStart(6)}|${line}`).join("\n");
+      return {
+        toolResponse: numbered2,
+        data: { path, content: numbered2, totalLines }
+      };
+    }
+    const numbered = lines.map((line, i) => `${String(i + 1).padStart(6)}|${line}`).join("\n");
+    return {
+      toolResponse: numbered,
+      data: { path, content: numbered, totalLines }
     };
   } catch (error) {
-    const err = error instanceof Error ? error : new Error("Unknown error");
+    const message = error instanceof Error ? error.message : "Unknown error";
     return {
-      toolResponse: `Error executing bash command: ${err.message}`,
+      toolResponse: `Error reading file "${path}": ${message}`,
       data: null
     };
   }
 };
 
-// src/lib/fs.ts
+// src/tools/write-file/handler.ts
+var writeFileHandler = async (args, { sandbox }) => {
+  const { fs } = sandbox;
+  const { file_path, content } = args;
+  try {
+    const lastSlash = file_path.lastIndexOf("/");
+    if (lastSlash > 0) {
+      const dir = file_path.slice(0, lastSlash);
+      const dirExists = await fs.exists(dir);
+      if (!dirExists) {
+        await fs.mkdir(dir, { recursive: true });
+      }
+    }
+    await fs.writeFile(file_path, content);
+    return {
+      toolResponse: `Successfully wrote to ${file_path}`,
+      data: { path: file_path, success: true }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      toolResponse: `Error writing file "${file_path}": ${message}`,
+      data: { path: file_path, success: false }
+    };
+  }
+};
+
+// src/lib/sandbox/tree.ts
 var basename = (path, separator) => {
   if (path[path.length - 1] === separator) path = path.slice(0, -1);
   const lastSlashIndex = path.lastIndexOf(separator);
@@ -1469,7 +1816,7 @@ var toTree = async (fs, opts = {}) => {
   const sort = opts.sort ?? true;
   let subtree = " (...)";
   if (depth > 0) {
-    const list = await fs.readdirWithFileTypes?.(dir) || [];
+    const list = await fs.readdirWithFileTypes(dir);
     if (sort) {
       list.sort((a, b) => {
         if (a.isDirectory && b.isDirectory) {
@@ -1503,62 +1850,7 @@ var toTree = async (fs, opts = {}) => {
   const base = basename(dir, separator) + separator;
   return base + subtree;
 };
-var FileSystemSkillProvider = class {
-  constructor(baseDir) {
-    this.baseDir = baseDir;
-  }
-  async listSkills() {
-    const dirs = await this.discoverSkillDirs();
-    const skills = [];
-    for (const dir of dirs) {
-      const raw = await readFile(join(this.baseDir, dir, "SKILL.md"), "utf-8");
-      const { frontmatter } = parseSkillFile(raw);
-      skills.push(frontmatter);
-    }
-    return skills;
-  }
-  async getSkill(name) {
-    const raw = await readFile(
-      join(this.baseDir, name, "SKILL.md"),
-      "utf-8"
-    );
-    const { frontmatter, body } = parseSkillFile(raw);
-    if (frontmatter.name !== name) {
-      throw new Error(
-        `Skill directory "${name}" contains SKILL.md with mismatched name "${frontmatter.name}"`
-      );
-    }
-    return { ...frontmatter, instructions: body };
-  }
-  /**
-   * Convenience method to load all skills with full instructions.
-   * Returns `Skill[]` ready to pass into a workflow.
-   */
-  async loadAll() {
-    const dirs = await this.discoverSkillDirs();
-    const skills = [];
-    for (const dir of dirs) {
-      const raw = await readFile(join(this.baseDir, dir, "SKILL.md"), "utf-8");
-      const { frontmatter, body } = parseSkillFile(raw);
-      skills.push({ ...frontmatter, instructions: body });
-    }
-    return skills;
-  }
-  async discoverSkillDirs() {
-    const entries = await readdir(this.baseDir, { withFileTypes: true });
-    const dirs = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      try {
-        await readFile(join(this.baseDir, entry.name, "SKILL.md"), "utf-8");
-        dirs.push(entry.name);
-      } catch {
-      }
-    }
-    return dirs;
-  }
-};
 
-export { FileSystemSkillProvider, agentQueryName, agentStateChangeUpdateName, askUserQuestionTool, bashTool, createAgentStateManager, createAskUserQuestionHandler, createBashHandler, createBashToolDescription, createEditHandler, createGlobHandler, createReadSkillHandler, createReadSkillTool, createRunAgentActivity, createSession, createSubagentTool, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createThreadManager, createToolRouter, defineSubagent, defineTool, editTool, getShortId, globTool, grepTool, hasNoOtherToolCalls, isTerminalStatus, parseSkillFile, proxyDefaultThreadOps, queryParentWorkflowState, readFileTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, toTree, withAutoAppend, writeFileTool };
+export { FileSystemSkillProvider, SandboxManager, SandboxNotFoundError, SandboxNotSupportedError, applyVirtualTreeMutations, askUserQuestionTool, bashHandler, bashTool, createAgentStateManager, createAskUserQuestionHandler, createBashToolDescription, createReadSkillHandler, createReadSkillTool, createRunAgentActivity, createSession, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createThreadManager, createToolRouter, defineSubagent, defineTool, editHandler, editTool, formatVirtualFileTree, getShortId, globHandler, globTool, grepTool, hasNoOtherToolCalls, isTerminalStatus, parseSkillFile, proxyDefaultThreadOps, proxySandboxOps, queryParentWorkflowState, readFileHandler, readFileTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, toTree, withAutoAppend, withParentWorkflowState, withSandbox, writeFileHandler, writeFileTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map