zeitlich 0.1.0 → 0.2.0

package/dist/workflow.cjs

@@ -0,0 +1,914 @@
+'use strict';
+
+var workflow = require('@temporalio/workflow');
+var z4 = require('zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var z4__default = /*#__PURE__*/_interopDefault(z4);
+
+// src/lib/session.ts
+var TASK_TOOL = "Task";
+function buildTaskDescription(subagents) {
+  const subagentList = subagents.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+  return `Launch a new agent to handle complex, multi-step tasks autonomously.
+
+The ${TASK_TOOL} tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.
+
+Available agent types:
+
+${subagentList}
+
+When using the ${TASK_TOOL} tool, you must specify a subagent parameter to select which agent type to use.
+
+Usage notes:
+
+- Always include a short description (3-5 words) summarizing what the agent will do
+- Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+- When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+- Each invocation starts fresh - provide a detailed task description with all necessary context.
+- Provide clear, detailed prompts so the agent can work autonomously and return exactly the information you need.
+- The agent's outputs should generally be trusted
+- Clearly tell the agent what type of work you expect since it is not aware of the user's intent
+- If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.`;
+}
+function createTaskTool(subagents) {
+  if (subagents.length === 0) {
+    throw new Error("createTaskTool requires at least one subagent");
+  }
+  const names = subagents.map((s) => s.name);
+  return {
+    name: TASK_TOOL,
+    description: buildTaskDescription(subagents),
+    schema: z4__default.default.object({
+      subagent: z4__default.default.enum(names).describe("The type of subagent to launch"),
+      description: z4__default.default.string().describe("A short (3-5 word) description of the task"),
+      prompt: z4__default.default.string().describe("The task for the agent to perform")
+    })
+  };
+}
+function createTaskHandler(subagents) {
+  const { workflowId: parentWorkflowId, taskQueue: parentTaskQueue } = workflow.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, {
+      workflowId: childWorkflowId,
+      args: [{ prompt: args.prompt }],
+      taskQueue: config.taskQueue ?? parentTaskQueue
+    });
+    const validated = config.resultSchema ? config.resultSchema.parse(childResult) : childResult;
+    const content = typeof validated === "string" ? validated : JSON.stringify(validated, null, 2);
+    return {
+      content,
+      result: {
+        result: validated,
+        childWorkflowId
+      }
+    };
+  };
+}
+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__default.default.object({
+    command: z4__default.default.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__default.default.object({
+    subject: z4__default.default.string().describe(
+      'A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")'
+    ),
+    description: z4__default.default.string().describe(
+      "Detailed description of what needs to be done, including context and acceptance criteria"
+    ),
+    activeForm: z4__default.default.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__default.default.record(z4__default.default.string(), z4__default.default.string()).describe("Arbitrary key-value pairs for tracking")
+  })
+};
+
+// src/lib/tool-router.ts
+var buildIntoolDefinitions = {
+  [bashTool.name]: bashTool,
+  [taskCreateTool.name]: taskCreateTool
+};
+function createToolRouter(options) {
+  const { appendToolResult } = workflow.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;
+  }
+  return {
+    // --- 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);
+    },
+    getResultsByName(results, name) {
+      return results.filter((r) => r.name === name);
+    }
+  };
+}
+function hasNoOtherToolCalls(toolCalls, excludeName) {
+  return toolCalls.filter((tc) => tc.name !== excludeName).length === 0;
+}
+
+// src/lib/session.ts
+async function resolvePrompt(prompt) {
+  if (typeof prompt === "function") {
+    return prompt();
+  }
+  return prompt;
+}
+var createSession = async ({
+  threadId,
+  agentName,
+  maxTurns = 50,
+  metadata = {},
+  runAgent,
+  baseSystemPrompt,
+  instructionsPrompt,
+  buildContextMessage,
+  buildFileTree = async () => "",
+  subagents,
+  tools = {},
+  processToolsInParallel = true,
+  buildInTools = {},
+  hooks = {}
+}) => {
+  const {
+    initializeThread,
+    appendHumanMessage,
+    parseToolCalls,
+    appendToolResult,
+    appendSystemMessage
+  } = workflow.proxyActivities({
+    startToCloseTimeout: "30m",
+    retry: {
+      maximumAttempts: 6,
+      initialInterval: "5s",
+      maximumInterval: "15m",
+      backoffCoefficient: 4
+    },
+    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({
+        threadId,
+        agentName,
+        exitReason,
+        turns,
+        metadata
+      });
+    }
+  };
+  return {
+    runSession: async ({ stateManager }) => {
+      if (hooks.onSessionStart) {
+        await hooks.onSessionStart({
+          threadId,
+          agentName,
+          metadata
+        });
+      }
+      stateManager.setTools(toolRouter.getToolDefinitions());
+      await initializeThread(threadId);
+      await appendSystemMessage(
+        threadId,
+        [
+          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
+          });
+          if (stopReason === "end_turn") {
+            stateManager.complete();
+            exitReason = "completed";
+            return message;
+          }
+          if (!toolRouter.hasTools()) {
+            stateManager.complete();
+            exitReason = "completed";
+            return message;
+          }
+          const rawToolCalls = await parseToolCalls(message);
+          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
+            }
+          );
+          if (stateManager.getStatus() === "WAITING_FOR_INPUT") {
+            exitReason = "waiting_for_input";
+            break;
+          }
+        }
+        if (stateManager.getTurns() >= maxTurns && stateManager.isRunning()) {
+          exitReason = "max_turns";
+        }
+      } catch (error) {
+        exitReason = "failed";
+        throw error;
+      } finally {
+        await callSessionEnd(exitReason, stateManager.getTurns());
+      }
+      return null;
+    }
+  };
+};
+
+// src/lib/types.ts
+function isTerminalStatus(status) {
+  return status === "COMPLETED" || status === "FAILED" || status === "CANCELLED";
+}
+
+// src/lib/state-manager.ts
+var getStateQuery = workflow.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
+    };
+  }
+  workflow.setHandler(getStateQuery, () => {
+    return buildState();
+  });
+  return {
+    getStatus() {
+      return status;
+    },
+    isRunning() {
+      return status === "RUNNING";
+    },
+    isTerminal() {
+      return isTerminalStatus(status);
+    },
+    getTurns() {
+      return turns;
+    },
+    getVersion() {
+      return version;
+    },
+    run() {
+      status = "RUNNING";
+      version++;
+    },
+    waitForInput() {
+      status = "WAITING_FOR_INPUT";
+      version++;
+    },
+    complete() {
+      status = "COMPLETED";
+      version++;
+    },
+    fail() {
+      status = "FAILED";
+      version++;
+    },
+    cancel() {
+      status = "CANCELLED";
+      version++;
+    },
+    incrementVersion() {
+      version++;
+    },
+    incrementTurns() {
+      turns++;
+    },
+    get(key) {
+      return customState[key];
+    },
+    set(key, value) {
+      customState[key] = value;
+      version++;
+    },
+    getCurrentState() {
+      return buildState();
+    },
+    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;
+    }
+  };
+}
+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:
+
+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: z4__default.default.object({
+    questions: z4__default.default.array(
+      z4__default.default.object({
+        question: z4__default.default.string().describe("The full question text to display"),
+        header: z4__default.default.string().describe("Short label for the question (max 12 characters)"),
+        options: z4__default.default.array(
+          z4__default.default.object({
+            label: z4__default.default.string(),
+            description: z4__default.default.string()
+          })
+        ).min(0).max(4).describe("Array of 0-4 choices, each with label and description"),
+        multiSelect: z4__default.default.boolean().describe("If true, users can select multiple options")
+      })
+    )
+  }),
+  strict: true
+};
+var globTool = {
+  name: "Glob",
+  description: `Search for files matching a glob pattern within the available file system.
+
+Usage:
+- Use glob patterns like "**/*.ts" to find all TypeScript files
+- Use "docs/**" to find all files in the docs directory
+- Patterns are matched against virtual paths in the file system
+
+Examples:
+- "*.md" - Find all markdown files in the root
+- "**/*.test.ts" - Find all test files recursively
+- "src/**/*.ts" - Find all TypeScript files in src directory
+`,
+  schema: z4.z.object({
+    pattern: z4.z.string().describe("Glob pattern to match files against"),
+    root: z4.z.string().optional().describe("Optional root directory to search from")
+  }),
+  strict: true
+};
+var grepTool = {
+  name: "Grep",
+  description: `Search file contents for a pattern within the available file system.
+
+Usage:
+- Searches for a regex pattern across file contents
+- Returns matching lines with file paths and line numbers
+- Can filter by file patterns and limit results
+
+Examples:
+- Search for "TODO" in all files
+- Search for function definitions with "function.*handleClick"
+- Search case-insensitively with ignoreCase: true
+`,
+  schema: z4.z.object({
+    pattern: z4.z.string().describe("Regex pattern to search for in file contents"),
+    ignoreCase: z4.z.boolean().optional().describe("Case-insensitive search (default: false)"),
+    maxMatches: z4.z.number().optional().describe("Maximum number of matches to return (default: 50)"),
+    includePatterns: z4.z.array(z4.z.string()).optional().describe("Glob patterns to include (e.g., ['*.ts', '*.js'])"),
+    excludePatterns: z4.z.array(z4.z.string()).optional().describe("Glob patterns to exclude (e.g., ['*.test.ts'])"),
+    contextLines: z4.z.number().optional().describe("Number of context lines to show around matches")
+  }),
+  strict: true
+};
+var readTool = {
+  name: "FileRead",
+  description: `Read file contents with optional pagination.
+
+Usage:
+- Provide the virtual path to the file you want to read
+- Supports text files, images, and PDFs
+- For large files, use offset and limit to read specific portions
+
+The tool returns the file content in an appropriate format:
+- Text files: Plain text content
+- Images: Base64-encoded image data
+- PDFs: Extracted text content
+`,
+  schema: z4.z.object({
+    path: z4.z.string().describe("Virtual path to the file to read"),
+    offset: z4.z.number().optional().describe(
+      "Line number to start reading from (1-indexed, for text files)"
+    ),
+    limit: z4.z.number().optional().describe("Maximum number of lines to read (for text files)")
+  }),
+  strict: true
+};
+var writeTool = {
+  name: "FileWrite",
+  description: `Create or overwrite a file with new content.
+
+Usage:
+- Provide the absolute virtual path to the file
+- The file will be created if it doesn't exist
+- If the file exists, it will be completely overwritten
+
+IMPORTANT:
+- You must read the file first (in this session) before writing to it
+- 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: z4.z.object({
+    file_path: z4.z.string().describe("The absolute virtual path to the file to write"),
+    content: z4.z.string().describe("The content to write to the file")
+  }),
+  strict: true
+};
+var editTool = {
+  name: "FileEdit",
+  description: `Edit specific sections of a file by replacing text.
+
+Usage:
+- Provide the exact text to find and replace
+- The old_string must match exactly (whitespace-sensitive)
+- By default, only replaces the first occurrence
+- Use replace_all: true to replace all occurrences
+
+IMPORTANT:
+- You must read the file first (in this session) before editing it
+- old_string must be unique in the file (unless using replace_all)
+- The operation fails if old_string is not found
+- old_string and new_string must be different
+`,
+  schema: z4.z.object({
+    file_path: z4.z.string().describe("The absolute virtual path to the file to modify"),
+    old_string: z4.z.string().describe("The exact text to replace"),
+    new_string: z4.z.string().describe(
+      "The text to replace it with (must be different from old_string)"
+    ),
+    replace_all: z4.z.boolean().optional().describe(
+      "If true, replace all occurrences of old_string (default: false)"
+    )
+  }),
+  strict: true
+};
+
+// 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
+    };
+  };
+}
+var taskGetTool = {
+  name: "TaskGet",
+  description: `Retrieve full task details including dependencies.`,
+  schema: z4__default.default.object({
+    taskId: z4__default.default.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 {
+      content: JSON.stringify(task, null, 2),
+      result: task
+    };
+  };
+}
+var taskListTool = {
+  name: "TaskList",
+  description: `List all tasks with current state.`,
+  schema: z4__default.default.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
+    };
+  };
+}
+var taskUpdateTool = {
+  name: "TaskUpdate",
+  description: `Update status, add blockers, modify details.`,
+  schema: z4__default.default.object({
+    taskId: z4__default.default.string().describe("The ID of the task to get"),
+    status: z4__default.default.enum(["pending", "in_progress", "completed"]).describe("The status of the task"),
+    addBlockedBy: z4__default.default.array(z4__default.default.string()).describe("The IDs of the tasks that are blocking this task"),
+    addBlocks: z4__default.default.array(z4__default.default.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 (args.status) {
+      task.status = args.status;
+    }
+    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 (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);
+        }
+      }
+    }
+    stateManager.setTask(task);
+    return {
+      content: JSON.stringify(task, null, 2),
+      result: task
+    };
+  };
+}
+
+exports.AGENT_HANDLER_NAMES = AGENT_HANDLER_NAMES;
+exports.askUserQuestionTool = askUserQuestionTool;
+exports.bashTool = bashTool;
+exports.createAgentStateManager = createAgentStateManager;
+exports.createSession = createSession;
+exports.createTaskCreateHandler = createTaskCreateHandler;
+exports.createTaskGetHandler = createTaskGetHandler;
+exports.createTaskListHandler = createTaskListHandler;
+exports.createTaskTool = createTaskTool;
+exports.createTaskUpdateHandler = createTaskUpdateHandler;
+exports.createToolRouter = createToolRouter;
+exports.editTool = editTool;
+exports.globTool = globTool;
+exports.grepTool = grepTool;
+exports.hasNoOtherToolCalls = hasNoOtherToolCalls;
+exports.isTerminalStatus = isTerminalStatus;
+exports.readTool = readTool;
+exports.taskCreateTool = taskCreateTool;
+exports.taskGetTool = taskGetTool;
+exports.taskListTool = taskListTool;
+exports.taskUpdateTool = taskUpdateTool;
+exports.writeTool = writeTool;
+//# sourceMappingURL=workflow.cjs.map
+//# sourceMappingURL=workflow.cjs.map