zeitlich 0.2.9 → 0.2.12

package/dist/index.cjs

@@ -1,58 +1,67 @@
 'use strict';
 
 var workflow = require('@temporalio/workflow');
-var z13 = require('zod');
-var plugin = require('@temporalio/plugin');
-var messages = require('@langchain/core/messages');
-var crypto = require('crypto');
+var z14 = require('zod');
 var activity = require('@temporalio/activity');
 var justBash = require('just-bash');
+var promises = require('fs/promises');
+var path = require('path');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var z13__default = /*#__PURE__*/_interopDefault(z13);
-var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var z14__default = /*#__PURE__*/_interopDefault(z14);
 
 // src/lib/session.ts
 var SUBAGENT_TOOL_NAME = "Subagent";
 function buildSubagentDescription(subagents) {
-  const subagentList = subagents.map((s) => `- **${s.agentName}**: ${s.description}`).join("\n");
-  return `Launch a new agent to handle complex tasks autonomously.
-
-The ${SUBAGENT_TOOL_NAME} tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.
-
-Available agent types:
+  const subagentList = subagents.map((s) => {
+    const continuation = s.allowThreadContinuation ? "\n*(Supports thread continuation \u2014 pass a threadId to resume a previous conversation)*" : "";
+    return `## ${s.agentName}
+${s.description}${continuation}`;
+  }).join("\n\n");
+  return `The ${SUBAGENT_TOOL_NAME} tool launches specialized agents (subagents) that autonomously handle complex work. Each agent type has specific capabilities and tools available to it.
 
+# Available subagents:
 ${subagentList}
-
-When using the ${SUBAGENT_TOOL_NAME} 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.
-- 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 createSubagentTool(subagents) {
   if (subagents.length === 0) {
     throw new Error("createTaskTool requires at least one subagent");
   }
   const names = subagents.map((s) => s.agentName);
+  const hasThreadContinuation = subagents.some(
+    (s) => s.allowThreadContinuation
+  );
+  const baseFields = {
+    subagent: z14__default.default.enum(names).describe("The type of subagent to launch"),
+    description: z14__default.default.string().describe("A short (3-5 word) description of the task"),
+    prompt: z14__default.default.string().describe("The task for the agent to perform")
+  };
+  const schema = hasThreadContinuation ? z14__default.default.object({
+    ...baseFields,
+    threadId: z14__default.default.string().nullable().describe(
+      "Thread ID to continue an existing conversation, or null to start a new one"
+    )
+  }) : z14__default.default.object(baseFields);
   return {
     name: SUBAGENT_TOOL_NAME,
     description: buildSubagentDescription(subagents),
-    schema: z13__default.default.object({
-      subagent: z13__default.default.enum(names).describe("The type of subagent to launch"),
-      description: z13__default.default.string().describe("A short (3-5 word) description of the task"),
-      prompt: z13__default.default.string().describe("The task for the agent to perform")
-    })
+    schema
   };
 }
+var BASE62 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function getShortId(length = 12) {
+  const hex = workflow.uuid4().replace(/-/g, "");
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    const byte = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    result += BASE62[byte % BASE62.length];
+  }
+  return result;
+}
+
+// src/tools/subagent/handler.ts
 function createSubagentHandler(subagents) {
   const { taskQueue: parentTaskQueue } = workflow.workflowInfo();
   return async (args) => {
@@ -62,34 +71,95 @@ function createSubagentHandler(subagents) {
         `Unknown subagent: ${args.subagent}. Available: ${subagents.map((s) => s.agentName).join(", ")}`
       );
     }
-    const childWorkflowId = `${args.subagent}-${workflow.uuid4()}`;
+    const childWorkflowId = `${args.subagent}-${getShortId()}`;
     const input = {
       prompt: args.prompt,
-      ...config.context && { context: config.context }
+      ...config.context && { context: config.context },
+      ...args.threadId && config.allowThreadContinuation && { threadId: args.threadId }
     };
     const childOpts = {
       workflowId: childWorkflowId,
       args: [input],
       taskQueue: config.taskQueue ?? parentTaskQueue
     };
-    const { toolResponse, data, usage } = typeof config.workflow === "string" ? await workflow.executeChild(config.workflow, childOpts) : await workflow.executeChild(config.workflow, childOpts);
-    const validated = config.resultSchema ? config.resultSchema.parse(data) : null;
+    const { toolResponse, data, usage, threadId: childThreadId } = typeof config.workflow === "string" ? await workflow.executeChild(config.workflow, childOpts) : await workflow.executeChild(config.workflow, childOpts);
+    if (!toolResponse) {
+      return {
+        toolResponse: "Subagent workflow returned no response",
+        data: null,
+        ...usage && { usage }
+      };
+    }
+    const validated = config.resultSchema ? config.resultSchema.safeParse(data) : null;
+    if (validated && !validated.success) {
+      return {
+        toolResponse: `Subagent workflow returned invalid data: ${validated.error.message}`,
+        data: null,
+        ...usage && { usage }
+      };
+    }
+    let finalToolResponse = toolResponse;
+    if (config.allowThreadContinuation && childThreadId) {
+      finalToolResponse = typeof toolResponse === "string" ? `${toolResponse}
+
+[Thread ID: ${childThreadId}]` : toolResponse;
+    }
     return {
-      toolResponse,
-      data: validated,
+      toolResponse: finalToolResponse,
+      data: validated ? validated.data : data,
       ...usage && { usage }
     };
   };
 }
+var READ_SKILL_TOOL_NAME = "ReadSkill";
+function buildReadSkillDescription(skills) {
+  const skillList = skills.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+  return `Load the full instructions for a skill. Read the skill before following its instructions.
 
-// src/lib/tool-router.ts
+# Available skills:
+${skillList}
+`;
+}
+function createReadSkillTool(skills) {
+  if (skills.length === 0) {
+    throw new Error("createReadSkillTool requires at least one skill");
+  }
+  const names = skills.map((s) => s.name);
+  return {
+    name: READ_SKILL_TOOL_NAME,
+    description: buildReadSkillDescription(skills),
+    schema: z14__default.default.object({
+      skill_name: z14__default.default.enum(names).describe("The name of the skill to load")
+    })
+  };
+}
+
+// src/tools/read-skill/handler.ts
+function createReadSkillHandler(skills) {
+  const skillMap = new Map(skills.map((s) => [s.name, s]));
+  return (args) => {
+    const skill = skillMap.get(args.skill_name);
+    if (!skill) {
+      return {
+        toolResponse: JSON.stringify({
+          error: `Skill "${args.skill_name}" not found`
+        }),
+        data: null
+      };
+    }
+    return {
+      toolResponse: skill.instructions,
+      data: null
+    };
+  };
+}
 function createToolRouter(options) {
   const { appendToolResult } = options;
   const toolMap = /* @__PURE__ */ new Map();
   for (const [_key, tool] of Object.entries(options.tools)) {
     toolMap.set(tool.name, tool);
   }
-  const isEnabled = (tool) => tool.enabled?.() ?? true;
+  const isEnabled = (tool) => tool.enabled ?? true;
   if (options.subagents) {
     if (options.subagents.length > 0) {
       const subagentHooksMap = /* @__PURE__ */ new Map();
@@ -119,6 +189,12 @@ function createToolRouter(options) {
       });
     }
   }
+  if (options.skills && options.skills.length > 0) {
+    toolMap.set(READ_SKILL_TOOL_NAME, {
+      ...createReadSkillTool(options.skills),
+      handler: createReadSkillHandler(options.skills)
+    });
+  }
   async function processToolCall(toolCall, turn, handlerContext) {
     const startTime = Date.now();
     const tool = toolMap.get(toolCall.name);
@@ -228,7 +304,9 @@ function createToolRouter(options) {
         }
       }
       if (!recovered) {
-        throw error;
+        throw workflow.ApplicationFailure.fromError(error, {
+          nonRetryable: true
+        });
       }
     }
     if (!resultAppended) {
@@ -291,9 +369,10 @@ function createToolRouter(options) {
     },
     getToolDefinitions() {
       const activeSubagents = options.subagents?.filter((subagent) => isEnabled(subagent)) ?? [];
+      const activeSkills = options.skills ?? [];
       return [
         ...Array.from(toolMap).filter(
-          ([, tool]) => isEnabled(tool) && tool.name !== SUBAGENT_TOOL_NAME
+          ([, tool]) => isEnabled(tool) && tool.name !== SUBAGENT_TOOL_NAME && tool.name !== READ_SKILL_TOOL_NAME
         ).map(([name, tool]) => ({
           name,
           description: tool.description,
@@ -301,7 +380,8 @@ function createToolRouter(options) {
           strict: tool.strict,
           max_uses: tool.max_uses
         })),
-        ...activeSubagents.length > 0 ? [createSubagentTool(activeSubagents)] : []
+        ...activeSubagents.length > 0 ? [createSubagentTool(activeSubagents)] : [],
+        ...activeSkills.length > 0 ? [createReadSkillTool(activeSkills)] : []
       ];
     },
     // --- Methods for processing tool calls ---
@@ -413,22 +493,23 @@ function hasNoOtherToolCalls(toolCalls, excludeName) {
 
 // src/lib/session.ts
 var createSession = async ({
-  threadId,
+  threadId: providedThreadId,
   agentName,
-  description,
   maxTurns = 50,
   metadata = {},
   runAgent,
   threadOps,
   buildContextMessage,
   subagents,
+  skills,
   tools = {},
   processToolsInParallel = true,
   hooks = {},
   appendSystemPrompt = true,
-  systemPrompt,
+  continueThread = false,
   waitForInputTimeout = "48h"
 }) => {
+  const threadId = providedThreadId ?? getShortId();
   const {
     appendToolResult,
     appendHumanMessage,
@@ -441,6 +522,7 @@ var createSession = async ({
     threadId,
     hooks,
     subagents,
+    skills,
     parallel: processToolsInParallel
   });
   const callSessionEnd = async (exitReason, turns) => {
@@ -484,9 +566,19 @@ var createSession = async ({
           metadata
         });
       }
-      await initializeThread(threadId);
-      if (appendSystemPrompt && systemPrompt && systemPrompt.trim() !== "") {
-        await appendSystemMessage(threadId, systemPrompt);
+      const systemPrompt = stateManager.getSystemPrompt();
+      if (!continueThread) {
+        if (appendSystemPrompt) {
+          if (!systemPrompt || systemPrompt.trim() === "") {
+            throw workflow.ApplicationFailure.create({
+              message: "No system prompt in state",
+              nonRetryable: true
+            });
+          }
+          await appendSystemMessage(threadId, systemPrompt);
+        } else {
+          await initializeThread(threadId);
+        }
       }
       await appendHumanMessage(threadId, await buildContextMessage());
       let exitReason = "completed";
@@ -498,9 +590,7 @@ var createSession = async ({
           const { message, rawToolCalls, usage } = await runAgent({
             threadId,
             agentName,
-            metadata,
-            systemPrompt,
-            description
+            metadata
           });
           if (usage) {
             stateManager.updateUsage(usage);
@@ -557,7 +647,7 @@ var createSession = async ({
         }
       } catch (error) {
         exitReason = "failed";
-        throw error;
+        throw workflow.ApplicationFailure.fromError(error);
       } finally {
         await callSessionEnd(exitReason, stateManager.getTurns());
       }
@@ -570,33 +660,28 @@ var createSession = async ({
   };
 };
 function proxyDefaultThreadOps(options) {
-  const activities = workflow.proxyActivities(
+  return workflow.proxyActivities(
     options ?? {
-      startToCloseTimeout: "30m",
+      startToCloseTimeout: "10s",
       retry: {
         maximumAttempts: 6,
         initialInterval: "5s",
         maximumInterval: "15m",
         backoffCoefficient: 4
-      },
-      heartbeatTimeout: "5m"
+      }
     }
   );
-  return {
-    initializeThread: activities.initializeThread,
-    appendHumanMessage: activities.appendHumanMessage,
-    appendToolResult: activities.appendToolResult,
-    appendSystemMessage: activities.appendSystemMessage
-  };
 }
 
 // src/lib/types.ts
+var agentQueryName = (agentName) => `get${agentName}State`;
+var agentStateChangeUpdateName = (agentName) => `waitFor${agentName}StateChange`;
 function isTerminalStatus(status) {
   return status === "COMPLETED" || status === "FAILED" || status === "CANCELLED";
 }
 function createAgentStateManager({
   initialState,
-  agentConfig
+  agentName
 }) {
   let status = initialState?.status ?? "RUNNING";
   let version = initialState?.version ?? 0;
@@ -607,6 +692,7 @@ function createAgentStateManager({
   let totalCachedWriteTokens = 0;
   let totalCachedReadTokens = 0;
   let totalReasonTokens = 0;
+  let systemPrompt = initialState?.systemPrompt;
   const tasks = new Map(initialState?.tasks);
   const {
     status: _,
@@ -626,28 +712,32 @@ function createAgentStateManager({
       ...customState
     };
   }
-  workflow.setHandler(workflow.defineQuery(`get${agentConfig.agentName}State`), () => {
+  const stateQuery = workflow.defineQuery(
+    agentQueryName(agentName)
+  );
+  const stateChangeUpdate = workflow.defineUpdate(
+    agentStateChangeUpdateName(agentName)
+  );
+  workflow.setHandler(stateQuery, () => buildState());
+  workflow.setHandler(stateChangeUpdate, async (lastKnownVersion) => {
+    await workflow.condition(
+      () => version > lastKnownVersion || isTerminalStatus(status),
+      "55s"
+    );
     return buildState();
   });
-  workflow.setHandler(
-    workflow.defineUpdate(
-      `waitFor${agentConfig.agentName}StateChange`
-    ),
-    async (lastKnownVersion) => {
-      await workflow.condition(
-        () => version > lastKnownVersion || isTerminalStatus(status),
-        "55s"
-      );
-      return buildState();
-    }
-  );
   return {
+    stateQuery,
+    stateChangeUpdate,
     getStatus() {
       return status;
     },
     isRunning() {
       return status === "RUNNING";
     },
+    getSystemPrompt() {
+      return systemPrompt;
+    },
     isTerminal() {
       return isTerminalStatus(status);
     },
@@ -710,11 +800,14 @@ function createAgentStateManager({
       tools = newTools.map((tool) => ({
         name: tool.name,
         description: tool.description,
-        schema: z13.z.toJSONSchema(tool.schema),
+        schema: z14.z.toJSONSchema(tool.schema),
         strict: tool.strict,
         max_uses: tool.max_uses
       }));
     },
+    setSystemPrompt(newSystemPrompt) {
+      systemPrompt = newSystemPrompt;
+    },
     deleteTask(id) {
       const deleted = tasks.delete(id);
       if (deleted) {
@@ -741,11 +834,79 @@ function createAgentStateManager({
     }
   };
 }
-var AGENT_HANDLER_NAMES = {
-  getAgentState: "getAgentState",
-  waitForStateChange: "waitForStateChange",
-  addMessage: "addMessage"
-};
+
+// src/lib/skills/parse.ts
+function parseSkillFile(raw) {
+  const trimmed = raw.replace(/^\uFEFF/, "");
+  const match = trimmed.match(/^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*\r?\n?([\s\S]*)$/);
+  if (!match) {
+    throw new Error(
+      "SKILL.md must start with YAML frontmatter delimited by ---"
+    );
+  }
+  const [, yamlBlock, body] = match;
+  const frontmatter = parseSimpleYaml(yamlBlock);
+  if (!frontmatter.name || typeof frontmatter.name !== "string") {
+    throw new Error("SKILL.md frontmatter must include a 'name' field");
+  }
+  if (!frontmatter.description || typeof frontmatter.description !== "string") {
+    throw new Error("SKILL.md frontmatter must include a 'description' field");
+  }
+  const result = {
+    name: frontmatter.name,
+    description: frontmatter.description
+  };
+  if (frontmatter.license) result.license = String(frontmatter.license);
+  if (frontmatter.compatibility)
+    result.compatibility = String(frontmatter.compatibility);
+  if (frontmatter["allowed-tools"]) {
+    result.allowedTools = String(frontmatter["allowed-tools"]).split(/\s+/).filter(Boolean);
+  }
+  if (frontmatter.metadata && typeof frontmatter.metadata === "object" && !Array.isArray(frontmatter.metadata)) {
+    result.metadata = frontmatter.metadata;
+  }
+  return { frontmatter: result, body: body.trim() };
+}
+function parseSimpleYaml(yaml) {
+  const result = {};
+  const lines = yaml.split(/\r?\n/);
+  let currentMapKey = null;
+  let currentMap = null;
+  for (const line of lines) {
+    if (line.trim() === "" || line.trim().startsWith("#")) continue;
+    const nestedMatch = line.match(/^(\s{2,}|\t+)(\S+)\s*:\s*(.*)$/);
+    if (nestedMatch && currentMapKey && currentMap) {
+      const [, , key2, rawVal2] = nestedMatch;
+      currentMap[key2] = unquote(rawVal2.trim());
+      continue;
+    }
+    if (currentMapKey && currentMap) {
+      result[currentMapKey] = currentMap;
+      currentMapKey = null;
+      currentMap = null;
+    }
+    const topMatch = line.match(/^(\S+)\s*:\s*(.*)$/);
+    if (!topMatch) continue;
+    const [, key, rawVal] = topMatch;
+    const val = rawVal.trim();
+    if (val === "" || val === "|" || val === ">") {
+      currentMapKey = key;
+      currentMap = {};
+    } else {
+      result[key] = unquote(val);
+    }
+  }
+  if (currentMapKey && currentMap) {
+    result[currentMapKey] = currentMap;
+  }
+  return result;
+}
+function unquote(s) {
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
 var globTool = {
   name: "Glob",
   description: `Search for files matching a glob pattern within the available file system.
@@ -760,9 +921,9 @@ Examples:
 - "**/*.test.ts" - Find all test files recursively
 - "src/**/*.ts" - Find all TypeScript files in src directory
 `,
-  schema: z13.z.object({
-    pattern: z13.z.string().describe("Glob pattern to match files against"),
-    root: z13.z.string().optional().describe("Optional root directory to search from")
+  schema: z14.z.object({
+    pattern: z14.z.string().describe("Glob pattern to match files against"),
+    root: z14.z.string().optional().describe("Optional root directory to search from")
   }),
   strict: true
 };
@@ -780,13 +941,13 @@ Examples:
 - Search for function definitions with "function.*handleClick"
 - Search case-insensitively with ignoreCase: true
 `,
-  schema: z13.z.object({
-    pattern: z13.z.string().describe("Regex pattern to search for in file contents"),
-    ignoreCase: z13.z.boolean().optional().describe("Case-insensitive search (default: false)"),
-    maxMatches: z13.z.number().optional().describe("Maximum number of matches to return (default: 50)"),
-    includePatterns: z13.z.array(z13.z.string()).optional().describe("Glob patterns to include (e.g., ['*.ts', '*.js'])"),
-    excludePatterns: z13.z.array(z13.z.string()).optional().describe("Glob patterns to exclude (e.g., ['*.test.ts'])"),
-    contextLines: z13.z.number().optional().describe("Number of context lines to show around matches")
+  schema: z14.z.object({
+    pattern: z14.z.string().describe("Regex pattern to search for in file contents"),
+    ignoreCase: z14.z.boolean().optional().describe("Case-insensitive search (default: false)"),
+    maxMatches: z14.z.number().optional().describe("Maximum number of matches to return (default: 50)"),
+    includePatterns: z14.z.array(z14.z.string()).optional().describe("Glob patterns to include (e.g., ['*.ts', '*.js'])"),
+    excludePatterns: z14.z.array(z14.z.string()).optional().describe("Glob patterns to exclude (e.g., ['*.test.ts'])"),
+    contextLines: z14.z.number().optional().describe("Number of context lines to show around matches")
   }),
   strict: true
 };
@@ -804,12 +965,12 @@ The tool returns the file content in an appropriate format:
 - Images: Base64-encoded image data
 - PDFs: Extracted text content
 `,
-  schema: z13.z.object({
-    path: z13.z.string().describe("Virtual path to the file to read"),
-    offset: z13.z.number().optional().describe(
+  schema: z14.z.object({
+    path: z14.z.string().describe("Virtual path to the file to read"),
+    offset: z14.z.number().optional().describe(
       "Line number to start reading from (1-indexed, for text files)"
     ),
-    limit: z13.z.number().optional().describe("Maximum number of lines to read (for text files)")
+    limit: z14.z.number().optional().describe("Maximum number of lines to read (for text files)")
   }),
   strict: true
 };
@@ -826,9 +987,9 @@ IMPORTANT:
 - This is an atomic write operation - the entire file is replaced
 - Path must be relative to the root of the file system (e.g., "docs/readme.md", not "/docs/readme.md")
 `,
-  schema: z13.z.object({
-    file_path: z13.z.string().describe("The path to the file to write"),
-    content: z13.z.string().describe("The content to write to the file")
+  schema: z14.z.object({
+    file_path: z14.z.string().describe("The path to the file to write"),
+    content: z14.z.string().describe("The content to write to the file")
   }),
   strict: true
 };
@@ -848,13 +1009,13 @@ IMPORTANT:
 - The operation fails if old_string is not found
 - old_string and new_string must be different
 `,
-  schema: z13.z.object({
-    file_path: z13.z.string().describe("The absolute virtual path to the file to modify"),
-    old_string: z13.z.string().describe("The exact text to replace"),
-    new_string: z13.z.string().describe(
+  schema: z14.z.object({
+    file_path: z14.z.string().describe("The absolute virtual path to the file to modify"),
+    old_string: z14.z.string().describe("The exact text to replace"),
+    new_string: z14.z.string().describe(
       "The text to replace it with (must be different from old_string)"
     ),
-    replace_all: z13.z.boolean().optional().describe(
+    replace_all: z14.z.boolean().optional().describe(
       "If true, replace all occurrences of old_string (default: false)"
     )
   }),
@@ -862,7 +1023,7 @@ IMPORTANT:
 };
 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.
+  description: `Use this tool to create a structured task list. 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
@@ -901,17 +1062,17 @@ var taskCreateTool = {
   - 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: z13__default.default.object({
-    subject: z13__default.default.string().describe(
+  schema: z14__default.default.object({
+    subject: z14__default.default.string().describe(
       'A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")'
     ),
-    description: z13__default.default.string().describe(
+    description: z14__default.default.string().describe(
       "Detailed description of what needs to be done, including context and acceptance criteria"
     ),
-    activeForm: z13__default.default.string().describe(
+    activeForm: z14__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: z13__default.default.record(z13__default.default.string(), z13__default.default.string()).describe("Arbitrary key-value pairs for tracking")
+    metadata: z14__default.default.record(z14__default.default.string(), z14__default.default.string()).describe("Arbitrary key-value pairs for tracking")
   })
 };
 function createTaskCreateHandler(stateManager) {
@@ -936,8 +1097,8 @@ function createTaskCreateHandler(stateManager) {
 var taskGetTool = {
   name: "TaskGet",
   description: `Retrieve full task details including dependencies.`,
-  schema: z13__default.default.object({
-    taskId: z13__default.default.string().describe("The ID of the task to get")
+  schema: z14__default.default.object({
+    taskId: z14__default.default.string().describe("The ID of the task to get")
   })
 };
 
@@ -960,7 +1121,7 @@ function createTaskGetHandler(stateManager) {
 var taskListTool = {
   name: "TaskList",
   description: `List all tasks with current state.`,
-  schema: z13__default.default.object({})
+  schema: z14__default.default.object({})
 };
 
 // src/tools/task-list/handler.ts
@@ -976,11 +1137,11 @@ function createTaskListHandler(stateManager) {
 var taskUpdateTool = {
   name: "TaskUpdate",
   description: `Update status, add blockers, modify details.`,
-  schema: z13__default.default.object({
-    taskId: z13__default.default.string().describe("The ID of the task to get"),
-    status: z13__default.default.enum(["pending", "in_progress", "completed"]).describe("The status of the task"),
-    addBlockedBy: z13__default.default.array(z13__default.default.string()).describe("The IDs of the tasks that are blocking this task"),
-    addBlocks: z13__default.default.array(z13__default.default.string()).describe("The IDs of the tasks that this task is blocking")
+  schema: z14__default.default.object({
+    taskId: z14__default.default.string().describe("The ID of the task to get"),
+    status: z14__default.default.enum(["pending", "in_progress", "completed"]).describe("The status of the task"),
+    addBlockedBy: z14__default.default.array(z14__default.default.string()).describe("The IDs of the tasks that are blocking this task"),
+    addBlocks: z14__default.default.array(z14__default.default.string()).describe("The IDs of the tasks that this task is blocking")
   })
 };
 
@@ -1048,8 +1209,8 @@ Use this tool to:
 - Execute scripts and chain commands with pipes (|) or logical operators (&&, ||)
 - Inspect files and directories
 `,
-  schema: z13__default.default.object({
-    command: z13__default.default.string().describe(
+  schema: z14__default.default.object({
+    command: z14__default.default.string().describe(
       "The bash command to execute. Can include pipes (|), redirects (>, >>), logical operators (&&, ||), and shell features like command substitution $(...)."
     )
   }),
@@ -1070,18 +1231,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: z13__default.default.object({
-    questions: z13__default.default.array(
-      z13__default.default.object({
-        question: z13__default.default.string().describe("The full question text to display"),
-        header: z13__default.default.string().describe("Short label for the question (max 12 characters)"),
-        options: z13__default.default.array(
-          z13__default.default.object({
-            label: z13__default.default.string(),
-            description: z13__default.default.string()
+  schema: z14__default.default.object({
+    questions: z14__default.default.array(
+      z14__default.default.object({
+        question: z14__default.default.string().describe("The full question text to display"),
+        header: z14__default.default.string().describe("Short label for the question (max 12 characters)"),
+        options: z14__default.default.array(
+          z14__default.default.object({
+            label: z14__default.default.string(),
+            description: z14__default.default.string()
           })
         ).min(0).max(4).describe("Array of 0-4 choices, each with label and description"),
-        multiSelect: z13__default.default.boolean().describe("If true, users can select multiple options")
+        multiSelect: z14__default.default.boolean().describe("If true, users can select multiple options")
       })
     )
   }),
@@ -1096,49 +1257,19 @@ var createAskUserQuestionHandler = () => async (args) => {
   };
 };
 
-// node_modules/uuid/dist/esm-node/stringify.js
-var byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-  byteToHex.push((i + 256).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-}
-var rnds8Pool = new Uint8Array(256);
-var poolPtr = rnds8Pool.length;
-function rng() {
-  if (poolPtr > rnds8Pool.length - 16) {
-    crypto__default.default.randomFillSync(rnds8Pool);
-    poolPtr = 0;
-  }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
-}
-var native_default = {
-  randomUUID: crypto__default.default.randomUUID
-};
-
-// node_modules/uuid/dist/esm-node/v4.js
-function v4(options, buf, offset) {
-  if (native_default.randomUUID && !buf && !options) {
-    return native_default.randomUUID();
-  }
-  options = options || {};
-  const rnds = options.random || (options.rng || rng)();
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    for (let i = 0; i < 16; ++i) {
-      buf[offset + i] = rnds[i];
-    }
-    return buf;
-  }
-  return unsafeStringify(rnds);
-}
-var v4_default = v4;
-
 // src/lib/thread-manager.ts
 var THREAD_TTL_SECONDS = 60 * 60 * 24 * 90;
+var APPEND_IDEMPOTENT_SCRIPT = `
+if redis.call('EXISTS', KEYS[1]) == 1 then
+  return 0
+end
+for i = 2, #ARGV do
+  redis.call('RPUSH', KEYS[2], ARGV[i])
+end
+redis.call('EXPIRE', KEYS[2], tonumber(ARGV[1]))
+redis.call('SET', KEYS[1], '1', 'EX', tonumber(ARGV[1]))
+return 1
+`;
 function getThreadKey(threadId, key) {
   return `thread:${threadId}:${key}`;
 }
@@ -1148,152 +1279,66 @@ function createThreadManager(config) {
     threadId,
     key = "messages",
     serialize = (m) => JSON.stringify(m),
-    deserialize = (raw) => JSON.parse(raw)
+    deserialize = (raw) => JSON.parse(raw),
+    idOf
   } = config;
   const redisKey = getThreadKey(threadId, key);
-  const base = {
+  const metaKey = getThreadKey(threadId, `${key}:meta`);
+  async function assertThreadExists() {
+    const exists = await redis.exists(metaKey);
+    if (!exists) {
+      throw new Error(`Thread "${threadId}" (key: ${key}) does not exist`);
+    }
+  }
+  return {
     async initialize() {
       await redis.del(redisKey);
+      await redis.set(metaKey, "1", "EX", THREAD_TTL_SECONDS);
     },
     async load() {
+      await assertThreadExists();
       const data = await redis.lrange(redisKey, 0, -1);
       return data.map(deserialize);
     },
     async append(messages) {
-      if (messages.length > 0) {
+      if (messages.length === 0) return;
+      await assertThreadExists();
+      if (idOf) {
+        const dedupId = messages.map(idOf).join(":");
+        const dedupKey = getThreadKey(threadId, `dedup:${dedupId}`);
+        await redis.eval(
+          APPEND_IDEMPOTENT_SCRIPT,
+          2,
+          dedupKey,
+          redisKey,
+          String(THREAD_TTL_SECONDS),
+          ...messages.map(serialize)
+        );
+      } else {
         await redis.rpush(redisKey, ...messages.map(serialize));
         await redis.expire(redisKey, THREAD_TTL_SECONDS);
       }
     },
     async delete() {
-      await redis.del(redisKey);
-    }
-  };
-  const helpers = {
-    createHumanMessage(content) {
-      return new messages.HumanMessage({
-        id: v4_default(),
-        content
-      }).toDict();
-    },
-    createSystemMessage(content) {
-      return new messages.SystemMessage({
-        id: v4_default(),
-        content
-      }).toDict();
-    },
-    createAIMessage(content, kwargs) {
-      return new messages.AIMessage({
-        id: v4_default(),
-        content,
-        additional_kwargs: kwargs ? {
-          header: kwargs.header,
-          options: kwargs.options,
-          multiSelect: kwargs.multiSelect
-        } : void 0
-      }).toDict();
-    },
-    createToolMessage(content, toolCallId) {
-      return new messages.ToolMessage({
-        content,
-        tool_call_id: toolCallId
-      }).toDict();
-    },
-    async appendHumanMessage(content) {
-      const message = helpers.createHumanMessage(content);
-      await base.append([message]);
-    },
-    async appendToolMessage(content, toolCallId) {
-      const message = helpers.createToolMessage(content, toolCallId);
-      await base.append([message]);
-    },
-    async appendAIMessage(content) {
-      const message = helpers.createAIMessage(content);
-      await base.append([message]);
-    },
-    async appendSystemMessage(content) {
-      const message = helpers.createSystemMessage(content);
-      await base.append([message]);
+      await redis.del(redisKey, metaKey);
     }
   };
-  return Object.assign(base, helpers);
 }
-
-// src/activities.ts
-function createSharedActivities(redis) {
-  return {
-    async appendToolResult(config) {
-      const { threadId, toolCallId, content } = config;
-      const thread = createThreadManager({ redis, threadId });
-      await thread.appendToolMessage(content, toolCallId);
-    },
-    async initializeThread(threadId) {
-      const thread = createThreadManager({ redis, threadId });
-      await thread.initialize();
-    },
-    async appendThreadMessages(threadId, messages) {
-      const thread = createThreadManager({ redis, threadId });
-      await thread.append(messages);
-    },
-    async appendHumanMessage(threadId, content) {
-      const thread = createThreadManager({ redis, threadId });
-      await thread.appendHumanMessage(content);
-    },
-    async appendSystemMessage(threadId, content) {
-      const thread = createThreadManager({ redis, threadId });
-      await thread.appendSystemMessage(content);
-    }
-  };
-}
-
-// src/plugin.ts
-var ZeitlichPlugin = class extends plugin.SimplePlugin {
-  constructor(options) {
-    super({
-      name: "ZeitlichPlugin",
-      activities: createSharedActivities(options.redis)
-    });
-  }
-};
-async function invokeModel({
-  redis,
-  model,
-  client,
-  config: { threadId, agentName }
-}) {
-  const thread = createThreadManager({ redis, threadId });
-  const runId = v4_default();
-  const info = activity.Context.current().info;
-  const parentWorkflowId = info.workflowExecution.workflowId;
-  const parentRunId = info.workflowExecution.runId;
-  const handle = client.getHandle(parentWorkflowId, parentRunId);
-  const { tools } = await handle.query(`get${agentName}State`);
-  const messages$1 = await thread.load();
-  const response = await model.invoke(
-    [...messages.mapStoredMessagesToChatMessages(messages$1)],
-    {
-      runName: agentName,
-      runId,
-      metadata: { thread_id: threadId },
-      tools
-    }
+async function queryParentWorkflowState(client, queryName) {
+  const { workflowExecution } = activity.Context.current().info;
+  const handle = client.getHandle(
+    workflowExecution.workflowId,
+    workflowExecution.runId
   );
-  await thread.append([response.toDict()]);
-  const toolCalls = response.tool_calls ?? [];
-  return {
-    message: response.toDict(),
-    rawToolCalls: toolCalls.map((tc) => ({
-      id: tc.id,
-      name: tc.name,
-      args: tc.args
-    })),
-    usage: {
-      inputTokens: response.usage_metadata?.input_tokens,
-      outputTokens: response.usage_metadata?.output_tokens,
-      reasonTokens: response.usage_metadata?.output_token_details?.reasoning,
-      cachedWriteTokens: response.usage_metadata?.input_token_details?.cache_creation,
-      cachedReadTokens: response.usage_metadata?.input_token_details?.cache_read
-    }
+  return handle.query(queryName);
+}
+function createRunAgentActivity(client, invoker) {
+  return async (config) => {
+    const state = await queryParentWorkflowState(
+      client,
+      agentQueryName(config.agentName)
+    );
+    return invoker({ ...config, state });
   };
 }
 function createGlobHandler(fs) {
@@ -1464,9 +1509,65 @@ var toTree = async (fs, opts = {}) => {
   const base = basename(dir, separator) + separator;
   return base + subtree;
 };
+var FileSystemSkillProvider = class {
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+  }
+  async listSkills() {
+    const dirs = await this.discoverSkillDirs();
+    const skills = [];
+    for (const dir of dirs) {
+      const raw = await promises.readFile(path.join(this.baseDir, dir, "SKILL.md"), "utf-8");
+      const { frontmatter } = parseSkillFile(raw);
+      skills.push(frontmatter);
+    }
+    return skills;
+  }
+  async getSkill(name) {
+    const raw = await promises.readFile(
+      path.join(this.baseDir, name, "SKILL.md"),
+      "utf-8"
+    );
+    const { frontmatter, body } = parseSkillFile(raw);
+    if (frontmatter.name !== name) {
+      throw new Error(
+        `Skill directory "${name}" contains SKILL.md with mismatched name "${frontmatter.name}"`
+      );
+    }
+    return { ...frontmatter, instructions: body };
+  }
+  /**
+   * Convenience method to load all skills with full instructions.
+   * Returns `Skill[]` ready to pass into a workflow.
+   */
+  async loadAll() {
+    const dirs = await this.discoverSkillDirs();
+    const skills = [];
+    for (const dir of dirs) {
+      const raw = await promises.readFile(path.join(this.baseDir, dir, "SKILL.md"), "utf-8");
+      const { frontmatter, body } = parseSkillFile(raw);
+      skills.push({ ...frontmatter, instructions: body });
+    }
+    return skills;
+  }
+  async discoverSkillDirs() {
+    const entries = await promises.readdir(this.baseDir, { withFileTypes: true });
+    const dirs = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      try {
+        await promises.readFile(path.join(this.baseDir, entry.name, "SKILL.md"), "utf-8");
+        dirs.push(entry.name);
+      } catch {
+      }
+    }
+    return dirs;
+  }
+};
 
-exports.AGENT_HANDLER_NAMES = AGENT_HANDLER_NAMES;
-exports.ZeitlichPlugin = ZeitlichPlugin;
+exports.FileSystemSkillProvider = FileSystemSkillProvider;
+exports.agentQueryName = agentQueryName;
+exports.agentStateChangeUpdateName = agentStateChangeUpdateName;
 exports.askUserQuestionTool = askUserQuestionTool;
 exports.bashTool = bashTool;
 exports.createAgentStateManager = createAgentStateManager;
@@ -1475,8 +1576,10 @@ exports.createBashHandler = createBashHandler;
 exports.createBashToolDescription = createBashToolDescription;
 exports.createEditHandler = createEditHandler;
 exports.createGlobHandler = createGlobHandler;
+exports.createReadSkillHandler = createReadSkillHandler;
+exports.createReadSkillTool = createReadSkillTool;
+exports.createRunAgentActivity = createRunAgentActivity;
 exports.createSession = createSession;
-exports.createSharedActivities = createSharedActivities;
 exports.createSubagentTool = createSubagentTool;
 exports.createTaskCreateHandler = createTaskCreateHandler;
 exports.createTaskGetHandler = createTaskGetHandler;
@@ -1487,12 +1590,14 @@ exports.createToolRouter = createToolRouter;
 exports.defineSubagent = defineSubagent;
 exports.defineTool = defineTool;
 exports.editTool = editTool;
+exports.getShortId = getShortId;
 exports.globTool = globTool;
 exports.grepTool = grepTool;
 exports.hasNoOtherToolCalls = hasNoOtherToolCalls;
-exports.invokeModel = invokeModel;
 exports.isTerminalStatus = isTerminalStatus;
+exports.parseSkillFile = parseSkillFile;
 exports.proxyDefaultThreadOps = proxyDefaultThreadOps;
+exports.queryParentWorkflowState = queryParentWorkflowState;
 exports.readFileTool = readFileTool;
 exports.taskCreateTool = taskCreateTool;
 exports.taskGetTool = taskGetTool;