zeitlich 0.2.13 → 0.2.14

package/dist/index.cjs

@@ -2,157 +2,15 @@
 
 var workflow = require('@temporalio/workflow');
 var z14 = require('zod');
-var activity = require('@temporalio/activity');
-var justBash = require('just-bash');
-var promises = require('fs/promises');
+var common = require('@temporalio/common');
 var path = require('path');
+var activity = require('@temporalio/activity');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var z14__default = /*#__PURE__*/_interopDefault(z14);
 
-// 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__default.default.enum(names).describe("The type of subagent to launch"),
-    description: z14__default.default.string().describe("A short (3-5 word) description of the task"),
-    prompt: z14__default.default.string().describe("The task for the agent to perform")
-  };
-  const schema = hasThreadContinuation ? z14__default.default.object({
-    ...baseFields,
-    threadId: z14__default.default.string().nullable().describe(
-      "Thread ID to continue an existing conversation, or null to start a new one"
-    )
-  }) : z14__default.default.object(baseFields);
-  return {
-    name: SUBAGENT_TOOL_NAME,
-    description: buildSubagentDescription(subagents),
-    schema
-  };
-}
-var BASE62 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-function getShortId(length = 12) {
-  const hex = workflow.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 } = workflow.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 workflow.executeChild(config.workflow, childOpts) : await workflow.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__default.default.object({
-      skill_name: z14__default.default.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();
@@ -160,45 +18,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({
@@ -206,58 +31,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 workflow.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;
@@ -267,47 +139,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 workflow.ApplicationFailure.fromError(error, {
-          nonRetryable: true
-        });
-      }
+      const recovery = await runFailureHooks(toolCall, tool, error, effectiveArgs, turn);
+      result = recovery.result;
+      content = recovery.content;
     }
     if (!resultAppended) {
       await appendToolResult({
@@ -322,29 +156,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);
     },
@@ -368,32 +183,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
@@ -401,7 +209,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);
         }
@@ -413,17 +225,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({
@@ -448,7 +259,6 @@ function createToolRouter(options) {
       }
       return results;
     },
-    // --- Utility methods ---
     filterByName(toolCalls, name) {
       return toolCalls.filter(
         (tc) => tc.name === name
@@ -462,36 +272,201 @@ function createToolRouter(options) {
     }
   };
 }
-function withAutoAppend(threadHandler, handler) {
+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 = workflow.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__default.default.enum(names).describe("The type of subagent to launch"),
+    description: z14__default.default.string().describe("A short (3-5 word) description of the task"),
+    prompt: z14__default.default.string().describe("The task for the agent to perform")
+  };
+  const schema = hasThreadContinuation ? z14__default.default.object({
+    ...baseFields,
+    threadId: z14__default.default.string().nullable().describe(
+      "Thread ID to continue an existing conversation, or null to start a new one"
+    )
+  }) : z14__default.default.object(baseFields);
+  return {
+    name: SUBAGENT_TOOL_NAME,
+    description: buildSubagentDescription(subagents),
+    schema
+  };
+}
+function createSubagentHandler(subagents) {
+  const { taskQueue: parentTaskQueue } = workflow.workflowInfo();
   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
-    });
+    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 workflow.executeChild(config.workflow, childOpts) : await workflow.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: "Response appended via withAutoAppend",
-      data: response.data,
-      resultAppended: true
+      toolResponse: finalToolResponse,
+      data: validated ? validated.data : data,
+      ...usage && { usage }
     };
   };
 }
-function defineTool(tool) {
-  return tool;
+
+// src/lib/subagent/register.ts
+function buildSubagentRegistration(subagents) {
+  const enabled = subagents.filter((s) => s.enabled ?? true);
+  if (enabled.length === 0) return null;
+  const subagentHooksMap = /* @__PURE__ */ new Map();
+  for (const s of enabled) {
+    if (s.hooks) subagentHooksMap.set(s.agentName, s.hooks);
+  }
+  const resolveSubagentName = (args) => args.subagent;
+  return {
+    ...createSubagentTool(enabled),
+    handler: createSubagentHandler(enabled),
+    ...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 defineSubagent(config) {
-  return config;
+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 hasNoOtherToolCalls(toolCalls, excludeName) {
-  return toolCalls.filter((tc) => tc.name !== excludeName).length === 0;
+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__default.default.object({
+      skill_name: z14__default.default.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: skill.instructions,
+      data: null
+    };
+  };
+}
+
+// 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,
@@ -507,7 +482,9 @@ var createSession = async ({
   hooks = {},
   appendSystemPrompt = true,
   continueThread = false,
-  waitForInputTimeout = "48h"
+  waitForInputTimeout = "48h",
+  sandbox: sandboxOps,
+  sandboxId: inheritedSandboxId
 }) => {
   const threadId = providedThreadId ?? getShortId();
   const {
@@ -516,13 +493,21 @@ var createSession = async ({
     initializeThread,
     appendSystemMessage
   } = 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) => {
@@ -559,6 +544,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,
@@ -599,6 +595,7 @@ var createSession = async ({
             stateManager.complete();
             exitReason = "completed";
             return {
+              threadId,
               finalMessage: message,
               exitReason,
               usage: stateManager.getTotalUsage()
@@ -622,7 +619,8 @@ var createSession = async ({
           const toolCallResults = await toolRouter.processToolCalls(
             parsedToolCalls,
             {
-              turn: currentTurn
+              turn: currentTurn,
+              ...sandboxId !== void 0 && { sandboxId }
             }
           );
           for (const result of toolCallResults) {
@@ -650,8 +648,12 @@ var createSession = async ({
         throw workflow.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()
@@ -672,16 +674,94 @@ function proxyDefaultThreadOps(options) {
     }
   );
 }
+function proxySandboxOps(options) {
+  return workflow.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 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;
@@ -712,11 +792,9 @@ function createAgentStateManager({
       ...customState
     };
   }
-  const stateQuery = workflow.defineQuery(
-    agentQueryName(agentName)
-  );
+  const stateQuery = workflow.defineQuery("getAgentState");
   const stateChangeUpdate = workflow.defineUpdate(
-    agentStateChangeUpdateName(agentName)
+    "waitForAgentStateChange"
   );
   workflow.setHandler(stateQuery, () => buildState());
   workflow.setHandler(stateChangeUpdate, async (lastKnownVersion) => {
@@ -780,6 +858,10 @@ function createAgentStateManager({
       customState[key] = value;
       version++;
     },
+    mergeUpdate(update) {
+      Object.assign(customState, update);
+      version++;
+    },
     getCurrentState() {
       return buildState();
     },
@@ -835,6 +917,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 common.ApplicationFailure {
+  constructor(operation) {
+    super(
+      `Sandbox does not support: ${operation}`,
+      "SandboxNotSupportedError",
+      true
+    );
+  }
+};
+var SandboxNotFoundError = class extends common.ApplicationFailure {
+  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/, "");
@@ -1256,197 +1459,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(path.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(
+      path.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(path.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 = path.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 } = activity.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 justBash.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 justBash.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);
@@ -1475,7 +1794,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) {
@@ -1509,78 +1828,22 @@ 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 promises.readFile(path.join(this.baseDir, dir, "SKILL.md"), "utf-8");
-      const { frontmatter } = parseSkillFile(raw);
-      skills.push(frontmatter);
-    }
-    return skills;
-  }
-  async getSkill(name) {
-    const raw = await promises.readFile(
-      path.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 promises.readFile(path.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 promises.readdir(this.baseDir, { withFileTypes: true });
-    const dirs = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      try {
-        await promises.readFile(path.join(this.baseDir, entry.name, "SKILL.md"), "utf-8");
-        dirs.push(entry.name);
-      } catch {
-      }
-    }
-    return dirs;
-  }
-};
 
 exports.FileSystemSkillProvider = FileSystemSkillProvider;
-exports.agentQueryName = agentQueryName;
-exports.agentStateChangeUpdateName = agentStateChangeUpdateName;
+exports.SandboxManager = SandboxManager;
+exports.SandboxNotFoundError = SandboxNotFoundError;
+exports.SandboxNotSupportedError = SandboxNotSupportedError;
+exports.applyVirtualTreeMutations = applyVirtualTreeMutations;
 exports.askUserQuestionTool = askUserQuestionTool;
+exports.bashHandler = bashHandler;
 exports.bashTool = bashTool;
 exports.createAgentStateManager = createAgentStateManager;
 exports.createAskUserQuestionHandler = createAskUserQuestionHandler;
-exports.createBashHandler = createBashHandler;
 exports.createBashToolDescription = createBashToolDescription;
-exports.createEditHandler = createEditHandler;
-exports.createGlobHandler = createGlobHandler;
 exports.createReadSkillHandler = createReadSkillHandler;
 exports.createReadSkillTool = createReadSkillTool;
 exports.createRunAgentActivity = createRunAgentActivity;
 exports.createSession = createSession;
-exports.createSubagentTool = createSubagentTool;
 exports.createTaskCreateHandler = createTaskCreateHandler;
 exports.createTaskGetHandler = createTaskGetHandler;
 exports.createTaskListHandler = createTaskListHandler;
@@ -1589,15 +1852,20 @@ exports.createThreadManager = createThreadManager;
 exports.createToolRouter = createToolRouter;
 exports.defineSubagent = defineSubagent;
 exports.defineTool = defineTool;
+exports.editHandler = editHandler;
 exports.editTool = editTool;
+exports.formatVirtualFileTree = formatVirtualFileTree;
 exports.getShortId = getShortId;
+exports.globHandler = globHandler;
 exports.globTool = globTool;
 exports.grepTool = grepTool;
 exports.hasNoOtherToolCalls = hasNoOtherToolCalls;
 exports.isTerminalStatus = isTerminalStatus;
 exports.parseSkillFile = parseSkillFile;
 exports.proxyDefaultThreadOps = proxyDefaultThreadOps;
+exports.proxySandboxOps = proxySandboxOps;
 exports.queryParentWorkflowState = queryParentWorkflowState;
+exports.readFileHandler = readFileHandler;
 exports.readFileTool = readFileTool;
 exports.taskCreateTool = taskCreateTool;
 exports.taskGetTool = taskGetTool;
@@ -1605,6 +1873,9 @@ exports.taskListTool = taskListTool;
 exports.taskUpdateTool = taskUpdateTool;
 exports.toTree = toTree;
 exports.withAutoAppend = withAutoAppend;
+exports.withParentWorkflowState = withParentWorkflowState;
+exports.withSandbox = withSandbox;
+exports.writeFileHandler = writeFileHandler;
 exports.writeFileTool = writeFileTool;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map