zeitlich 0.1.1 → 0.2.0

package/dist/workflow.js

@@ -1,12 +1,5 @@
-'use strict';
-
-var workflow = require('@temporalio/workflow');
-var z2 = require('zod');
-var minimatch = require('minimatch');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var z2__default = /*#__PURE__*/_interopDefault(z2);
+import { defineQuery, proxyActivities, setHandler, workflowInfo, uuid4, executeChild } from '@temporalio/workflow';
+import z4, { z } from 'zod';
 
 // src/lib/session.ts
 var TASK_TOOL = "Task";
@@ -41,24 +34,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
@@ -74,35 +67,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;
     },
-    taskHandler
+    // --- Utility methods ---
+    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 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,
@@ -112,6 +402,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({
@@ -124,7 +424,7 @@ var createSession = async ({ threadId, agentName, maxTurns = 50, metadata = {} }
     }
   };
   return {
-    runSession: async (prompt, stateManager) => {
+    runSession: async ({ stateManager }) => {
       if (hooks.onSessionStart) {
         await hooks.onSessionStart({
           threadId,
@@ -132,43 +432,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;
@@ -194,19 +505,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;
@@ -261,222 +587,34 @@ function createAgentStateManager(config) {
     },
     shouldReturnFromWait(lastKnownVersion) {
       return version > lastKnownVersion || isTerminalStatus(status);
-    }
-  };
-}
-var AGENT_HANDLER_NAMES = {
-  getAgentState: "getAgentState",
-  waitForStateChange: "waitForStateChange",
-  addMessage: "addMessage"
-};
-
-// 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);
-    }
-  };
-}
-
-// 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);
+    getTasks() {
+      return Array.from(tasks.values());
     },
-    getTool(name) {
-      return tools[name];
+    getTask(id) {
+      return tasks.get(id);
     },
-    hasTool(name) {
-      return toolMap.has(name);
+    setTask(task) {
+      tasks.set(task.id, task);
+      version++;
     },
-    getToolNames() {
-      return Array.from(toolMap.keys());
-    }
-  };
-}
-
-// 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;
+    setTools(newTools) {
+      tools = newTools;
     },
-    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));
+    deleteTask(id) {
+      const deleted = tasks.delete(id);
+      if (deleted) {
+        version++;
       }
-      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
-      );
+      return deleted;
     }
   };
 }
-function hasNoOtherToolCalls(toolCalls, excludeName) {
-  return toolCalls.filter((tc) => tc.name !== excludeName).length === 0;
-}
+var AGENT_HANDLER_NAMES = {
+  getAgentState: "getAgentState",
+  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:
@@ -492,18 +630,18 @@ Usage notes:
 * 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()
+  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")
       })
     )
   }),
@@ -523,9 +661,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
 };
@@ -543,13 +681,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
 };
@@ -567,12 +705,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
 };
@@ -590,9 +728,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
 };
@@ -612,156 +750,138 @@ 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));
+// 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 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));
+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")
+  })
+};
+
+// 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
+      };
     }
-  }
-  return lines;
+    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 taskListTool = {
+  name: "TaskList",
+  description: `List all tasks with current state.`,
+  schema: z4.object({})
+};
 
-${lines.join("\n")}
-</file_system>`;
+// 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 flattenFileTree(nodes) {
-  const paths = [];
-  function traverse(node) {
-    if (node.type === "file") {
-      paths.push(node.path);
+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
+      };
     }
-    if (node.children) {
-      for (const child of node.children) {
-        traverse(child);
-      }
+    if (args.status) {
+      task.status = args.status;
     }
-  }
-  for (const node of nodes) {
-    traverse(node);
-  }
-  return paths;
-}
-function isPathInScope(path, scopedNodes) {
-  const allowedPaths = flattenFileTree(scopedNodes);
-  return allowedPaths.includes(path);
-}
-function findNodeByPath(path, 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);
+        }
+        const blockerTask = stateManager.getTask(blockerId);
+        if (blockerTask && !blockerTask.blocks.includes(task.id)) {
+          blockerTask.blocks.push(task.id);
+          stateManager.setTask(blockerTask);
+        }
+      }
     }
-    if (node.children) {
-      const found = findNodeByPath(path, node.children);
-      if (found) {
-        return found;
+    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 void 0;
+    stateManager.setTask(task);
+    return {
+      content: JSON.stringify(task, null, 2),
+      result: task
+    };
+  };
 }
 
-exports.AGENT_HANDLER_NAMES = AGENT_HANDLER_NAMES;
-exports.askUserQuestionTool = askUserQuestionTool;
-exports.buildFileTreePrompt = buildFileTreePrompt;
-exports.createAgentStateManager = createAgentStateManager;
-exports.createPromptManager = createPromptManager;
-exports.createSession = createSession;
-exports.createTaskHandler = createTaskHandler;
-exports.createTaskTool = createTaskTool;
-exports.createToolRegistry = createToolRegistry;
-exports.createToolRouter = createToolRouter;
-exports.editTool = editTool;
-exports.fileContentToMessageContent = fileContentToMessageContent;
-exports.findNodeByPath = findNodeByPath;
-exports.flattenFileTree = flattenFileTree;
-exports.globTool = globTool;
-exports.grepTool = grepTool;
-exports.hasNoOtherToolCalls = hasNoOtherToolCalls;
-exports.hasTaskTool = hasTaskTool;
-exports.isPathInScope = isPathInScope;
-exports.isTerminalStatus = isTerminalStatus;
-exports.readTool = readTool;
-exports.withSubagentSupport = withSubagentSupport;
-exports.writeTool = writeTool;
+export { AGENT_HANDLER_NAMES, askUserQuestionTool, bashTool, createAgentStateManager, createSession, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskTool, createTaskUpdateHandler, createToolRouter, editTool, globTool, grepTool, hasNoOtherToolCalls, isTerminalStatus, readTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, writeTool };
 //# sourceMappingURL=workflow.js.map
 //# sourceMappingURL=workflow.js.map