zeitlich 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,16 +1,10 @@
-'use strict';
-
-var workflow = require('@temporalio/workflow');
-var z2 = require('zod');
-var minimatch = require('minimatch');
-var plugin = require('@temporalio/plugin');
-var messages = require('@langchain/core/messages');
-var crypto = require('crypto');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var z2__default = /*#__PURE__*/_interopDefault(z2);
-var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+import { defineQuery, proxyActivities, setHandler, workflowInfo, uuid4, executeChild } from '@temporalio/workflow';
+import z4, { z } from 'zod';
+import { SimplePlugin } from '@temporalio/plugin';
+import { mapStoredMessageToChatMessage, mapStoredMessagesToChatMessages, AIMessage, SystemMessage, ToolMessage, HumanMessage } from '@langchain/core/messages';
+import crypto from 'crypto';
+import { Context } from '@temporalio/activity';
+import { Bash } from 'just-bash';
 
 // src/lib/session.ts
 var TASK_TOOL = "Task";
@@ -45,24 +39,24 @@ function createTaskTool(subagents) {
   return {
     name: TASK_TOOL,
     description: buildTaskDescription(subagents),
-    schema: z2__default.default.object({
-      subagent: z2__default.default.enum(names).describe("The type of subagent to launch"),
-      description: z2__default.default.string().describe("A short (3-5 word) description of the task"),
-      prompt: z2__default.default.string().describe("The task for the agent to perform")
+    schema: z4.object({
+      subagent: z4.enum(names).describe("The type of subagent to launch"),
+      description: z4.string().describe("A short (3-5 word) description of the task"),
+      prompt: z4.string().describe("The task for the agent to perform")
     })
   };
 }
 function createTaskHandler(subagents) {
-  const { workflowId: parentWorkflowId, taskQueue: parentTaskQueue } = workflow.workflowInfo();
-  return async (args, _toolCallId) => {
+  const { workflowId: parentWorkflowId, taskQueue: parentTaskQueue } = workflowInfo();
+  return async (args) => {
     const config = subagents.find((s) => s.name === args.subagent);
     if (!config) {
       throw new Error(
         `Unknown subagent: ${args.subagent}. Available: ${subagents.map((s) => s.name).join(", ")}`
       );
     }
-    const childWorkflowId = `${parentWorkflowId}-${args.subagent}-${workflow.uuid4()}`;
-    const childResult = await workflow.executeChild(config.workflowType, {
+    const childWorkflowId = `${parentWorkflowId}-${args.subagent}-${uuid4()}`;
+    const childResult = await executeChild(config.workflowType, {
       workflowId: childWorkflowId,
       args: [{ prompt: args.prompt }],
       taskQueue: config.taskQueue ?? parentTaskQueue
@@ -78,35 +72,332 @@ function createTaskHandler(subagents) {
     };
   };
 }
+var createBashToolDescription = ({
+  fileTree
+}) => `tool to execute bash commands, the file tree is: ${fileTree}`;
+var bashTool = {
+  name: "Bash",
+  description: "tool to execute bash commands",
+  schema: z4.object({
+    command: z4.string().describe("stringified command to be executed inside the Bash")
+  }),
+  strict: true
+};
+var taskCreateTool = {
+  name: "TaskCreate",
+  description: `Use this tool to create a structured task list for the control test. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+  It also helps the user understand the progress of the task and overall progress of their requests.
+  
+  ## When to Use This Tool
+  
+  Use this tool proactively in these scenarios:
+  
+  - Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+  - Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+  - User explicitly requests todo list - When the user directly asks you to use the todo list
+  - User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+  - After receiving new instructions - Immediately capture user requirements as tasks
+  - When you start working on a task - Mark it as in_progress BEFORE beginning work
+  - After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+  
+  ## When NOT to Use This Tool
+  
+  Skip using this tool when:
+  - There is only a single, straightforward task
+  - The task is trivial and tracking it provides no organizational benefit
+  - The task can be completed in less than 3 trivial steps
+  - The task is purely conversational or informational
+  
+  NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
+  
+  ## Task Fields
+  
+  - **subject**: A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")
+  - **description**: Detailed description of what needs to be done, including context and acceptance criteria
+  - **activeForm**: Present continuous form shown in spinner when task is in_progress (e.g., "Fixing authentication bug"). This is displayed to the user while you work on the task.
+  
+  **IMPORTANT**: Always provide activeForm when creating tasks. The subject should be imperative ("Run tests") while activeForm should be present continuous ("Running tests"). All tasks are created with status \`pending\`.
+  
+  ## Tips
+  
+  - Create tasks with clear, specific subjects that describe the outcome
+  - Include enough detail in the description for another agent to understand and complete the task
+  - After creating tasks, use TaskUpdate to set up dependencies (blocks/blockedBy) if needed
+  - Check TaskList first to avoid creating duplicate tasks`,
+  schema: z4.object({
+    subject: z4.string().describe(
+      'A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")'
+    ),
+    description: z4.string().describe(
+      "Detailed description of what needs to be done, including context and acceptance criteria"
+    ),
+    activeForm: z4.string().describe(
+      'Present continuous form shown in spinner when task is in_progress (e.g., "Fixing authentication bug"). This is displayed to the user while you work on the task.'
+    ),
+    metadata: z4.record(z4.string(), z4.string()).describe("Arbitrary key-value pairs for tracking")
+  })
+};
 
-// src/lib/subagent-support.ts
-function withSubagentSupport(userTools, config) {
-  if (config.subagents.length === 0) {
-    throw new Error("withSubagentSupport requires at least one subagent");
+// src/lib/tool-router.ts
+var buildIntoolDefinitions = {
+  [bashTool.name]: bashTool,
+  [taskCreateTool.name]: taskCreateTool
+};
+function createToolRouter(options) {
+  const { appendToolResult } = proxyActivities({
+    startToCloseTimeout: "2m",
+    retry: {
+      maximumAttempts: 3,
+      initialInterval: "5s",
+      maximumInterval: "15m",
+      backoffCoefficient: 4
+    }
+  });
+  const toolMap = /* @__PURE__ */ new Map();
+  for (const [_key, tool] of Object.entries(options.tools)) {
+    toolMap.set(tool.name, tool);
+  }
+  if (options.subagents) {
+    toolMap.set("Task", {
+      ...createTaskTool(options.subagents),
+      handler: createTaskHandler(options.subagents)
+    });
+  }
+  if (options.buildInTools) {
+    for (const [key, value] of Object.entries(options.buildInTools)) {
+      if (key === bashTool.name) {
+        toolMap.set(key, {
+          ...buildIntoolDefinitions[key],
+          description: createBashToolDescription({
+            fileTree: options.fileTree
+          }),
+          handler: value
+        });
+      } else {
+        toolMap.set(key, {
+          ...buildIntoolDefinitions[key],
+          handler: value
+        });
+      }
+    }
+  }
+  async function processToolCall(toolCall, turn, handlerContext) {
+    const startTime = Date.now();
+    let effectiveArgs = toolCall.args;
+    if (options.hooks?.onPreToolUse) {
+      const preResult = await options.hooks.onPreToolUse({
+        toolCall,
+        threadId: options.threadId,
+        turn
+      });
+      if (preResult?.skip) {
+        await appendToolResult({
+          threadId: options.threadId,
+          toolCallId: toolCall.id,
+          content: JSON.stringify({
+            skipped: true,
+            reason: "Skipped by PreToolUse hook"
+          })
+        });
+        return null;
+      }
+      if (preResult?.modifiedArgs !== void 0) {
+        effectiveArgs = preResult.modifiedArgs;
+      }
+    }
+    const tool = toolMap.get(toolCall.name);
+    let result;
+    let content;
+    try {
+      if (tool) {
+        const response = await tool.handler(
+          effectiveArgs,
+          handlerContext ?? {}
+        );
+        result = response.result;
+        content = response.content;
+      } else {
+        result = { error: `Unknown tool: ${toolCall.name}` };
+        content = JSON.stringify(result, null, 2);
+      }
+    } catch (error) {
+      if (options.hooks?.onPostToolUseFailure) {
+        const failureResult = await options.hooks.onPostToolUseFailure({
+          toolCall,
+          error: error instanceof Error ? error : new Error(String(error)),
+          threadId: options.threadId,
+          turn
+        });
+        if (failureResult?.fallbackContent !== void 0) {
+          content = failureResult.fallbackContent;
+          result = { error: String(error), recovered: true };
+        } else if (failureResult?.suppress) {
+          content = JSON.stringify({ error: String(error), suppressed: true });
+          result = { error: String(error), suppressed: true };
+        } else {
+          throw error;
+        }
+      } else {
+        throw error;
+      }
+    }
+    await appendToolResult({
+      threadId: options.threadId,
+      toolCallId: toolCall.id,
+      content
+    });
+    const toolResult = {
+      toolCallId: toolCall.id,
+      name: toolCall.name,
+      result
+    };
+    if (options.hooks?.onPostToolUse) {
+      const durationMs = Date.now() - startTime;
+      await options.hooks.onPostToolUse({
+        toolCall,
+        result: toolResult,
+        threadId: options.threadId,
+        turn,
+        durationMs
+      });
+    }
+    return toolResult;
   }
-  const taskTool = createTaskTool(config.subagents);
-  const taskHandler = createTaskHandler(config.subagents);
   return {
-    tools: {
-      ...userTools,
-      Task: taskTool
+    // --- Methods from registry ---
+    hasTools() {
+      return toolMap.size > 0;
+    },
+    parseToolCall(toolCall) {
+      const tool = toolMap.get(toolCall.name);
+      if (!tool) {
+        throw new Error(`Tool ${toolCall.name} not found`);
+      }
+      const parsedArgs = tool.schema.parse(toolCall.args);
+      return {
+        id: toolCall.id ?? "",
+        name: toolCall.name,
+        args: parsedArgs
+      };
+    },
+    hasTool(name) {
+      return toolMap.has(name);
+    },
+    getToolNames() {
+      return Array.from(toolMap.keys());
+    },
+    getToolDefinitions() {
+      return Array.from(toolMap).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;
+      if (options.parallel) {
+        const results2 = await Promise.all(
+          toolCalls.map((tc) => processToolCall(tc, turn, handlerContext))
+        );
+        return results2.filter(
+          (r) => r !== null
+        );
+      }
+      const results = [];
+      for (const toolCall of toolCalls) {
+        const result = await processToolCall(toolCall, turn, handlerContext);
+        if (result !== null) {
+          results.push(result);
+        }
+      }
+      return results;
+    },
+    async processToolCallsByName(toolCalls, toolName, handler, context) {
+      const matchingCalls = toolCalls.filter((tc) => tc.name === toolName);
+      if (matchingCalls.length === 0) {
+        return [];
+      }
+      const handlerContext = context?.handlerContext ?? {};
+      const processOne = async (toolCall) => {
+        const response = await handler(
+          toolCall.args,
+          handlerContext
+        );
+        await appendToolResult({
+          threadId: options.threadId,
+          toolCallId: toolCall.id,
+          content: response.content
+        });
+        return {
+          toolCallId: toolCall.id,
+          name: toolCall.name,
+          result: response.result
+        };
+      };
+      if (options.parallel) {
+        return Promise.all(matchingCalls.map(processOne));
+      }
+      const results = [];
+      for (const toolCall of matchingCalls) {
+        results.push(await processOne(toolCall));
+      }
+      return results;
+    },
+    // --- Utility methods ---
+    filterByName(toolCalls, name) {
+      return toolCalls.filter(
+        (tc) => tc.name === name
+      );
+    },
+    hasToolCall(toolCalls, name) {
+      return toolCalls.some((tc) => tc.name === name);
     },
-    taskHandler
+    getResultsByName(results, name) {
+      return results.filter((r) => r.name === name);
+    }
   };
 }
-function hasTaskTool(tools) {
-  return "Task" in tools;
+function hasNoOtherToolCalls(toolCalls, excludeName) {
+  return toolCalls.filter((tc) => tc.name !== excludeName).length === 0;
 }
 
 // src/lib/session.ts
-var createSession = async ({ threadId, agentName, maxTurns = 50, metadata = {} }, {
+async function resolvePrompt(prompt) {
+  if (typeof prompt === "function") {
+    return prompt();
+  }
+  return prompt;
+}
+var createSession = async ({
+  threadId,
+  agentName,
+  maxTurns = 50,
+  metadata = {},
   runAgent,
-  promptManager,
-  toolRouter,
-  toolRegistry,
+  baseSystemPrompt,
+  instructionsPrompt,
+  buildContextMessage,
+  buildFileTree = async () => "",
+  subagents,
+  tools = {},
+  processToolsInParallel = true,
+  buildInTools = {},
   hooks = {}
 }) => {
-  const { initializeThread, appendHumanMessage, parseToolCalls } = workflow.proxyActivities({
+  const {
+    initializeThread,
+    appendHumanMessage,
+    parseToolCalls,
+    appendToolResult,
+    appendSystemMessage
+  } = proxyActivities({
     startToCloseTimeout: "30m",
     retry: {
       maximumAttempts: 6,
@@ -116,6 +407,16 @@ var createSession = async ({ threadId, agentName, maxTurns = 50, metadata = {} }
     },
     heartbeatTimeout: "5m"
   });
+  const fileTree = await buildFileTree();
+  const toolRouter = createToolRouter({
+    tools,
+    threadId,
+    hooks,
+    buildInTools,
+    fileTree,
+    subagents,
+    parallel: processToolsInParallel
+  });
   const callSessionEnd = async (exitReason, turns) => {
     if (hooks.onSessionEnd) {
       await hooks.onSessionEnd({
@@ -128,7 +429,7 @@ var createSession = async ({ threadId, agentName, maxTurns = 50, metadata = {} }
     }
   };
   return {
-    runSession: async (prompt, stateManager) => {
+    runSession: async ({ stateManager }) => {
       if (hooks.onSessionStart) {
         await hooks.onSessionStart({
           threadId,
@@ -136,43 +437,54 @@ var createSession = async ({ threadId, agentName, maxTurns = 50, metadata = {} }
           metadata
         });
       }
+      stateManager.setTools(toolRouter.getToolDefinitions());
       await initializeThread(threadId);
-      await appendHumanMessage(
+      await appendSystemMessage(
         threadId,
-        await promptManager.buildContextMessage(prompt)
+        [
+          await resolvePrompt(baseSystemPrompt),
+          await resolvePrompt(instructionsPrompt)
+        ].join("\n")
       );
+      await appendHumanMessage(threadId, await buildContextMessage());
       let exitReason = "completed";
       try {
         while (stateManager.isRunning() && !stateManager.isTerminal() && stateManager.getTurns() < maxTurns) {
           stateManager.incrementTurns();
           const currentTurn = stateManager.getTurns();
-          const { message, stopReason } = await runAgent(
-            {
-              threadId,
-              agentName,
-              metadata
-            },
-            {
-              systemPrompt: await promptManager.getSystemPrompt()
-            }
-          );
+          const { message, stopReason } = await runAgent({
+            threadId,
+            agentName,
+            metadata
+          });
           if (stopReason === "end_turn") {
             stateManager.complete();
             exitReason = "completed";
             return message;
           }
-          if (!toolRouter || !toolRegistry) {
+          if (!toolRouter.hasTools()) {
             stateManager.complete();
             exitReason = "completed";
             return message;
           }
           const rawToolCalls = await parseToolCalls(message);
-          const parsedToolCalls = rawToolCalls.map(
-            (tc) => toolRegistry.parseToolCall(tc)
+          const parsedToolCalls = rawToolCalls.filter((tc) => tc.name !== "Task").map((tc) => toolRouter.parseToolCall(tc));
+          const taskToolCalls = subagents && subagents.length > 0 ? rawToolCalls.filter((tc) => tc.name === "Task").map((tc) => {
+            const parsedArgs = createTaskTool(subagents).schema.parse(
+              tc.args
+            );
+            return {
+              id: tc.id ?? "",
+              name: tc.name,
+              args: parsedArgs
+            };
+          }) : [];
+          await toolRouter.processToolCalls(
+            [...parsedToolCalls, ...taskToolCalls],
+            {
+              turn: currentTurn
+            }
           );
-          await toolRouter.processToolCalls(parsedToolCalls, {
-            turn: currentTurn
-          });
           if (stateManager.getStatus() === "WAITING_FOR_INPUT") {
             exitReason = "waiting_for_input";
             break;
@@ -198,19 +510,34 @@ function isTerminalStatus(status) {
 }
 
 // src/lib/state-manager.ts
-function createAgentStateManager(config) {
-  let status = "RUNNING";
-  let version = 0;
-  let turns = 0;
-  const customState = { ...config?.initialState ?? {} };
+var getStateQuery = defineQuery("getState");
+function createAgentStateManager(initialState) {
+  let status = initialState?.status ?? "RUNNING";
+  let version = initialState?.version ?? 0;
+  let turns = initialState?.turns ?? 0;
+  let tools = initialState?.tools ?? [];
+  const tasks = new Map(initialState?.tasks);
+  const {
+    status: _,
+    version: __,
+    turns: ___,
+    tasks: ____,
+    tools: _____,
+    ...custom
+  } = initialState ?? {};
+  const customState = custom;
   function buildState() {
     return {
       status,
       version,
       turns,
+      tools,
       ...customState
     };
   }
+  setHandler(getStateQuery, () => {
+    return buildState();
+  });
   return {
     getStatus() {
       return status;
@@ -265,6 +592,26 @@ function createAgentStateManager(config) {
     },
     shouldReturnFromWait(lastKnownVersion) {
       return version > lastKnownVersion || isTerminalStatus(status);
+    },
+    getTasks() {
+      return Array.from(tasks.values());
+    },
+    getTask(id) {
+      return tasks.get(id);
+    },
+    setTask(task) {
+      tasks.set(task.id, task);
+      version++;
+    },
+    setTools(newTools) {
+      tools = newTools;
+    },
+    deleteTask(id) {
+      const deleted = tasks.delete(id);
+      if (deleted) {
+        version++;
+      }
+      return deleted;
     }
   };
 }
@@ -273,241 +620,33 @@ var AGENT_HANDLER_NAMES = {
   waitForStateChange: "waitForStateChange",
   addMessage: "addMessage"
 };
+var askUserQuestionTool = {
+  name: "AskUserQuestion",
+  description: `Use this tool when you need to ask the user questions during execution. This allows you to:
 
-// src/lib/prompt-manager.ts
-function createPromptManager(config) {
-  const { baseSystemPrompt, instructionsPrompt, buildContextMessage } = config;
-  async function resolvePrompt(prompt) {
-    if (typeof prompt === "function") {
-      return prompt();
-    }
-    return prompt;
-  }
-  return {
-    async getSystemPrompt() {
-      const base = await resolvePrompt(baseSystemPrompt);
-      const instructions = await resolvePrompt(instructionsPrompt);
-      return [base, instructions].join("\n");
-    },
-    async buildContextMessage(context) {
-      return buildContextMessage(context);
-    }
-  };
-}
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
 
-// src/lib/tool-registry.ts
-function createToolRegistry(tools) {
-  const toolMap = /* @__PURE__ */ new Map();
-  for (const [_key, tool] of Object.entries(tools)) {
-    toolMap.set(tool.name, tool);
-  }
-  return {
-    parseToolCall(toolCall) {
-      const tool = toolMap.get(toolCall.name);
-      if (!tool) {
-        throw new Error(`Tool ${toolCall.name} not found`);
-      }
-      const parsedArgs = tool.schema.parse(toolCall.args);
-      return {
-        id: toolCall.id ?? "",
-        name: toolCall.name,
-        args: parsedArgs
-      };
-    },
-    getToolList() {
-      return Object.values(tools);
-    },
-    getTool(name) {
-      return tools[name];
-    },
-    hasTool(name) {
-      return toolMap.has(name);
-    },
-    getToolNames() {
-      return Array.from(toolMap.keys());
-    }
-  };
-}
+Usage notes:
 
-// src/lib/tool-router.ts
-function createToolRouter(options, handlers) {
-  const { parallel = true, threadId, appendToolResult, hooks } = options;
-  async function processToolCall(toolCall, turn) {
-    const startTime = Date.now();
-    let effectiveArgs = toolCall.args;
-    if (hooks?.onPreToolUse) {
-      const preResult = await hooks.onPreToolUse({
-        toolCall,
-        threadId,
-        turn
-      });
-      if (preResult?.skip) {
-        await appendToolResult({
-          threadId,
-          toolCallId: toolCall.id,
-          content: JSON.stringify({
-            skipped: true,
-            reason: "Skipped by PreToolUse hook"
-          })
-        });
-        return null;
-      }
-      if (preResult?.modifiedArgs !== void 0) {
-        effectiveArgs = preResult.modifiedArgs;
-      }
-    }
-    const handler = handlers[toolCall.name];
-    let result;
-    let content;
-    try {
-      if (handler) {
-        const response = await handler(
-          effectiveArgs,
-          toolCall.id
-        );
-        result = response.result;
-        content = response.content;
-      } else {
-        result = { error: `Unknown tool: ${toolCall.name}` };
-        content = JSON.stringify(result, null, 2);
-      }
-    } catch (error) {
-      if (hooks?.onPostToolUseFailure) {
-        const failureResult = await hooks.onPostToolUseFailure({
-          toolCall,
-          error: error instanceof Error ? error : new Error(String(error)),
-          threadId,
-          turn
-        });
-        if (failureResult?.fallbackContent !== void 0) {
-          content = failureResult.fallbackContent;
-          result = { error: String(error), recovered: true };
-        } else if (failureResult?.suppress) {
-          content = JSON.stringify({ error: String(error), suppressed: true });
-          result = { error: String(error), suppressed: true };
-        } else {
-          throw error;
-        }
-      } else {
-        throw error;
-      }
-    }
-    await appendToolResult({ threadId, toolCallId: toolCall.id, content });
-    const toolResult = {
-      toolCallId: toolCall.id,
-      name: toolCall.name,
-      result
-    };
-    if (hooks?.onPostToolUse) {
-      const durationMs = Date.now() - startTime;
-      await hooks.onPostToolUse({
-        toolCall,
-        result: toolResult,
-        threadId,
-        turn,
-        durationMs
-      });
-    }
-    return toolResult;
-  }
-  return {
-    async processToolCalls(toolCalls, context) {
-      if (toolCalls.length === 0) {
-        return [];
-      }
-      const turn = context?.turn ?? 0;
-      if (parallel) {
-        const results2 = await Promise.all(
-          toolCalls.map((tc) => processToolCall(tc, turn))
-        );
-        return results2.filter(
-          (r) => r !== null
-        );
-      }
-      const results = [];
-      for (const toolCall of toolCalls) {
-        const result = await processToolCall(toolCall, turn);
-        if (result !== null) {
-          results.push(result);
-        }
-      }
-      return results;
-    },
-    async processToolCallsByName(toolCalls, toolName, handler) {
-      const matchingCalls = toolCalls.filter((tc) => tc.name === toolName);
-      if (matchingCalls.length === 0) {
-        return [];
-      }
-      const processOne = async (toolCall) => {
-        const response = await handler(
-          toolCall.args,
-          toolCall.id
-        );
-        await appendToolResult({
-          threadId,
-          toolCallId: toolCall.id,
-          content: response.content
-        });
-        return {
-          toolCallId: toolCall.id,
-          name: toolCall.name,
-          result: response.result
-        };
-      };
-      if (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 hasNoOtherToolCalls(toolCalls, excludeName) {
-  return toolCalls.filter((tc) => tc.name !== excludeName).length === 0;
-}
-var askUserQuestionTool = {
-  name: "AskUserQuestion",
-  description: `Use this tool when you need to ask the user questions during execution. This allows you to:
-
-1. Gather user preferences or requirements
-2. Clarify ambiguous instructions
-3. Get decisions on implementation choices as you work
-4. Offer choices to the user about what direction to take.
-
-Usage notes:
-
-* Users will always be able to select "Other" to provide custom text input
-* Use multiSelect: true to allow multiple answers to be selected for a question
-* If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label
-`,
-  schema: z2__default.default.object({
-    questions: z2__default.default.array(
-      z2__default.default.object({
-        question: z2__default.default.string().describe("The full question text to display"),
-        header: z2__default.default.string().describe("Short label for the question (max 12 characters)"),
-        options: z2__default.default.array(
-          z2__default.default.object({
-            label: z2__default.default.string(),
-            description: z2__default.default.string()
+* Users will always be able to select "Other" to provide custom text input
+* Use multiSelect: true to allow multiple answers to be selected for a question
+* If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label
+`,
+  schema: z4.object({
+    questions: z4.array(
+      z4.object({
+        question: z4.string().describe("The full question text to display"),
+        header: z4.string().describe("Short label for the question (max 12 characters)"),
+        options: z4.array(
+          z4.object({
+            label: z4.string(),
+            description: z4.string()
           })
         ).min(0).max(4).describe("Array of 0-4 choices, each with label and description"),
-        multiSelect: z2__default.default.boolean().describe("If true, users can select multiple options")
+        multiSelect: z4.boolean().describe("If true, users can select multiple options")
       })
     )
   }),
@@ -527,9 +666,9 @@ Examples:
 - "**/*.test.ts" - Find all test files recursively
 - "src/**/*.ts" - Find all TypeScript files in src directory
 `,
-  schema: z2.z.object({
-    pattern: z2.z.string().describe("Glob pattern to match files against"),
-    root: z2.z.string().optional().describe("Optional root directory to search from")
+  schema: z.object({
+    pattern: z.string().describe("Glob pattern to match files against"),
+    root: z.string().optional().describe("Optional root directory to search from")
   }),
   strict: true
 };
@@ -547,13 +686,13 @@ Examples:
 - Search for function definitions with "function.*handleClick"
 - Search case-insensitively with ignoreCase: true
 `,
-  schema: z2.z.object({
-    pattern: z2.z.string().describe("Regex pattern to search for in file contents"),
-    ignoreCase: z2.z.boolean().optional().describe("Case-insensitive search (default: false)"),
-    maxMatches: z2.z.number().optional().describe("Maximum number of matches to return (default: 50)"),
-    includePatterns: z2.z.array(z2.z.string()).optional().describe("Glob patterns to include (e.g., ['*.ts', '*.js'])"),
-    excludePatterns: z2.z.array(z2.z.string()).optional().describe("Glob patterns to exclude (e.g., ['*.test.ts'])"),
-    contextLines: z2.z.number().optional().describe("Number of context lines to show around matches")
+  schema: z.object({
+    pattern: z.string().describe("Regex pattern to search for in file contents"),
+    ignoreCase: z.boolean().optional().describe("Case-insensitive search (default: false)"),
+    maxMatches: z.number().optional().describe("Maximum number of matches to return (default: 50)"),
+    includePatterns: z.array(z.string()).optional().describe("Glob patterns to include (e.g., ['*.ts', '*.js'])"),
+    excludePatterns: z.array(z.string()).optional().describe("Glob patterns to exclude (e.g., ['*.test.ts'])"),
+    contextLines: z.number().optional().describe("Number of context lines to show around matches")
   }),
   strict: true
 };
@@ -571,12 +710,12 @@ The tool returns the file content in an appropriate format:
 - Images: Base64-encoded image data
 - PDFs: Extracted text content
 `,
-  schema: z2.z.object({
-    path: z2.z.string().describe("Virtual path to the file to read"),
-    offset: z2.z.number().optional().describe(
+  schema: z.object({
+    path: z.string().describe("Virtual path to the file to read"),
+    offset: z.number().optional().describe(
       "Line number to start reading from (1-indexed, for text files)"
     ),
-    limit: z2.z.number().optional().describe("Maximum number of lines to read (for text files)")
+    limit: z.number().optional().describe("Maximum number of lines to read (for text files)")
   }),
   strict: true
 };
@@ -594,9 +733,9 @@ IMPORTANT:
 - This is an atomic write operation - the entire file is replaced
 - Path must be absolute (e.g., "/docs/readme.md", not "docs/readme.md")
 `,
-  schema: z2.z.object({
-    file_path: z2.z.string().describe("The absolute virtual path to the file to write"),
-    content: z2.z.string().describe("The content to write to the file")
+  schema: z.object({
+    file_path: z.string().describe("The absolute virtual path to the file to write"),
+    content: z.string().describe("The content to write to the file")
   }),
   strict: true
 };
@@ -616,392 +755,137 @@ IMPORTANT:
 - The operation fails if old_string is not found
 - old_string and new_string must be different
 `,
-  schema: z2.z.object({
-    file_path: z2.z.string().describe("The absolute virtual path to the file to modify"),
-    old_string: z2.z.string().describe("The exact text to replace"),
-    new_string: z2.z.string().describe(
+  schema: z.object({
+    file_path: z.string().describe("The absolute virtual path to the file to modify"),
+    old_string: z.string().describe("The exact text to replace"),
+    new_string: z.string().describe(
       "The text to replace it with (must be different from old_string)"
     ),
-    replace_all: z2.z.boolean().optional().describe(
+    replace_all: z.boolean().optional().describe(
       "If true, replace all occurrences of old_string (default: false)"
     )
   }),
   strict: true
 };
 
-// src/lib/filesystem/types.ts
-function fileContentToMessageContent(content) {
-  switch (content.type) {
-    case "text":
-      return [{ type: "text", text: content.content }];
-    case "image":
-      return [
-        {
-          type: "image_url",
-          image_url: {
-            url: `data:${content.mimeType};base64,${content.data}`
-          }
-        }
-      ];
-    case "pdf":
-      return [{ type: "text", text: content.content }];
-  }
-}
-var DEFAULT_HEADER = "Available files and directories:";
-var DEFAULT_DESCRIPTION = "You have access to the following files. Use the Read, Glob, and Grep tools to explore them.";
-function isExcluded(path, excludePatterns) {
-  if (!excludePatterns || excludePatterns.length === 0) {
-    return false;
-  }
-  return excludePatterns.some((pattern) => minimatch.minimatch(path, pattern));
-}
-function renderNode(node, options, depth, indent) {
-  const lines = [];
-  if (options.maxDepth !== void 0 && depth > options.maxDepth) {
-    return lines;
-  }
-  if (isExcluded(node.path, options.excludePatterns)) {
-    return lines;
-  }
-  const parts = node.path.split("/");
-  const name = parts[parts.length - 1] || node.path;
-  let line = indent;
-  if (node.type === "directory") {
-    line += `${name}/`;
-  } else {
-    line += name;
-  }
-  if (options.showMimeTypes && node.mimeType) {
-    line += ` [${node.mimeType}]`;
-  }
-  if (options.showDescriptions !== false && node.description) {
-    line += ` - ${node.description}`;
-  }
-  lines.push(line);
-  if (node.type === "directory" && node.children) {
-    const childIndent = indent + "  ";
-    for (const child of node.children) {
-      lines.push(...renderNode(child, options, depth + 1, childIndent));
-    }
-  }
-  return lines;
+// src/tools/task-create/handler.ts
+function createTaskCreateHandler({
+  stateManager,
+  idGenerator
+}) {
+  return (args) => {
+    const task = {
+      id: idGenerator(),
+      subject: args.subject,
+      description: args.description,
+      activeForm: args.activeForm,
+      status: "pending",
+      metadata: args.metadata ?? {},
+      blockedBy: [],
+      blocks: []
+    };
+    stateManager.setTask(task);
+    return {
+      content: JSON.stringify(task, null, 2),
+      result: task
+    };
+  };
 }
-function buildFileTreePrompt(nodes, options = {}) {
-  const header = options.headerText ?? DEFAULT_HEADER;
-  const description = options.descriptionText ?? DEFAULT_DESCRIPTION;
-  const lines = [];
-  for (const node of nodes) {
-    lines.push(...renderNode(node, options, 0, ""));
-  }
-  if (lines.length === 0) {
-    return `<file_system>
-${header}
-
-${description}
-
-(no files available)
-</file_system>`;
-  }
-  return `<file_system>
-${header}
+var taskGetTool = {
+  name: "TaskGet",
+  description: `Retrieve full task details including dependencies.`,
+  schema: z4.object({
+    taskId: z4.string().describe("The ID of the task to get")
+  })
+};
 
-${lines.join("\n")}
-</file_system>`;
-}
-function flattenFileTree(nodes) {
-  const paths = [];
-  function traverse(node) {
-    if (node.type === "file") {
-      paths.push(node.path);
-    }
-    if (node.children) {
-      for (const child of node.children) {
-        traverse(child);
-      }
+// src/tools/task-get/handler.ts
+function createTaskGetHandler(stateManager) {
+  return (args) => {
+    const task = stateManager.getTask(args.taskId) ?? null;
+    if (!task) {
+      return {
+        content: JSON.stringify({ error: `Task not found: ${args.taskId}` }),
+        result: null
+      };
     }
-  }
-  for (const node of nodes) {
-    traverse(node);
-  }
-  return paths;
+    return {
+      content: JSON.stringify(task, null, 2),
+      result: task
+    };
+  };
 }
-function isPathInScope(path, scopedNodes) {
-  const allowedPaths = flattenFileTree(scopedNodes);
-  return allowedPaths.includes(path);
+var taskListTool = {
+  name: "TaskList",
+  description: `List all tasks with current state.`,
+  schema: z4.object({})
+};
+
+// src/tools/task-list/handler.ts
+function createTaskListHandler(stateManager) {
+  return (_args) => {
+    const taskList = stateManager.getTasks();
+    return {
+      content: JSON.stringify(taskList, null, 2),
+      result: taskList
+    };
+  };
 }
-function findNodeByPath(path, nodes) {
-  for (const node of nodes) {
-    if (node.path === path) {
-      return node;
-    }
-    if (node.children) {
-      const found = findNodeByPath(path, node.children);
-      if (found) {
-        return found;
-      }
+var taskUpdateTool = {
+  name: "TaskUpdate",
+  description: `Update status, add blockers, modify details.`,
+  schema: z4.object({
+    taskId: z4.string().describe("The ID of the task to get"),
+    status: z4.enum(["pending", "in_progress", "completed"]).describe("The status of the task"),
+    addBlockedBy: z4.array(z4.string()).describe("The IDs of the tasks that are blocking this task"),
+    addBlocks: z4.array(z4.string()).describe("The IDs of the tasks that this task is blocking")
+  })
+};
+
+// src/tools/task-update/handler.ts
+function createTaskUpdateHandler(stateManager) {
+  return (args) => {
+    const task = stateManager.getTask(args.taskId);
+    if (!task) {
+      return {
+        content: JSON.stringify({ error: `Task not found: ${args.taskId}` }),
+        result: null
+      };
     }
-  }
-  return void 0;
-}
-var BaseFileSystemProvider = class {
-  scopedNodes;
-  allowedPaths;
-  constructor(scopedNodes) {
-    this.scopedNodes = scopedNodes;
-    this.allowedPaths = new Set(flattenFileTree(scopedNodes));
-  }
-  /**
-   * Validate that a path is within the allowed scope.
-   * Throws an error if the path is not allowed.
-   */
-  validatePath(path) {
-    if (!this.allowedPaths.has(path)) {
-      throw new Error(`Path "${path}" is not within the allowed scope`);
+    if (args.status) {
+      task.status = args.status;
     }
-  }
-  /**
-   * Filter paths by glob pattern.
-   */
-  filterByPattern(paths, pattern, root) {
-    const effectivePattern = root ? `${root}/${pattern}` : pattern;
-    return paths.filter((path) => {
-      if (root && !path.startsWith(root)) {
-        return false;
-      }
-      return minimatch.minimatch(path, effectivePattern, { matchBase: true });
-    });
-  }
-  /**
-   * Get all file paths in scope
-   */
-  getAllPaths() {
-    return Array.from(this.allowedPaths);
-  }
-  /**
-   * Find FileNode by path
-   */
-  findNode(path) {
-    const findInNodes = (nodes) => {
-      for (const node of nodes) {
-        if (node.path === path) {
-          return node;
+    if (args.addBlockedBy) {
+      for (const blockerId of args.addBlockedBy) {
+        if (!task.blockedBy.includes(blockerId)) {
+          task.blockedBy.push(blockerId);
         }
-        if (node.children) {
-          const found = findInNodes(node.children);
-          if (found) return found;
+        const blockerTask = stateManager.getTask(blockerId);
+        if (blockerTask && !blockerTask.blocks.includes(task.id)) {
+          blockerTask.blocks.push(task.id);
+          stateManager.setTask(blockerTask);
         }
       }
-      return void 0;
-    };
-    return findInNodes(this.scopedNodes);
-  }
-  /**
-   * Read file as text for grep operations.
-   * Default implementation uses readFile, but can be overridden for efficiency.
-   */
-  async readFileAsText(node) {
-    try {
-      const content = await this.readFile(node);
-      if (content.type === "text") {
-        return content.content;
-      }
-      if (content.type === "pdf") {
-        return content.content;
-      }
-      return null;
-    } catch {
-      return null;
     }
-  }
-  // ============================================================================
-  // FileSystemProvider implementation
-  // ============================================================================
-  async glob(pattern, root) {
-    const allPaths = this.getAllPaths();
-    const matchingPaths = this.filterByPattern(allPaths, pattern, root);
-    return matchingPaths.map((path) => this.findNode(path)).filter((node) => node !== void 0);
-  }
-  async grep(pattern, options) {
-    const matches = [];
-    const maxMatches = options?.maxMatches ?? 50;
-    const flags = options?.ignoreCase ? "gi" : "g";
-    let regex;
-    try {
-      regex = new RegExp(pattern, flags);
-    } catch {
-      throw new Error(`Invalid regex pattern: ${pattern}`);
-    }
-    let paths = this.getAllPaths();
-    if (options?.includePatterns?.length) {
-      const includePatterns = options.includePatterns;
-      paths = paths.filter(
-        (path) => includePatterns.some((p) => minimatch.minimatch(path, p, { matchBase: true }))
-      );
-    }
-    if (options?.excludePatterns?.length) {
-      const excludePatterns = options.excludePatterns;
-      paths = paths.filter(
-        (path) => !excludePatterns.some((p) => minimatch.minimatch(path, p, { matchBase: true }))
-      );
-    }
-    for (const path of paths) {
-      if (matches.length >= maxMatches) break;
-      const node = this.findNode(path);
-      if (!node || node.type !== "file") continue;
-      const text = await this.readFileAsText(node);
-      if (!text) continue;
-      const lines = text.split("\n");
-      for (let i = 0; i < lines.length; i++) {
-        if (matches.length >= maxMatches) break;
-        const line = lines[i];
-        if (line === void 0) continue;
-        if (regex.test(line)) {
-          regex.lastIndex = 0;
-          const match = {
-            path,
-            lineNumber: i + 1,
-            line: line.trim()
-          };
-          if (options?.contextLines && options.contextLines > 0) {
-            const contextBefore = [];
-            const contextAfter = [];
-            for (let j = Math.max(0, i - options.contextLines); j < i; j++) {
-              const contextLine = lines[j];
-              if (contextLine !== void 0) {
-                contextBefore.push(contextLine.trim());
-              }
-            }
-            for (let j = i + 1; j <= Math.min(lines.length - 1, i + options.contextLines); j++) {
-              const contextLine = lines[j];
-              if (contextLine !== void 0) {
-                contextAfter.push(contextLine.trim());
-              }
-            }
-            match.contextBefore = contextBefore;
-            match.contextAfter = contextAfter;
-          }
-          matches.push(match);
+    if (args.addBlocks) {
+      for (const blockedId of args.addBlocks) {
+        if (!task.blocks.includes(blockedId)) {
+          task.blocks.push(blockedId);
+        }
+        const blockedTask = stateManager.getTask(blockedId);
+        if (blockedTask && !blockedTask.blockedBy.includes(task.id)) {
+          blockedTask.blockedBy.push(task.id);
+          stateManager.setTask(blockedTask);
         }
       }
     }
-    return matches;
-  }
-  async read(path) {
-    this.validatePath(path);
-    const node = this.findNode(path);
-    if (!node) {
-      throw new Error(`File not found: ${path}`);
-    }
-    if (node.type !== "file") {
-      throw new Error(`Path is a directory, not a file: ${path}`);
-    }
-    return this.readFile(node);
-  }
-  async exists(path) {
-    return this.allowedPaths.has(path);
-  }
-};
-var InMemoryFileSystemProvider = class _InMemoryFileSystemProvider extends BaseFileSystemProvider {
-  files;
-  constructor(scopedNodes, files) {
-    super(scopedNodes);
-    this.files = files;
-  }
-  async readFile(node) {
-    const content = this.files.get(node.path);
-    if (!content) {
-      throw new Error(`File not found in storage: ${node.path}`);
-    }
-    return content;
-  }
-  /**
-   * Add or update a file in the in-memory storage
-   */
-  setFile(path, content) {
-    this.files.set(path, content);
-  }
-  /**
-   * Write text content to a file
-   */
-  async write(path, content) {
-    this.validatePath(path);
-    this.files.set(path, { type: "text", content });
-  }
-  /**
-   * Create an InMemoryFileSystemProvider from a simple object map
-   */
-  static fromTextFiles(scopedNodes, files) {
-    const fileMap = /* @__PURE__ */ new Map();
-    for (const [path, content] of Object.entries(files)) {
-      fileMap.set(path, { type: "text", content });
-    }
-    return new _InMemoryFileSystemProvider(scopedNodes, fileMap);
-  }
-};
-var CompositeFileSystemProvider = class extends BaseFileSystemProvider {
-  backends;
-  defaultBackend;
-  defaultResolver;
-  constructor(scopedNodes, config) {
-    super(scopedNodes);
-    this.backends = new Map(Object.entries(config.backends));
-    this.defaultBackend = config.defaultBackend;
-    this.defaultResolver = config.defaultResolver;
-  }
-  /**
-   * Get the backend name for a file node
-   */
-  getBackendName(node) {
-    const backend = node.metadata?.backend;
-    if (typeof backend === "string") {
-      return backend;
-    }
-    return this.defaultBackend;
-  }
-  /**
-   * Resolve content using a resolver (function or provider)
-   */
-  async resolveContent(resolver, node) {
-    if (typeof resolver === "function") {
-      return resolver(node);
-    }
-    return resolver.read(node.path);
-  }
-  async readFile(node) {
-    const backendName = this.getBackendName(node);
-    if (backendName) {
-      const config = this.backends.get(backendName);
-      if (config) {
-        return this.resolveContent(config.resolver, node);
-      }
-    }
-    if (this.defaultResolver) {
-      return this.defaultResolver(node);
-    }
-    const availableBackends = Array.from(this.backends.keys()).join(", ");
-    throw new Error(
-      `No resolver for file "${node.path}". Backend: ${backendName ?? "(none)"}. Available backends: ${availableBackends || "(none)"}`
-    );
-  }
-  /**
-   * Add or update a backend configuration
-   */
-  setBackend(name, config) {
-    this.backends.set(name, config);
-  }
-  /**
-   * Remove a backend
-   */
-  removeBackend(name) {
-    return this.backends.delete(name);
-  }
-  /**
-   * Check if a backend exists
-   */
-  hasBackend(name) {
-    return this.backends.has(name);
-  }
-};
+    stateManager.setTask(task);
+    return {
+      content: JSON.stringify(task, null, 2),
+      result: task
+    };
+  };
+}
 
 // node_modules/uuid/dist/esm-node/stringify.js
 var byteToHex = [];
@@ -1015,13 +899,13 @@ var rnds8Pool = new Uint8Array(256);
 var poolPtr = rnds8Pool.length;
 function rng() {
   if (poolPtr > rnds8Pool.length - 16) {
-    crypto__default.default.randomFillSync(rnds8Pool);
+    crypto.randomFillSync(rnds8Pool);
     poolPtr = 0;
   }
   return rnds8Pool.slice(poolPtr, poolPtr += 16);
 }
 var native_default = {
-  randomUUID: crypto__default.default.randomUUID
+  randomUUID: crypto.randomUUID
 };
 
 // node_modules/uuid/dist/esm-node/v4.js
@@ -1070,13 +954,13 @@ function createThreadManager(config) {
       await redis.del(redisKey);
     },
     createHumanMessage(content) {
-      return new messages.HumanMessage({
+      return new HumanMessage({
         id: v4_default(),
         content
       }).toDict();
     },
     createAIMessage(content, kwargs) {
-      return new messages.AIMessage({
+      return new AIMessage({
         id: v4_default(),
         content,
         additional_kwargs: kwargs ? {
@@ -1087,12 +971,21 @@ function createThreadManager(config) {
       }).toDict();
     },
     createToolMessage(content, toolCallId) {
-      return new messages.ToolMessage({
+      return new ToolMessage({
         // Cast needed due to langchain type compatibility
         content,
         tool_call_id: toolCallId
       }).toDict();
     },
+    createSystemMessage(content) {
+      return new SystemMessage({
+        content
+      }).toDict();
+    },
+    async appendSystemMessage(content) {
+      const message = this.createSystemMessage(content);
+      await this.append([message]);
+    },
     async appendHumanMessage(content) {
       const message = this.createHumanMessage(content);
       await this.append([message]);
@@ -1109,6 +1002,10 @@ function createThreadManager(config) {
 }
 function createSharedActivities(redis) {
   return {
+    async appendSystemMessage(threadId, content) {
+      const thread = createThreadManager({ redis, threadId });
+      await thread.appendSystemMessage(content);
+    },
     async appendToolResult(config) {
       const { threadId, toolCallId, content } = config;
       const thread = createThreadManager({ redis, threadId });
@@ -1127,7 +1024,7 @@ function createSharedActivities(redis) {
       await thread.appendHumanMessage(content);
     },
     async parseToolCalls(storedMessage) {
-      const message = messages.mapStoredMessageToChatMessage(storedMessage);
+      const message = mapStoredMessageToChatMessage(storedMessage);
       const toolCalls = message.tool_calls ?? [];
       return toolCalls.map((toolCall) => ({
         id: toolCall.id,
@@ -1139,7 +1036,7 @@ function createSharedActivities(redis) {
 }
 
 // src/plugin.ts
-var ZeitlichPlugin = class extends plugin.SimplePlugin {
+var ZeitlichPlugin = class extends SimplePlugin {
   constructor(options) {
     super({
       name: "ZeitlichPlugin",
@@ -1147,15 +1044,22 @@ var ZeitlichPlugin = class extends plugin.SimplePlugin {
     });
   }
 };
-async function invokeModel(redis, { threadId, agentName, tools }, model, { systemPrompt }) {
+async function invokeModel({
+  redis,
+  model,
+  client,
+  config: { threadId, agentName }
+}) {
   const thread = createThreadManager({ redis, threadId });
   const runId = v4_default();
-  const messages$1 = await thread.load();
+  const info = Context.current().info;
+  const parentWorkflowId = info.workflowExecution.workflowId;
+  const parentRunId = info.workflowExecution.runId;
+  const handle = client.getHandle(parentWorkflowId, parentRunId);
+  const { tools } = await handle.query(getStateQuery);
+  const messages = await thread.load();
   const response = await model.invoke(
-    [
-      new messages.SystemMessage(systemPrompt),
-      ...messages.mapStoredMessagesToChatMessages(messages$1)
-    ],
+    [...mapStoredMessagesToChatMessages(messages)],
     {
       runName: agentName,
       runId,
@@ -1175,8 +1079,8 @@ async function invokeModel(redis, { threadId, agentName, tools }, model, { syste
   };
 }
 var handleAskUserQuestionToolResult = async (args) => {
-  const messages$1 = args.questions.map(
-    ({ question, header, options, multiSelect }) => new messages.AIMessage({
+  const messages = args.questions.map(
+    ({ question, header, options, multiSelect }) => new AIMessage({
       content: question,
       additional_kwargs: {
         header,
@@ -1185,292 +1089,37 @@ var handleAskUserQuestionToolResult = async (args) => {
       }
     }).toDict()
   );
-  return { content: "Question submitted", result: { chatMessages: messages$1 } };
+  return { content: "Question submitted", result: { chatMessages: messages } };
 };
-
-// src/tools/glob/handler.ts
-function createGlobHandler(config) {
-  return async (args) => {
-    const { pattern, root } = args;
-    try {
-      const matches = await config.provider.glob(pattern, root);
-      if (matches.length === 0) {
-        return {
-          content: `No files found matching pattern: ${pattern}`,
-          result: { files: [] }
-        };
-      }
-      const paths = matches.map((node) => node.path);
-      const fileList = paths.map((p) => `  ${p}`).join("\n");
-      return {
-        content: `Found ${matches.length} file(s) matching "${pattern}":
-${fileList}`,
-        result: { files: matches }
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      return {
-        content: `Error searching for files: ${message}`,
-        result: { files: [] }
-      };
-    }
-  };
-}
-
-// src/tools/grep/handler.ts
-function formatMatch(match, showContext) {
-  const lines = [];
-  if (showContext && match.contextBefore?.length) {
-    for (let i = 0; i < match.contextBefore.length; i++) {
-      const lineNum = match.lineNumber - match.contextBefore.length + i;
-      lines.push(`${match.path}:${lineNum}-${match.contextBefore[i]}`);
-    }
-  }
-  lines.push(`${match.path}:${match.lineNumber}:${match.line}`);
-  if (showContext && match.contextAfter?.length) {
-    for (let i = 0; i < match.contextAfter.length; i++) {
-      const lineNum = match.lineNumber + 1 + i;
-      lines.push(`${match.path}:${lineNum}-${match.contextAfter[i]}`);
-    }
-  }
-  return lines.join("\n");
-}
-function createGrepHandler(config) {
-  return async (args) => {
-    const {
-      pattern,
-      ignoreCase,
-      maxMatches,
-      includePatterns,
-      excludePatterns,
-      contextLines
-    } = args;
-    try {
-      const matches = await config.provider.grep(pattern, {
-        ignoreCase,
-        maxMatches: maxMatches ?? 50,
-        includePatterns,
-        excludePatterns,
-        contextLines
-      });
-      if (matches.length === 0) {
-        return {
-          content: `No matches found for pattern: ${pattern}`,
-          result: { matches: [] }
-        };
-      }
-      const showContext = contextLines !== void 0 && contextLines > 0;
-      const formattedMatches = matches.map((m) => formatMatch(m, showContext)).join("\n");
-      return {
-        content: `Found ${matches.length} match(es) for "${pattern}":
-
-${formattedMatches}`,
-        result: { matches }
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      return {
-        content: `Error searching file contents: ${message}`,
-        result: { matches: [] }
-      };
-    }
-  };
-}
-
-// src/tools/read/handler.ts
-function applyTextRange(content, offset, limit) {
-  if (offset === void 0 && limit === void 0) {
-    return content;
-  }
-  const lines = content.split("\n");
-  const startLine = offset !== void 0 ? Math.max(0, offset - 1) : 0;
-  const endLine = limit !== void 0 ? startLine + limit : lines.length;
-  const selectedLines = lines.slice(startLine, endLine);
-  return selectedLines.map((line, i) => {
-    const lineNum = (startLine + i + 1).toString().padStart(6, " ");
-    return `${lineNum}|${line}`;
-  }).join("\n");
-}
-function createReadHandler(config) {
-  return async (args) => {
-    const { path, offset, limit } = args;
-    if (!isPathInScope(path, config.scopedNodes)) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: Path "${path}" is not within the available file system scope.`
-          }
-        ],
-        result: {
-          path,
-          content: {
-            type: "text",
-            content: "Error: Path is not within the available file system scope."
-          }
-        }
-      };
-    }
-    try {
-      const exists = await config.provider.exists(path);
-      if (!exists) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: File "${path}" does not exist.`
-            }
-          ],
-          result: {
-            path,
-            content: { type: "text", content: "Error: File does not exist." }
-          }
-        };
-      }
-      const fileContent = await config.provider.read(path);
-      if (fileContent.type === "text") {
-        const processedContent = applyTextRange(
-          fileContent.content,
-          offset,
-          limit
-        );
-        let header = `File: ${path}`;
-        if (offset !== void 0 || limit !== void 0) {
-          const startLine = offset ?? 1;
-          const endInfo = limit ? `, showing ${limit} lines` : "";
-          header += ` (from line ${startLine}${endInfo})`;
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: `${header}
-
-${processedContent}`
-            }
-          ],
-          result: {
-            path,
-            content: {
-              type: "text",
-              content: `${header}
-
-${processedContent}`
-            }
-          }
-        };
-      }
-      const messageContent = fileContentToMessageContent(fileContent);
-      return {
-        content: [
-          {
-            type: "text",
-            text: `File: ${path} (${fileContent.type})`
-          },
-          ...messageContent
-        ],
-        result: { path, content: fileContent }
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error reading file "${path}": ${message}`
-          }
-        ],
-        result: {
-          path,
-          content: {
-            type: "text",
-            content: `Error reading file "${path}": ${message}`
-          }
-        }
-      };
-    }
-  };
-}
-
-// src/tools/write/handler.ts
-function createWriteHandler(config) {
-  return async (args) => {
-    const { file_path, content } = args;
-    if (!isPathInScope(file_path, config.scopedNodes)) {
-      return {
-        content: `Error: Path "${file_path}" is not within the available file system scope.`,
-        result: {
-          path: file_path,
-          success: false,
-          created: false,
-          bytesWritten: 0
-        }
-      };
-    }
-    if (!config.skipReadCheck && !config.readFiles.has(file_path)) {
-      const exists = await config.provider.exists(file_path);
-      if (exists) {
-        return {
-          content: `Error: You must read "${file_path}" before writing to it. Use FileRead first.`,
-          result: {
-            path: file_path,
-            success: false,
-            created: false,
-            bytesWritten: 0
-          }
-        };
-      }
-    }
-    try {
-      const exists = await config.provider.exists(file_path);
-      if (!config.provider.write) {
-        return {
-          content: `Error: The file system provider does not support write operations.`,
-          result: {
-            path: file_path,
-            success: false,
-            created: false,
-            bytesWritten: 0
-          }
-        };
-      }
-      await config.provider.write(file_path, content);
-      const bytesWritten = Buffer.byteLength(content, "utf-8");
-      const action = exists ? "Updated" : "Created";
-      return {
-        content: `${action} file: ${file_path} (${bytesWritten} bytes)`,
-        result: {
-          path: file_path,
-          success: true,
-          created: !exists,
-          bytesWritten
-        }
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      return {
-        content: `Error writing file "${file_path}": ${message}`,
-        result: {
-          path: file_path,
-          success: false,
-          created: false,
-          bytesWritten: 0
-        }
-      };
-    }
-  };
+async function globHandler(_args, fs) {
+  new Bash({ fs });
+  return Promise.resolve({
+    content: "Hello, world!",
+    result: { files: [] }
+  });
 }
 
 // src/tools/edit/handler.ts
 function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function createEditHandler(config) {
-  return async (args) => {
-    const { file_path, old_string, new_string, replace_all = false } = args;
-    if (old_string === new_string) {
+async function editHandler(args, fs) {
+  const { file_path, old_string, new_string, replace_all = false } = args;
+  if (old_string === new_string) {
+    return {
+      content: `Error: old_string and new_string must be different.`,
+      result: {
+        path: file_path,
+        success: false,
+        replacements: 0
+      }
+    };
+  }
+  try {
+    const exists = await fs.exists(file_path);
+    if (!exists) {
       return {
-        content: `Error: old_string and new_string must be different.`,
+        content: `Error: File "${file_path}" does not exist.`,
         result: {
           path: file_path,
           success: false,
@@ -1478,9 +1127,10 @@ function createEditHandler(config) {
         }
       };
     }
-    if (!isPathInScope(file_path, config.scopedNodes)) {
+    const content = await fs.readFile(file_path);
+    if (!content.includes(old_string)) {
       return {
-        content: `Error: Path "${file_path}" is not within the available file system scope.`,
+        content: `Error: Could not find the specified text in "${file_path}". Make sure old_string matches exactly (whitespace-sensitive).`,
         result: {
           path: file_path,
           success: false,
@@ -1488,9 +1138,12 @@ function createEditHandler(config) {
         }
       };
     }
-    if (!config.skipReadCheck && !config.readFiles.has(file_path)) {
+    const escapedOldString = escapeRegExp(old_string);
+    const globalRegex = new RegExp(escapedOldString, "g");
+    const occurrences = (content.match(globalRegex) || []).length;
+    if (!replace_all && occurrences > 1) {
       return {
-        content: `Error: You must read "${file_path}" before editing it. Use FileRead first.`,
+        content: `Error: old_string appears ${occurrences} times in "${file_path}". Either provide more context to make it unique, or use replace_all: true.`,
         result: {
           path: file_path,
           success: false,
@@ -1498,131 +1151,128 @@ function createEditHandler(config) {
         }
       };
     }
-    try {
-      const exists = await config.provider.exists(file_path);
-      if (!exists) {
-        return {
-          content: `Error: File "${file_path}" does not exist.`,
-          result: {
-            path: file_path,
-            success: false,
-            replacements: 0
-          }
-        };
-      }
-      if (!config.provider.write) {
-        return {
-          content: `Error: The file system provider does not support write operations.`,
-          result: {
-            path: file_path,
-            success: false,
-            replacements: 0
-          }
-        };
-      }
-      const fileContent = await config.provider.read(file_path);
-      if (fileContent.type !== "text") {
-        return {
-          content: `Error: FileEdit only works with text files. "${file_path}" is ${fileContent.type}.`,
-          result: {
-            path: file_path,
-            success: false,
-            replacements: 0
-          }
-        };
-      }
-      const content = fileContent.content;
-      if (!content.includes(old_string)) {
-        return {
-          content: `Error: Could not find the specified text in "${file_path}". Make sure old_string matches exactly (whitespace-sensitive).`,
-          result: {
-            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 {
-          content: `Error: old_string appears ${occurrences} times in "${file_path}". Either provide more context to make it unique, or use replace_all: true.`,
-          result: {
-            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 {
+      content: `${summary} in ${file_path}`,
+      result: {
+        path: file_path,
+        success: true,
+        replacements
       }
-      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;
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      content: `Error editing file "${file_path}": ${message}`,
+      result: {
+        path: file_path,
+        success: false,
+        replacements: 0
       }
-      await config.provider.write(file_path, newContent);
-      const summary = replace_all ? `Replaced ${replacements} occurrence(s)` : `Replaced 1 occurrence`;
-      return {
-        content: `${summary} in ${file_path}`,
-        result: {
-          path: file_path,
-          success: true,
-          replacements
-        }
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      return {
-        content: `Error editing file "${file_path}": ${message}`,
-        result: {
-          path: file_path,
-          success: false,
-          replacements: 0
+    };
+  }
+}
+var handleBashTool = (fs) => async (args, _context) => {
+  const { command } = args;
+  const bashOptions = fs ? { fs } : {};
+  const bash = new Bash(bashOptions);
+  try {
+    const { exitCode, stderr, stdout } = await bash.exec(command);
+    const bashExecOut = { exitCode, stderr, stdout };
+    return {
+      content: `Exit code: ${exitCode}
+
+stdout:
+${stdout}
+
+stderr:
+${stderr}`,
+      result: bashExecOut
+    };
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error("Unknown error");
+    return {
+      content: `Error executing bash command: ${err.message}`,
+      result: null
+    };
+  }
+};
+
+// src/lib/fs.ts
+var basename = (path, separator) => {
+  if (path[path.length - 1] === separator) path = path.slice(0, -1);
+  const lastSlashIndex = path.lastIndexOf(separator);
+  return lastSlashIndex === -1 ? path : path.slice(lastSlashIndex + 1);
+};
+var printTree = async (tab = "", children) => {
+  let str = "";
+  let last = children.length - 1;
+  for (; last >= 0; last--) if (children[last]) break;
+  for (let i = 0; i <= last; i++) {
+    const fn = children[i];
+    if (!fn) continue;
+    const isLast = i === last;
+    const child = await fn(tab + (isLast ? " " : "\u2502") + "  ");
+    const branch = child ? isLast ? "\u2514\u2500" : "\u251C\u2500" : "\u2502";
+    str += "\n" + tab + branch + (child ? " " + child : "");
+  }
+  return str;
+};
+var toTree = async (fs, opts = {}) => {
+  const separator = opts.separator || "/";
+  let dir = opts.dir || separator;
+  if (dir[dir.length - 1] !== separator) dir += separator;
+  const tab = opts.tab || "";
+  const depth = opts.depth ?? 10;
+  const sort = opts.sort ?? true;
+  let subtree = " (...)";
+  if (depth > 0) {
+    const list = await fs.readdirWithFileTypes?.(dir) || [];
+    if (sort) {
+      list.sort((a, b) => {
+        if (a.isDirectory && b.isDirectory) {
+          return a.name.toString().localeCompare(b.name.toString());
+        } else if (a.isDirectory) {
+          return -1;
+        } else if (b.isDirectory) {
+          return 1;
+        } else {
+          return a.name.toString().localeCompare(b.name.toString());
         }
-      };
+      });
     }
-  };
-}
+    subtree = await printTree(
+      tab,
+      list.map((entry) => async (tab2) => {
+        if (entry.isDirectory) {
+          return toTree(fs, {
+            dir: dir + entry.name,
+            depth: depth - 1,
+            tab: tab2
+          });
+        } else if (entry.isSymbolicLink) {
+          return "" + entry.name + " \u2192 " + await fs.readlink(dir + entry.name);
+        } else {
+          return "" + entry.name;
+        }
+      })
+    );
+  }
+  const base = basename(dir, separator) + separator;
+  return base + subtree;
+};
 
-exports.AGENT_HANDLER_NAMES = AGENT_HANDLER_NAMES;
-exports.BaseFileSystemProvider = BaseFileSystemProvider;
-exports.CompositeFileSystemProvider = CompositeFileSystemProvider;
-exports.InMemoryFileSystemProvider = InMemoryFileSystemProvider;
-exports.ZeitlichPlugin = ZeitlichPlugin;
-exports.askUserQuestionTool = askUserQuestionTool;
-exports.buildFileTreePrompt = buildFileTreePrompt;
-exports.createAgentStateManager = createAgentStateManager;
-exports.createEditHandler = createEditHandler;
-exports.createGlobHandler = createGlobHandler;
-exports.createGrepHandler = createGrepHandler;
-exports.createPromptManager = createPromptManager;
-exports.createReadHandler = createReadHandler;
-exports.createSession = createSession;
-exports.createSharedActivities = createSharedActivities;
-exports.createTaskHandler = createTaskHandler;
-exports.createTaskTool = createTaskTool;
-exports.createToolRegistry = createToolRegistry;
-exports.createToolRouter = createToolRouter;
-exports.createWriteHandler = createWriteHandler;
-exports.editTool = editTool;
-exports.fileContentToMessageContent = fileContentToMessageContent;
-exports.findNodeByPath = findNodeByPath;
-exports.flattenFileTree = flattenFileTree;
-exports.globTool = globTool;
-exports.grepTool = grepTool;
-exports.handleAskUserQuestionToolResult = handleAskUserQuestionToolResult;
-exports.hasNoOtherToolCalls = hasNoOtherToolCalls;
-exports.hasTaskTool = hasTaskTool;
-exports.invokeModel = invokeModel;
-exports.isPathInScope = isPathInScope;
-exports.isTerminalStatus = isTerminalStatus;
-exports.readTool = readTool;
-exports.withSubagentSupport = withSubagentSupport;
-exports.writeTool = writeTool;
+export { AGENT_HANDLER_NAMES, ZeitlichPlugin, askUserQuestionTool, bashTool, createAgentStateManager, createSession, createSharedActivities, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskTool, createTaskUpdateHandler, createToolRouter, editHandler, editTool, globHandler, globTool, grepTool, handleAskUserQuestionToolResult, handleBashTool, hasNoOtherToolCalls, invokeModel, isTerminalStatus, readTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, toTree, writeTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map