@everworker/oneringai 0.3.2 → 0.4.1

package/dist/index.cjs

@@ -2,7 +2,7 @@
 
 var crypto2 = require('crypto');
 var jose = require('jose');
-var fs18 = require('fs');
+var fs19 = require('fs');
 var eventemitter3 = require('eventemitter3');
 var path2 = require('path');
 var TurndownService = require('turndown');
@@ -17,7 +17,7 @@ var z = require('zod/v4');
 var spawn = require('cross-spawn');
 var process2 = require('process');
 var stream = require('stream');
-var fs17 = require('fs/promises');
+var fs18 = require('fs/promises');
 var simpleIcons = require('simple-icons');
 var child_process = require('child_process');
 var util = require('util');
@@ -45,7 +45,7 @@ function _interopNamespace(e) {
 }
 
 var crypto2__namespace = /*#__PURE__*/_interopNamespace(crypto2);
-var fs18__namespace = /*#__PURE__*/_interopNamespace(fs18);
+var fs19__namespace = /*#__PURE__*/_interopNamespace(fs19);
 var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
 var TurndownService__default = /*#__PURE__*/_interopDefault(TurndownService);
 var os2__namespace = /*#__PURE__*/_interopNamespace(os2);
@@ -55,7 +55,7 @@ var z4mini__namespace = /*#__PURE__*/_interopNamespace(z4mini);
 var z__namespace = /*#__PURE__*/_interopNamespace(z);
 var spawn__default = /*#__PURE__*/_interopDefault(spawn);
 var process2__default = /*#__PURE__*/_interopDefault(process2);
-var fs17__namespace = /*#__PURE__*/_interopNamespace(fs17);
+var fs18__namespace = /*#__PURE__*/_interopNamespace(fs18);
 var simpleIcons__namespace = /*#__PURE__*/_interopNamespace(simpleIcons);
 var vm__namespace = /*#__PURE__*/_interopNamespace(vm);
 
@@ -673,7 +673,7 @@ var init_JWTBearer = __esm({
           this.privateKey = config.privateKey;
         } else if (config.privateKeyPath) {
           try {
-            this.privateKey = fs18__namespace.readFileSync(config.privateKeyPath, "utf8");
+            this.privateKey = fs19__namespace.readFileSync(config.privateKeyPath, "utf8");
           } catch (error) {
             throw new Error(`Failed to read private key from ${config.privateKeyPath}: ${error.message}`);
           }
@@ -1432,10 +1432,10 @@ var init_Logger = __esm({
       initFileStream(filePath) {
         try {
           const dir = path2__namespace.dirname(filePath);
-          if (!fs18__namespace.existsSync(dir)) {
-            fs18__namespace.mkdirSync(dir, { recursive: true });
+          if (!fs19__namespace.existsSync(dir)) {
+            fs19__namespace.mkdirSync(dir, { recursive: true });
           }
-          this.fileStream = fs18__namespace.createWriteStream(filePath, {
+          this.fileStream = fs19__namespace.createWriteStream(filePath, {
             flags: "a",
             // append mode
             encoding: "utf8"
@@ -9165,12 +9165,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs19, exportName) {
+    function addFormats(ajv, list, fs20, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs19[f]);
+        ajv.addFormat(f, fs20[f]);
     }
     module.exports = exports$1 = formatsPlugin;
     Object.defineProperty(exports$1, "__esModule", { value: true });
@@ -14505,7 +14505,7 @@ var PRIORITY_VALUES = {
 };
 var DEFAULT_CONFIG = {
   maxEntries: 20,
-  maxTotalTokens: 4e3,
+  maxTotalTokens: 4e4,
   defaultPriority: "normal",
   showTimestamps: false
 };
@@ -14902,7 +14902,7 @@ var FilePersistentInstructionsStorage = class {
    */
   async load() {
     try {
-      const raw = await fs18.promises.readFile(this.filePath, "utf-8");
+      const raw = await fs19.promises.readFile(this.filePath, "utf-8");
       const data = JSON.parse(raw);
       if (data.version === 2 && Array.isArray(data.entries)) {
         return data.entries.length > 0 ? data.entries : null;
@@ -14914,7 +14914,7 @@ var FilePersistentInstructionsStorage = class {
       }
     }
     try {
-      const content = await fs18.promises.readFile(this.legacyFilePath, "utf-8");
+      const content = await fs19.promises.readFile(this.legacyFilePath, "utf-8");
       const trimmed = content.trim();
       if (!trimmed) return null;
       const now = Date.now();
@@ -14944,11 +14944,11 @@ var FilePersistentInstructionsStorage = class {
     };
     const tempPath = `${this.filePath}.tmp`;
     try {
-      await fs18.promises.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
-      await fs18.promises.rename(tempPath, this.filePath);
+      await fs19.promises.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
+      await fs19.promises.rename(tempPath, this.filePath);
     } catch (error) {
       try {
-        await fs18.promises.unlink(tempPath);
+        await fs19.promises.unlink(tempPath);
       } catch {
       }
       throw error;
@@ -14960,7 +14960,7 @@ var FilePersistentInstructionsStorage = class {
    */
   async delete() {
     try {
-      await fs18.promises.unlink(this.filePath);
+      await fs19.promises.unlink(this.filePath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
         throw error;
@@ -14973,11 +14973,11 @@ var FilePersistentInstructionsStorage = class {
    */
   async exists() {
     try {
-      await fs18.promises.access(this.filePath);
+      await fs19.promises.access(this.filePath);
       return true;
     } catch {
       try {
-        await fs18.promises.access(this.legacyFilePath);
+        await fs19.promises.access(this.legacyFilePath);
         return true;
       } catch {
         return false;
@@ -15001,7 +15001,7 @@ var FilePersistentInstructionsStorage = class {
    */
   async ensureDirectory() {
     try {
-      await fs18.promises.mkdir(this.directory, { recursive: true });
+      await fs19.promises.mkdir(this.directory, { recursive: true });
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "EEXIST") {
         throw error;
@@ -15013,7 +15013,7 @@ var FilePersistentInstructionsStorage = class {
    */
   async removeLegacyFile() {
     try {
-      await fs18.promises.unlink(this.legacyFilePath);
+      await fs19.promises.unlink(this.legacyFilePath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
         console.warn(`Failed to remove legacy instructions file: ${this.legacyFilePath}`);
@@ -15518,7 +15518,7 @@ var FileUserInfoStorage = class {
   async load(userId) {
     const filePath = this.getUserFilePath(userId);
     try {
-      const raw = await fs18.promises.readFile(filePath, "utf-8");
+      const raw = await fs19.promises.readFile(filePath, "utf-8");
       const data = JSON.parse(raw);
       if (data.version === 1 && Array.isArray(data.entries)) {
         return data.entries.length > 0 ? data.entries : null;
@@ -15546,11 +15546,11 @@ var FileUserInfoStorage = class {
     };
     const tempPath = `${filePath}.tmp`;
     try {
-      await fs18.promises.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
-      await fs18.promises.rename(tempPath, filePath);
+      await fs19.promises.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
+      await fs19.promises.rename(tempPath, filePath);
     } catch (error) {
       try {
-        await fs18.promises.unlink(tempPath);
+        await fs19.promises.unlink(tempPath);
       } catch {
       }
       throw error;
@@ -15562,7 +15562,7 @@ var FileUserInfoStorage = class {
   async delete(userId) {
     const filePath = this.getUserFilePath(userId);
     try {
-      await fs18.promises.unlink(filePath);
+      await fs19.promises.unlink(filePath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
         throw error;
@@ -15575,7 +15575,7 @@ var FileUserInfoStorage = class {
   async exists(userId) {
     const filePath = this.getUserFilePath(userId);
     try {
-      await fs18.promises.access(filePath);
+      await fs19.promises.access(filePath);
       return true;
     } catch {
       return false;
@@ -15592,7 +15592,7 @@ var FileUserInfoStorage = class {
    */
   async ensureDirectory(directory) {
     try {
-      await fs18.promises.mkdir(directory, { recursive: true });
+      await fs19.promises.mkdir(directory, { recursive: true });
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "EEXIST") {
         throw error;
@@ -16690,7 +16690,7 @@ var StrategyRegistry = class {
 // src/core/context-nextgen/types.ts
 var DEFAULT_FEATURES = {
   workingMemory: true,
-  inContextMemory: false,
+  inContextMemory: true,
   persistentInstructions: false,
   userInfo: false
 };
@@ -17370,6 +17370,8 @@ ${content}`);
         breakdown.pluginContents[plugin.name] = plugin.getTokenSize();
       }
     }
+    const now = /* @__PURE__ */ new Date();
+    parts.push(`CURRENT DATE AND TIME: ${now.toLocaleString("en-US", { dateStyle: "full", timeStyle: "long", timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone })}`);
     const systemText = parts.join("\n\n---\n\n");
     const systemTokens = this._estimator.estimateTokens(systemText);
     const systemMessage = {
@@ -20828,6 +20830,7 @@ var BaseAgent = class extends eventemitter3.EventEmitter {
   _agentContext;
   // SINGLE SOURCE OF TRUTH for tools and sessions
   _permissionManager;
+  _ownsContext = true;
   _isDestroyed = false;
   _cleanupCallbacks = [];
   _logger;
@@ -20880,8 +20883,10 @@ var BaseAgent = class extends eventemitter3.EventEmitter {
    */
   initializeAgentContext(config) {
     if (config.context instanceof AgentContextNextGen) {
+      this._ownsContext = false;
       return config.context;
     }
+    this._ownsContext = true;
     const contextConfig = {
       model: config.model,
       agentId: config.name,
@@ -21393,7 +21398,9 @@ var BaseAgent = class extends eventemitter3.EventEmitter {
       clearInterval(this._autoSaveInterval);
       this._autoSaveInterval = null;
     }
-    this._agentContext.destroy();
+    if (this._ownsContext) {
+      this._agentContext.destroy();
+    }
     this._permissionManager.removeAllListeners();
     this.removeAllListeners();
   }
@@ -21734,6 +21741,18 @@ var HookManager = class {
     }
     existing.push(hook);
   }
+  /**
+   * Unregister a specific hook function by reference.
+   * Returns true if the hook was found and removed.
+   */
+  unregister(name, hook) {
+    const hooks = this.hooks.get(name);
+    if (!hooks) return false;
+    const index = hooks.indexOf(hook);
+    if (index === -1) return false;
+    hooks.splice(index, 1);
+    return true;
+  }
   /**
    * Execute hooks for a given name
    */
@@ -21756,7 +21775,7 @@ var HookManager = class {
       const hook = hooks[i];
       const hookKey = this.getHookKey(hook, i);
       const hookResult = await this.executeHookSafely(hook, context, hookKey);
-      if (hookResult === null) {
+      if (hookResult == null) {
         continue;
       }
       result = { ...result, ...hookResult };
@@ -21776,7 +21795,7 @@ var HookManager = class {
         return this.executeHookSafely(hook, context, hookKey);
       })
     );
-    const validResults = results.filter((r) => r !== null);
+    const validResults = results.filter((r) => r != null);
     return validResults.reduce(
       (acc, hookResult) => ({ ...acc, ...hookResult }),
       defaultResult
@@ -22452,7 +22471,6 @@ var Agent = class _Agent extends BaseAgent {
   _cleanupExecution(streamState) {
     streamState?.clear();
     this.executionContext?.cleanup();
-    this.hookManager.clear();
   }
   /**
    * Emit iteration complete event (helper for run loop)
@@ -23337,6 +23355,27 @@ var Agent = class _Agent extends BaseAgent {
   isCancelled() {
     return this._cancelled;
   }
+  /**
+   * Clear conversation history, resetting the context for a fresh interaction.
+   * Plugins (working memory, in-context memory, etc.) are NOT affected.
+   */
+  clearConversation(reason) {
+    this._agentContext.clearConversation(reason);
+    this._logger.info({ reason }, "Conversation cleared");
+  }
+  // ===== Hook Management =====
+  /**
+   * Register a hook on the agent. Can be called after creation.
+   */
+  registerHook(name, hook) {
+    this.hookManager.register(name, hook);
+  }
+  /**
+   * Unregister a previously registered hook by reference.
+   */
+  unregisterHook(name, hook) {
+    return this.hookManager.unregister(name, hook);
+  }
   // ===== Cleanup =====
   destroy() {
     if (this._isDestroyed) {
@@ -23366,6 +23405,1006 @@ var Agent = class _Agent extends BaseAgent {
   }
 };
 
+// src/domain/entities/Task.ts
+var TERMINAL_TASK_STATUSES = ["completed", "failed", "skipped", "cancelled"];
+function isTerminalStatus(status) {
+  return TERMINAL_TASK_STATUSES.includes(status);
+}
+function createTask(input) {
+  const now = Date.now();
+  const id = input.id ?? `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  return {
+    id,
+    name: input.name,
+    description: input.description,
+    status: "pending",
+    dependsOn: input.dependsOn ?? [],
+    externalDependency: input.externalDependency,
+    condition: input.condition,
+    execution: input.execution,
+    suggestedTools: input.suggestedTools,
+    validation: input.validation,
+    expectedOutput: input.expectedOutput,
+    attempts: 0,
+    maxAttempts: input.maxAttempts ?? 3,
+    createdAt: now,
+    lastUpdatedAt: now,
+    metadata: input.metadata
+  };
+}
+function createPlan(input) {
+  const now = Date.now();
+  const id = `plan-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  const tasks = input.tasks.map((taskInput) => createTask(taskInput));
+  const nameToId = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    nameToId.set(task.name, task.id);
+  }
+  for (let i = 0; i < tasks.length; i++) {
+    const taskInput = input.tasks[i];
+    const task = tasks[i];
+    if (taskInput.dependsOn && taskInput.dependsOn.length > 0) {
+      task.dependsOn = taskInput.dependsOn.map((dep) => {
+        if (dep.startsWith("task-")) {
+          return dep;
+        }
+        const resolvedId = nameToId.get(dep);
+        if (!resolvedId) {
+          throw new Error(`Task dependency "${dep}" not found in plan`);
+        }
+        return resolvedId;
+      });
+    }
+  }
+  if (!input.skipCycleCheck) {
+    const cycle = detectDependencyCycle(tasks);
+    if (cycle) {
+      const cycleNames = cycle.map((taskId) => {
+        const task = tasks.find((t) => t.id === taskId);
+        return task ? task.name : taskId;
+      });
+      throw new DependencyCycleError(cycleNames, id);
+    }
+  }
+  return {
+    id,
+    goal: input.goal,
+    context: input.context,
+    tasks,
+    concurrency: input.concurrency,
+    allowDynamicTasks: input.allowDynamicTasks ?? true,
+    status: "pending",
+    createdAt: now,
+    lastUpdatedAt: now,
+    metadata: input.metadata
+  };
+}
+function canTaskExecute(task, allTasks) {
+  if (task.status !== "pending") {
+    return false;
+  }
+  if (task.dependsOn.length > 0) {
+    for (const depId of task.dependsOn) {
+      const depTask = allTasks.find((t) => t.id === depId);
+      if (!depTask || depTask.status !== "completed") {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function getNextExecutableTasks(plan) {
+  const executable = plan.tasks.filter((task) => canTaskExecute(task, plan.tasks));
+  if (executable.length === 0) {
+    return [];
+  }
+  if (!plan.concurrency) {
+    return [executable[0]];
+  }
+  const runningCount = plan.tasks.filter((t) => t.status === "in_progress").length;
+  const availableSlots = plan.concurrency.maxParallelTasks - runningCount;
+  if (availableSlots <= 0) {
+    return [];
+  }
+  const parallelTasks = executable.filter((task) => task.execution?.parallel === true);
+  if (parallelTasks.length === 0) {
+    return [executable[0]];
+  }
+  let sortedTasks = [...parallelTasks];
+  if (plan.concurrency.strategy === "priority") {
+    sortedTasks.sort((a, b) => (b.execution?.priority ?? 0) - (a.execution?.priority ?? 0));
+  }
+  return sortedTasks.slice(0, availableSlots);
+}
+async function evaluateCondition(condition, memory) {
+  const value = await memory.get(condition.memoryKey);
+  switch (condition.operator) {
+    case "exists":
+      return value !== void 0;
+    case "not_exists":
+      return value === void 0;
+    case "equals":
+      return value === condition.value;
+    case "contains":
+      if (Array.isArray(value)) {
+        return value.includes(condition.value);
+      }
+      if (typeof value === "string" && typeof condition.value === "string") {
+        return value.includes(condition.value);
+      }
+      return false;
+    case "truthy":
+      return !!value;
+    case "greater_than":
+      if (typeof value === "number" && typeof condition.value === "number") {
+        return value > condition.value;
+      }
+      return false;
+    case "less_than":
+      if (typeof value === "number" && typeof condition.value === "number") {
+        return value < condition.value;
+      }
+      return false;
+    default:
+      return false;
+  }
+}
+function updateTaskStatus(task, status) {
+  const now = Date.now();
+  const updated = {
+    ...task,
+    status,
+    lastUpdatedAt: now
+  };
+  if (status === "in_progress") {
+    if (!updated.startedAt) {
+      updated.startedAt = now;
+    }
+    updated.attempts += 1;
+  }
+  if ((status === "completed" || status === "failed") && !updated.completedAt) {
+    updated.completedAt = now;
+  }
+  return updated;
+}
+function isTaskBlocked(task, allTasks) {
+  if (task.dependsOn.length === 0) {
+    return false;
+  }
+  for (const depId of task.dependsOn) {
+    const depTask = allTasks.find((t) => t.id === depId);
+    if (!depTask) {
+      return true;
+    }
+    if (depTask.status !== "completed") {
+      return true;
+    }
+  }
+  return false;
+}
+function getTaskDependencies(task, allTasks) {
+  if (task.dependsOn.length === 0) {
+    return [];
+  }
+  return task.dependsOn.map((depId) => allTasks.find((t) => t.id === depId)).filter((t) => t !== void 0);
+}
+function resolveDependencies(taskInputs, tasks) {
+  const nameToId = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    nameToId.set(task.name, task.id);
+  }
+  for (const input of taskInputs) {
+    if (input.dependsOn && input.dependsOn.length > 0) {
+      input.dependsOn = input.dependsOn.map((dep) => {
+        if (dep.startsWith("task-")) {
+          return dep;
+        }
+        const resolvedId = nameToId.get(dep);
+        if (!resolvedId) {
+          throw new Error(`Task dependency "${dep}" not found`);
+        }
+        return resolvedId;
+      });
+    }
+  }
+}
+function detectDependencyCycle(tasks) {
+  const visited = /* @__PURE__ */ new Set();
+  const recStack = /* @__PURE__ */ new Set();
+  const taskMap = new Map(tasks.map((t) => [t.id, t]));
+  function dfs(taskId, path6) {
+    if (recStack.has(taskId)) {
+      const cycleStart = path6.indexOf(taskId);
+      return [...path6.slice(cycleStart), taskId];
+    }
+    if (visited.has(taskId)) {
+      return null;
+    }
+    visited.add(taskId);
+    recStack.add(taskId);
+    const task = taskMap.get(taskId);
+    if (task) {
+      for (const depId of task.dependsOn) {
+        const cycle = dfs(depId, [...path6, taskId]);
+        if (cycle) {
+          return cycle;
+        }
+      }
+    }
+    recStack.delete(taskId);
+    return null;
+  }
+  for (const task of tasks) {
+    if (!visited.has(task.id)) {
+      const cycle = dfs(task.id, []);
+      if (cycle) {
+        return cycle;
+      }
+    }
+  }
+  return null;
+}
+
+// src/domain/entities/Routine.ts
+function createRoutineDefinition(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = input.id ?? `routine-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  const taskNames = new Set(input.tasks.map((t) => t.name));
+  const taskIds = new Set(input.tasks.filter((t) => t.id).map((t) => t.id));
+  for (const task of input.tasks) {
+    if (task.dependsOn) {
+      for (const dep of task.dependsOn) {
+        if (!taskNames.has(dep) && !taskIds.has(dep)) {
+          throw new Error(
+            `Routine "${input.name}": task "${task.name}" depends on unknown task "${dep}"`
+          );
+        }
+      }
+    }
+  }
+  createPlan({
+    goal: input.name,
+    tasks: input.tasks
+  });
+  return {
+    id,
+    name: input.name,
+    description: input.description,
+    version: input.version,
+    tasks: input.tasks,
+    requiredTools: input.requiredTools,
+    requiredPlugins: input.requiredPlugins,
+    instructions: input.instructions,
+    concurrency: input.concurrency,
+    allowDynamicTasks: input.allowDynamicTasks ?? false,
+    tags: input.tags,
+    author: input.author,
+    createdAt: now,
+    updatedAt: now,
+    metadata: input.metadata
+  };
+}
+function createRoutineExecution(definition) {
+  const now = Date.now();
+  const executionId = `rexec-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  const plan = createPlan({
+    goal: definition.name,
+    context: definition.description,
+    tasks: definition.tasks,
+    concurrency: definition.concurrency,
+    allowDynamicTasks: definition.allowDynamicTasks
+  });
+  return {
+    id: executionId,
+    routineId: definition.id,
+    plan,
+    status: "pending",
+    progress: 0,
+    lastUpdatedAt: now
+  };
+}
+function getRoutineProgress(execution) {
+  const { tasks } = execution.plan;
+  if (tasks.length === 0) return 100;
+  const completed = tasks.filter((t) => isTerminalStatus(t.status)).length;
+  return Math.round(completed / tasks.length * 100);
+}
+
+// src/utils/jsonExtractor.ts
+function extractJSON(text) {
+  if (!text || typeof text !== "string") {
+    return {
+      success: false,
+      error: "Input is empty or not a string"
+    };
+  }
+  const trimmedText = text.trim();
+  const codeBlockResult = extractFromCodeBlock(trimmedText);
+  if (codeBlockResult.success) {
+    return codeBlockResult;
+  }
+  const inlineResult = extractInlineJSON(trimmedText);
+  if (inlineResult.success) {
+    return inlineResult;
+  }
+  try {
+    const data = JSON.parse(trimmedText);
+    return {
+      success: true,
+      data,
+      rawJson: trimmedText,
+      method: "raw"
+    };
+  } catch (e) {
+    return {
+      success: false,
+      error: `Could not extract JSON from text: ${e instanceof Error ? e.message : String(e)}`
+    };
+  }
+}
+function extractFromCodeBlock(text) {
+  const codeBlockRegex = /```(?:json)?\s*([\s\S]*?)```/g;
+  let match;
+  while ((match = codeBlockRegex.exec(text)) !== null) {
+    const content = match[1];
+    if (content) {
+      const trimmed = content.trim();
+      try {
+        const data = JSON.parse(trimmed);
+        return {
+          success: true,
+          data,
+          rawJson: trimmed,
+          method: "code_block"
+        };
+      } catch {
+        continue;
+      }
+    }
+  }
+  return { success: false };
+}
+function extractInlineJSON(text) {
+  const objectMatch = findJSONObject(text);
+  if (objectMatch) {
+    try {
+      const data = JSON.parse(objectMatch);
+      return {
+        success: true,
+        data,
+        rawJson: objectMatch,
+        method: "inline"
+      };
+    } catch {
+    }
+  }
+  const arrayMatch = findJSONArray(text);
+  if (arrayMatch) {
+    try {
+      const data = JSON.parse(arrayMatch);
+      return {
+        success: true,
+        data,
+        rawJson: arrayMatch,
+        method: "inline"
+      };
+    } catch {
+    }
+  }
+  return { success: false };
+}
+function findJSONObject(text) {
+  const startIndex = text.indexOf("{");
+  if (startIndex === -1) return null;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = startIndex; i < text.length; i++) {
+    const char = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (char === "{") {
+      depth++;
+    } else if (char === "}") {
+      depth--;
+      if (depth === 0) {
+        return text.slice(startIndex, i + 1);
+      }
+    }
+  }
+  return null;
+}
+function findJSONArray(text) {
+  const startIndex = text.indexOf("[");
+  if (startIndex === -1) return null;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = startIndex; i < text.length; i++) {
+    const char = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (char === "[") {
+      depth++;
+    } else if (char === "]") {
+      depth--;
+      if (depth === 0) {
+        return text.slice(startIndex, i + 1);
+      }
+    }
+  }
+  return null;
+}
+function extractJSONField(text, field, defaultValue) {
+  const result = extractJSON(text);
+  if (result.success && result.data && field in result.data) {
+    return result.data[field];
+  }
+  return defaultValue;
+}
+function extractNumber(text, patterns = [
+  /(\d{1,3})%?\s*(?:complete|score|percent)/i,
+  /(?:score|completion|rating)[:\s]+(\d{1,3})/i,
+  /(\d{1,3})\s*(?:out of|\/)\s*100/i
+], defaultValue = 0) {
+  const jsonResult = extractJSON(text);
+  if (jsonResult.success && jsonResult.data) {
+    const scoreFields = ["score", "completionScore", "completion_score", "rating", "percent", "value"];
+    for (const field of scoreFields) {
+      if (field in jsonResult.data && typeof jsonResult.data[field] === "number") {
+        return jsonResult.data[field];
+      }
+    }
+  }
+  for (const pattern of patterns) {
+    const match = text.match(pattern);
+    if (match && match[1]) {
+      const num = parseInt(match[1], 10);
+      if (!isNaN(num)) {
+        return num;
+      }
+    }
+  }
+  return defaultValue;
+}
+
+// src/core/routineRunner.ts
+init_Logger();
+function defaultSystemPrompt(definition) {
+  const parts = [];
+  if (definition.instructions) {
+    parts.push(definition.instructions);
+  }
+  parts.push(
+    `You are executing a routine called "${definition.name}".`,
+    "",
+    "Between tasks, your conversation history is cleared but your memory persists.",
+    "Use these strategies to pass information between tasks:",
+    "- Use context_set for small key results that subsequent tasks need immediately (visible in context, no retrieval needed).",
+    '- Use memory_store with tier="findings" for larger data that may be needed later.',
+    "- Use memory_retrieve to access data stored by previous tasks.",
+    "",
+    "IMPORTANT: When you have completed the current task, you MUST stop immediately.",
+    "Do NOT repeat work you have already done. Do NOT re-fetch data you already have.",
+    "Store key results in memory once, then produce a final text response (no more tool calls) to signal completion."
+  );
+  return parts.join("\n");
+}
+function defaultTaskPrompt(task) {
+  const parts = [];
+  parts.push(`## Current Task: ${task.name}`, "");
+  parts.push(task.description, "");
+  if (task.expectedOutput) {
+    parts.push(`**Expected output:** ${task.expectedOutput}`, "");
+  }
+  if (task.suggestedTools && task.suggestedTools.length > 0) {
+    parts.push(`**Suggested tools:** ${task.suggestedTools.join(", ")}`, "");
+  }
+  const criteria = task.validation?.completionCriteria;
+  if (criteria && criteria.length > 0) {
+    parts.push("### Completion Criteria");
+    parts.push("When you are done, ensure the following are met:");
+    for (const c of criteria) {
+      parts.push(`- ${c}`);
+    }
+    parts.push("");
+  }
+  if (task.dependsOn.length > 0) {
+    parts.push("Note: Results from prerequisite tasks are available in your live context.");
+    parts.push("Small results appear directly; larger results are in working memory \u2014 use memory_retrieve to access them.");
+    parts.push("Review the plan overview and dependency results before starting.");
+    parts.push("");
+  }
+  parts.push("After completing the work, store key results in memory once, then respond with a text summary (no more tool calls).");
+  return parts.join("\n");
+}
+function defaultValidationPrompt(task, context) {
+  const criteria = task.validation?.completionCriteria ?? [];
+  const criteriaList = criteria.length > 0 ? criteria.map((c, i) => `${i + 1}. ${c}`).join("\n") : "The task was completed as described.";
+  const parts = [
+    `Evaluate if the task "${task.name}" was completed successfully.`,
+    "",
+    `Task description: ${task.description}`,
+    "",
+    "Completion criteria:",
+    criteriaList,
+    "",
+    "--- EVIDENCE ---",
+    "",
+    "Agent response (final text output):",
+    context.responseText || "(no text output)",
+    "",
+    "Tool calls made during this task:",
+    context.toolCallLog
+  ];
+  if (context.inContextMemory) {
+    parts.push("", "In-context memory (current state):", context.inContextMemory);
+  }
+  if (context.workingMemoryIndex) {
+    parts.push("", "Working memory index (stored data):", context.workingMemoryIndex);
+  }
+  parts.push(
+    "",
+    "--- END EVIDENCE ---",
+    "",
+    "Use the evidence above to verify each criterion. Check tool call results, not just the agent's claims.",
+    "",
+    "Return a JSON object with the following structure:",
+    "```json",
+    '{ "isComplete": boolean, "completionScore": number (0-100), "explanation": "..." }',
+    "```",
+    "",
+    "Be strict: only mark isComplete=true if all criteria are clearly met based on the evidence."
+  );
+  return parts.join("\n");
+}
+function formatToolCallLog(conversation) {
+  const calls = [];
+  for (const item of conversation) {
+    if (!("content" in item) || !Array.isArray(item.content)) continue;
+    const msg = item;
+    for (const c of msg.content) {
+      if (c.type === "tool_use" /* TOOL_USE */) {
+        let argsStr;
+        try {
+          const parsed = JSON.parse(c.arguments);
+          argsStr = JSON.stringify(parsed, null, 2);
+          if (argsStr.length > 500) argsStr = argsStr.slice(0, 500) + "... (truncated)";
+        } catch {
+          argsStr = c.arguments;
+        }
+        calls.push(`CALL: ${c.name}(${argsStr})`);
+      } else if (c.type === "tool_result" /* TOOL_RESULT */) {
+        let resultStr = typeof c.content === "string" ? c.content : JSON.stringify(c.content);
+        if (resultStr.length > 500) resultStr = resultStr.slice(0, 500) + "... (truncated)";
+        const prefix = c.error ? "ERROR" : "RESULT";
+        calls.push(`  ${prefix}: ${resultStr}`);
+      }
+    }
+  }
+  return calls.length > 0 ? calls.join("\n") : "(no tool calls)";
+}
+async function collectValidationContext(agent, responseText) {
+  const icmPlugin = agent.context.getPlugin("in_context_memory");
+  const inContextMemory = icmPlugin ? await icmPlugin.getContent() : null;
+  const wmPlugin = agent.context.memory;
+  const workingMemoryIndex = wmPlugin ? await wmPlugin.getContent() : null;
+  const conversation = agent.context.getConversation();
+  const toolCallLog = formatToolCallLog(conversation);
+  return {
+    responseText,
+    inContextMemory,
+    workingMemoryIndex,
+    toolCallLog
+  };
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function buildPlanOverview(execution, definition, currentTaskId) {
+  const parts = [];
+  const progress = execution.progress ?? 0;
+  parts.push(`Routine: ${definition.name}`);
+  if (definition.description) {
+    parts.push(`Goal: ${definition.description}`);
+  }
+  parts.push(`Progress: ${Math.round(progress * 100)}%`);
+  parts.push("");
+  parts.push("Tasks:");
+  for (const task of execution.plan.tasks) {
+    let statusIcon;
+    switch (task.status) {
+      case "completed":
+        statusIcon = "[x]";
+        break;
+      case "in_progress":
+        statusIcon = "[>]";
+        break;
+      case "failed":
+        statusIcon = "[!]";
+        break;
+      case "skipped":
+        statusIcon = "[-]";
+        break;
+      default:
+        statusIcon = "[ ]";
+    }
+    let line = `${statusIcon} ${task.name}`;
+    if (task.dependsOn.length > 0) {
+      const depNames = task.dependsOn.map((depId) => execution.plan.tasks.find((t) => t.id === depId)?.name ?? depId).join(", ");
+      line += ` (after: ${depNames})`;
+    }
+    if (task.id === currentTaskId) {
+      line += "  \u2190 CURRENT";
+    }
+    parts.push(line);
+  }
+  return parts.join("\n");
+}
+async function injectRoutineContext(agent, execution, definition, currentTask) {
+  const icmPlugin = agent.context.getPlugin("in_context_memory");
+  const wmPlugin = agent.context.memory;
+  if (!icmPlugin && !wmPlugin) {
+    exports.logger.warn("injectRoutineContext: No ICM or WM plugin available \u2014 skipping context injection");
+    return;
+  }
+  const planOverview = buildPlanOverview(execution, definition, currentTask.id);
+  if (icmPlugin) {
+    icmPlugin.set("__routine_plan", "Routine plan overview with task statuses", planOverview, "high");
+  }
+  if (icmPlugin) {
+    for (const entry of icmPlugin.list()) {
+      if (entry.key.startsWith("__dep_result_") || entry.key === "__routine_deps") {
+        icmPlugin.delete(entry.key);
+      }
+    }
+  }
+  if (wmPlugin) {
+    const { entries: wmEntries } = await wmPlugin.query();
+    for (const entry of wmEntries) {
+      if (entry.key.startsWith("__dep_result_") || entry.key.startsWith("findings/__dep_result_")) {
+        await wmPlugin.delete(entry.key);
+      }
+    }
+  }
+  if (currentTask.dependsOn.length === 0) return;
+  const inContextDeps = [];
+  const workingMemoryDeps = [];
+  for (const depId of currentTask.dependsOn) {
+    const depTask = execution.plan.tasks.find((t) => t.id === depId);
+    if (!depTask?.result?.output) continue;
+    const output = typeof depTask.result.output === "string" ? depTask.result.output : JSON.stringify(depTask.result.output);
+    const tokens = estimateTokens(output);
+    const depKey = `__dep_result_${depId}`;
+    const depLabel = `Result from task "${depTask.name}"`;
+    if (tokens < 5e3 && icmPlugin) {
+      icmPlugin.set(depKey, depLabel, output, "high");
+      inContextDeps.push(depTask.name);
+    } else if (wmPlugin) {
+      await wmPlugin.store(depKey, depLabel, output, { tier: "findings" });
+      workingMemoryDeps.push(depTask.name);
+    } else if (icmPlugin) {
+      const truncated = output.slice(0, 2e4) + "\n... (truncated, full result not available)";
+      icmPlugin.set(depKey, depLabel, truncated, "high");
+      inContextDeps.push(depTask.name + " (truncated)");
+    }
+  }
+  if (icmPlugin && (inContextDeps.length > 0 || workingMemoryDeps.length > 0)) {
+    const summaryParts = ["Dependency results available:"];
+    if (inContextDeps.length > 0) {
+      summaryParts.push(`In context (visible now): ${inContextDeps.join(", ")}`);
+    }
+    if (workingMemoryDeps.length > 0) {
+      summaryParts.push(`In working memory (use memory_retrieve): ${workingMemoryDeps.join(", ")}`);
+    }
+    icmPlugin.set("__routine_deps", "Dependency results location guide", summaryParts.join("\n"), "high");
+  }
+}
+async function cleanupRoutineContext(agent) {
+  const icmPlugin = agent.context.getPlugin("in_context_memory");
+  const wmPlugin = agent.context.memory;
+  if (icmPlugin) {
+    for (const entry of icmPlugin.list()) {
+      if (entry.key.startsWith("__routine_") || entry.key.startsWith("__dep_result_")) {
+        icmPlugin.delete(entry.key);
+      }
+    }
+  }
+  if (wmPlugin) {
+    const { entries: wmEntries } = await wmPlugin.query();
+    for (const entry of wmEntries) {
+      if (entry.key.startsWith("__dep_result_") || entry.key.startsWith("findings/__dep_result_")) {
+        await wmPlugin.delete(entry.key);
+      }
+    }
+  }
+}
+async function validateTaskCompletion(agent, task, responseText, validationPromptBuilder) {
+  const hasExplicitValidation = task.validation?.skipReflection === false && task.validation?.completionCriteria && task.validation.completionCriteria.length > 0;
+  if (!hasExplicitValidation) {
+    return {
+      isComplete: true,
+      completionScore: 100,
+      explanation: "Auto-passed (LLM validation not enabled)",
+      requiresUserApproval: false
+    };
+  }
+  const validationContext = await collectValidationContext(agent, responseText);
+  const prompt = validationPromptBuilder(task, validationContext);
+  const response = await agent.runDirect(prompt, {
+    instructions: "You are a task completion evaluator. Return only JSON.",
+    temperature: 0.1
+  });
+  const text = response.output_text ?? "";
+  const extracted = extractJSON(text);
+  if (!extracted.success || !extracted.data) {
+    return {
+      isComplete: false,
+      completionScore: 0,
+      explanation: `Failed to parse validation response: ${extracted.error ?? "unknown error"}`,
+      requiresUserApproval: false
+    };
+  }
+  const { isComplete, completionScore, explanation } = extracted.data;
+  const minScore = task.validation?.minCompletionScore ?? 80;
+  return {
+    isComplete: isComplete && completionScore >= minScore,
+    completionScore,
+    explanation,
+    requiresUserApproval: false
+  };
+}
+async function executeRoutine(options) {
+  const {
+    definition,
+    agent: existingAgent,
+    connector,
+    model,
+    tools: extraTools,
+    onTaskStarted,
+    onTaskComplete,
+    onTaskFailed,
+    onTaskValidation,
+    hooks,
+    prompts
+  } = options;
+  if (!existingAgent && (!connector || !model)) {
+    throw new Error("executeRoutine requires either `agent` or both `connector` and `model`");
+  }
+  const ownsAgent = !existingAgent;
+  const log = exports.logger.child({ routine: definition.name });
+  const execution = createRoutineExecution(definition);
+  execution.status = "running";
+  execution.startedAt = Date.now();
+  execution.lastUpdatedAt = Date.now();
+  const buildSystemPrompt = prompts?.system ?? defaultSystemPrompt;
+  const buildTaskPrompt = prompts?.task ?? defaultTaskPrompt;
+  const buildValidationPrompt = prompts?.validation ?? defaultValidationPrompt;
+  let agent;
+  const registeredHooks = [];
+  if (existingAgent) {
+    agent = existingAgent;
+    if (hooks) {
+      const hookNames = [
+        "before:execution",
+        "after:execution",
+        "before:llm",
+        "after:llm",
+        "before:tool",
+        "after:tool",
+        "approve:tool",
+        "pause:check"
+      ];
+      for (const name of hookNames) {
+        const hook = hooks[name];
+        if (hook) {
+          agent.registerHook(name, hook);
+          registeredHooks.push({ name, hook });
+        }
+      }
+    }
+  } else {
+    const allTools = [...extraTools ?? []];
+    if (definition.requiredTools && definition.requiredTools.length > 0) {
+      const availableToolNames = new Set(allTools.map((t) => t.definition.function.name));
+      const missing = definition.requiredTools.filter((name) => !availableToolNames.has(name));
+      if (missing.length > 0) {
+        execution.status = "failed";
+        execution.error = `Missing required tools: ${missing.join(", ")}`;
+        execution.completedAt = Date.now();
+        execution.lastUpdatedAt = Date.now();
+        return execution;
+      }
+    }
+    agent = Agent.create({
+      connector,
+      model,
+      tools: allTools,
+      instructions: buildSystemPrompt(definition),
+      hooks,
+      context: {
+        model,
+        features: {
+          workingMemory: true,
+          inContextMemory: true
+        }
+      }
+    });
+  }
+  if (definition.requiredPlugins && definition.requiredPlugins.length > 0) {
+    const missing = definition.requiredPlugins.filter(
+      (name) => !agent.context.hasPlugin(name)
+    );
+    if (missing.length > 0) {
+      if (ownsAgent) agent.destroy();
+      execution.status = "failed";
+      execution.error = `Missing required plugins: ${missing.join(", ")}`;
+      execution.completedAt = Date.now();
+      execution.lastUpdatedAt = Date.now();
+      return execution;
+    }
+  }
+  const failureMode = definition.concurrency?.failureMode ?? "fail-fast";
+  try {
+    let nextTasks = getNextExecutableTasks(execution.plan);
+    while (nextTasks.length > 0) {
+      const task = nextTasks[0];
+      const taskIndex = execution.plan.tasks.findIndex((t) => t.id === task.id);
+      log.info({ taskName: task.name, taskId: task.id }, "Starting task");
+      execution.plan.tasks[taskIndex] = updateTaskStatus(task, "in_progress");
+      execution.lastUpdatedAt = Date.now();
+      onTaskStarted?.(execution.plan.tasks[taskIndex], execution);
+      let taskCompleted = false;
+      const maxTaskIterations = task.execution?.maxIterations ?? 15;
+      const iterationLimiter = async (ctx) => {
+        if (ctx.iteration >= maxTaskIterations) {
+          agent.cancel(`Task "${task.name}" exceeded max iterations (${maxTaskIterations})`);
+        }
+        return { shouldPause: false };
+      };
+      agent.registerHook("pause:check", iterationLimiter);
+      const getTask = () => execution.plan.tasks[taskIndex];
+      await injectRoutineContext(agent, execution, definition, getTask());
+      while (!taskCompleted) {
+        try {
+          const taskPrompt = buildTaskPrompt(getTask());
+          const response = await agent.run(taskPrompt);
+          const responseText = response.output_text ?? "";
+          const validationResult = await validateTaskCompletion(
+            agent,
+            getTask(),
+            responseText,
+            buildValidationPrompt
+          );
+          onTaskValidation?.(getTask(), validationResult, execution);
+          if (validationResult.isComplete) {
+            execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "completed");
+            execution.plan.tasks[taskIndex].result = {
+              success: true,
+              output: responseText,
+              validationScore: validationResult.completionScore,
+              validationExplanation: validationResult.explanation
+            };
+            taskCompleted = true;
+            log.info(
+              { taskName: getTask().name, score: validationResult.completionScore },
+              "Task completed"
+            );
+            execution.progress = getRoutineProgress(execution);
+            execution.lastUpdatedAt = Date.now();
+            onTaskComplete?.(execution.plan.tasks[taskIndex], execution);
+          } else {
+            log.warn(
+              {
+                taskName: getTask().name,
+                score: validationResult.completionScore,
+                attempt: getTask().attempts,
+                maxAttempts: getTask().maxAttempts
+              },
+              "Task validation failed"
+            );
+            if (getTask().attempts >= getTask().maxAttempts) {
+              execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "failed");
+              execution.plan.tasks[taskIndex].result = {
+                success: false,
+                error: validationResult.explanation,
+                validationScore: validationResult.completionScore,
+                validationExplanation: validationResult.explanation
+              };
+              break;
+            }
+            execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "in_progress");
+          }
+        } catch (error) {
+          const errorMessage = error.message;
+          log.error({ taskName: getTask().name, error: errorMessage }, "Task execution error");
+          if (getTask().attempts >= getTask().maxAttempts) {
+            execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "failed");
+            execution.plan.tasks[taskIndex].result = {
+              success: false,
+              error: errorMessage
+            };
+            break;
+          }
+          execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "in_progress");
+        }
+      }
+      if (!taskCompleted) {
+        execution.progress = getRoutineProgress(execution);
+        execution.lastUpdatedAt = Date.now();
+        onTaskFailed?.(execution.plan.tasks[taskIndex], execution);
+        if (failureMode === "fail-fast") {
+          execution.status = "failed";
+          execution.error = `Task "${getTask().name}" failed after ${getTask().attempts} attempt(s)`;
+          execution.completedAt = Date.now();
+          execution.lastUpdatedAt = Date.now();
+          break;
+        }
+      }
+      agent.unregisterHook("pause:check", iterationLimiter);
+      agent.clearConversation("task-boundary");
+      nextTasks = getNextExecutableTasks(execution.plan);
+    }
+    if (execution.status === "running") {
+      const allTerminal = execution.plan.tasks.every((t) => isTerminalStatus(t.status));
+      const allCompleted = execution.plan.tasks.every((t) => t.status === "completed");
+      if (allCompleted) {
+        execution.status = "completed";
+      } else if (allTerminal) {
+        execution.status = "failed";
+        execution.error = "Not all tasks completed successfully";
+      } else {
+        execution.status = "failed";
+        execution.error = "Execution stalled: remaining tasks are blocked by incomplete dependencies";
+      }
+      execution.completedAt = Date.now();
+      execution.lastUpdatedAt = Date.now();
+      execution.progress = getRoutineProgress(execution);
+    }
+    log.info(
+      { status: execution.status, progress: execution.progress },
+      "Routine execution finished"
+    );
+    return execution;
+  } finally {
+    try {
+      await cleanupRoutineContext(agent);
+    } catch {
+    }
+    for (const { name, hook } of registeredHooks) {
+      try {
+        agent.unregisterHook(name, hook);
+      } catch {
+      }
+    }
+    if (ownsAgent) {
+      agent.destroy();
+    }
+  }
+}
+
 // src/core/index.ts
 init_constants();
 (class {
@@ -23382,7 +24421,7 @@ init_constants();
       throw new Error("Configuration file not found. Searched: " + this.DEFAULT_PATHS.join(", "));
     }
     try {
-      const content = await fs18.promises.readFile(configPath, "utf-8");
+      const content = await fs19.promises.readFile(configPath, "utf-8");
       let config = JSON.parse(content);
       config = this.interpolateEnvVars(config);
       this.validate(config);
@@ -23403,8 +24442,8 @@ init_constants();
       throw new Error("Configuration file not found. Searched: " + this.DEFAULT_PATHS.join(", "));
     }
     try {
-      const fs19 = __require("fs");
-      const content = fs19.readFileSync(configPath, "utf-8");
+      const fs20 = __require("fs");
+      const content = fs20.readFileSync(configPath, "utf-8");
       let config = JSON.parse(content);
       config = this.interpolateEnvVars(config);
       this.validate(config);
@@ -23422,7 +24461,7 @@ init_constants();
   static async findConfig() {
     for (const path6 of this.DEFAULT_PATHS) {
       try {
-        await fs18.promises.access(path2.resolve(path6));
+        await fs19.promises.access(path2.resolve(path6));
         return path2.resolve(path6);
       } catch {
       }
@@ -23433,10 +24472,10 @@ init_constants();
    * Find configuration file synchronously
    */
   static findConfigSync() {
-    const fs19 = __require("fs");
+    const fs20 = __require("fs");
     for (const path6 of this.DEFAULT_PATHS) {
       try {
-        fs19.accessSync(path2.resolve(path6));
+        fs20.accessSync(path2.resolve(path6));
         return path2.resolve(path6);
       } catch {
       }
@@ -29010,7 +30049,7 @@ var MCPRegistry = class {
   static async loadFromConfigFile(path6) {
     try {
       const configPath = path2.resolve(path6);
-      const content = await fs18.promises.readFile(configPath, "utf-8");
+      const content = await fs19.promises.readFile(configPath, "utf-8");
       const config = JSON.parse(content);
       if (!config.mcp) {
         throw new MCPError("Configuration file does not contain MCP section");
@@ -29615,7 +30654,7 @@ var OpenAISTTProvider = class extends BaseMediaProvider {
     if (Buffer.isBuffer(audio)) {
       return new File([new Uint8Array(audio)], "audio.wav", { type: "audio/wav" });
     } else if (typeof audio === "string") {
-      return fs18__namespace.createReadStream(audio);
+      return fs19__namespace.createReadStream(audio);
     } else {
       throw new Error("Invalid audio input: must be Buffer or file path");
     }
@@ -30168,7 +31207,7 @@ var TextToSpeech = class _TextToSpeech {
    */
   async toFile(text, filePath, options) {
     const response = await this.synthesize(text, options);
-    await fs17__namespace.writeFile(filePath, response.audio);
+    await fs18__namespace.writeFile(filePath, response.audio);
   }
   // ======================== Introspection Methods ========================
   /**
@@ -30516,7 +31555,7 @@ var SpeechToText = class _SpeechToText {
    * @param options - Optional transcription parameters
    */
   async transcribeFile(filePath, options) {
-    const audio = await fs17__namespace.readFile(filePath);
+    const audio = await fs18__namespace.readFile(filePath);
     return this.transcribe(audio, options);
   }
   /**
@@ -30842,7 +31881,7 @@ var OpenAIImageProvider = class extends BaseMediaProvider {
     if (Buffer.isBuffer(image)) {
       return new File([new Uint8Array(image)], "image.png", { type: "image/png" });
     }
-    return fs18__namespace.createReadStream(image);
+    return fs19__namespace.createReadStream(image);
   }
   /**
    * Handle OpenAI API errors
@@ -30989,8 +32028,8 @@ var GoogleImageProvider = class extends BaseMediaProvider {
     if (Buffer.isBuffer(image)) {
       imageBytes = image.toString("base64");
     } else {
-      const fs19 = await import('fs');
-      const buffer = fs19.readFileSync(image);
+      const fs20 = await import('fs');
+      const buffer = fs20.readFileSync(image);
       imageBytes = buffer.toString("base64");
     }
     return {
@@ -31151,7 +32190,7 @@ var GrokImageProvider = class extends BaseMediaProvider {
     if (Buffer.isBuffer(image)) {
       return new File([new Uint8Array(image)], "image.png", { type: "image/png" });
     }
-    return fs18__namespace.createReadStream(image);
+    return fs19__namespace.createReadStream(image);
   }
   /**
    * Handle API errors
@@ -32601,8 +33640,8 @@ var OpenAISoraProvider = class extends BaseMediaProvider {
       return new File([new Uint8Array(image)], "input.png", { type: "image/png" });
     }
     if (!image.startsWith("http")) {
-      const fs19 = await import('fs');
-      const data = fs19.readFileSync(image);
+      const fs20 = await import('fs');
+      const data = fs20.readFileSync(image);
       return new File([new Uint8Array(data)], "input.png", { type: "image/png" });
     }
     const response = await fetch(image);
@@ -32780,7 +33819,7 @@ var GoogleVeoProvider = class extends BaseMediaProvider {
           if (video.videoBytes) {
             buffer = Buffer.from(video.videoBytes, "base64");
           } else if (video.uri) {
-            const fs19 = await import('fs/promises');
+            const fs20 = await import('fs/promises');
             const os3 = await import('os');
             const path6 = await import('path');
             const tempDir = os3.tmpdir();
@@ -32791,11 +33830,11 @@ var GoogleVeoProvider = class extends BaseMediaProvider {
                 // Pass as GeneratedVideo
                 downloadPath: tempFile
               });
-              buffer = await fs19.readFile(tempFile);
-              await fs19.unlink(tempFile).catch(() => {
+              buffer = await fs20.readFile(tempFile);
+              await fs20.unlink(tempFile).catch(() => {
               });
             } catch (downloadError) {
-              await fs19.unlink(tempFile).catch(() => {
+              await fs20.unlink(tempFile).catch(() => {
               });
               throw new ProviderError(
                 "google",
@@ -32917,8 +33956,8 @@ var GoogleVeoProvider = class extends BaseMediaProvider {
     if (image.startsWith("http://") || image.startsWith("https://")) {
       return { imageUri: image };
     }
-    const fs19 = await import('fs/promises');
-    const data = await fs19.readFile(image);
+    const fs20 = await import('fs/promises');
+    const data = await fs20.readFile(image);
     return {
       imageBytes: data.toString("base64")
     };
@@ -33225,8 +34264,8 @@ var GrokImagineProvider = class extends BaseMediaProvider {
     if (image.startsWith("http") || image.startsWith("data:")) {
       return image;
     }
-    const fs19 = await import('fs');
-    const data = fs19.readFileSync(image);
+    const fs20 = await import('fs');
+    const data = fs20.readFileSync(image);
     const base64 = data.toString("base64");
     const ext = image.split(".").pop()?.toLowerCase() || "png";
     const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : `image/${ext}`;
@@ -34662,7 +35701,7 @@ var DocumentReader = class _DocumentReader {
   async resolveSource(source) {
     switch (source.type) {
       case "file": {
-        const buffer = await fs17.readFile(source.path);
+        const buffer = await fs18.readFile(source.path);
         const filename = source.path.split("/").pop() || source.path;
         return { buffer, filename };
       }
@@ -35895,245 +36934,6 @@ var CheckpointManager = class {
   }
 };
 
-// src/domain/entities/Task.ts
-var TERMINAL_TASK_STATUSES = ["completed", "failed", "skipped", "cancelled"];
-function isTerminalStatus(status) {
-  return TERMINAL_TASK_STATUSES.includes(status);
-}
-function createTask(input) {
-  const now = Date.now();
-  const id = input.id ?? `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-  return {
-    id,
-    name: input.name,
-    description: input.description,
-    status: "pending",
-    dependsOn: input.dependsOn ?? [],
-    externalDependency: input.externalDependency,
-    condition: input.condition,
-    execution: input.execution,
-    validation: input.validation,
-    expectedOutput: input.expectedOutput,
-    attempts: 0,
-    maxAttempts: input.maxAttempts ?? 3,
-    createdAt: now,
-    lastUpdatedAt: now,
-    metadata: input.metadata
-  };
-}
-function createPlan(input) {
-  const now = Date.now();
-  const id = `plan-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-  const tasks = input.tasks.map((taskInput) => createTask(taskInput));
-  const nameToId = /* @__PURE__ */ new Map();
-  for (const task of tasks) {
-    nameToId.set(task.name, task.id);
-  }
-  for (let i = 0; i < tasks.length; i++) {
-    const taskInput = input.tasks[i];
-    const task = tasks[i];
-    if (taskInput.dependsOn && taskInput.dependsOn.length > 0) {
-      task.dependsOn = taskInput.dependsOn.map((dep) => {
-        if (dep.startsWith("task-")) {
-          return dep;
-        }
-        const resolvedId = nameToId.get(dep);
-        if (!resolvedId) {
-          throw new Error(`Task dependency "${dep}" not found in plan`);
-        }
-        return resolvedId;
-      });
-    }
-  }
-  if (!input.skipCycleCheck) {
-    const cycle = detectDependencyCycle(tasks);
-    if (cycle) {
-      const cycleNames = cycle.map((taskId) => {
-        const task = tasks.find((t) => t.id === taskId);
-        return task ? task.name : taskId;
-      });
-      throw new DependencyCycleError(cycleNames, id);
-    }
-  }
-  return {
-    id,
-    goal: input.goal,
-    context: input.context,
-    tasks,
-    concurrency: input.concurrency,
-    allowDynamicTasks: input.allowDynamicTasks ?? true,
-    status: "pending",
-    createdAt: now,
-    lastUpdatedAt: now,
-    metadata: input.metadata
-  };
-}
-function canTaskExecute(task, allTasks) {
-  if (task.status !== "pending") {
-    return false;
-  }
-  if (task.dependsOn.length > 0) {
-    for (const depId of task.dependsOn) {
-      const depTask = allTasks.find((t) => t.id === depId);
-      if (!depTask || depTask.status !== "completed") {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function getNextExecutableTasks(plan) {
-  const executable = plan.tasks.filter((task) => canTaskExecute(task, plan.tasks));
-  if (executable.length === 0) {
-    return [];
-  }
-  if (!plan.concurrency) {
-    return [executable[0]];
-  }
-  const runningCount = plan.tasks.filter((t) => t.status === "in_progress").length;
-  const availableSlots = plan.concurrency.maxParallelTasks - runningCount;
-  if (availableSlots <= 0) {
-    return [];
-  }
-  const parallelTasks = executable.filter((task) => task.execution?.parallel === true);
-  if (parallelTasks.length === 0) {
-    return [executable[0]];
-  }
-  let sortedTasks = [...parallelTasks];
-  if (plan.concurrency.strategy === "priority") {
-    sortedTasks.sort((a, b) => (b.execution?.priority ?? 0) - (a.execution?.priority ?? 0));
-  }
-  return sortedTasks.slice(0, availableSlots);
-}
-async function evaluateCondition(condition, memory) {
-  const value = await memory.get(condition.memoryKey);
-  switch (condition.operator) {
-    case "exists":
-      return value !== void 0;
-    case "not_exists":
-      return value === void 0;
-    case "equals":
-      return value === condition.value;
-    case "contains":
-      if (Array.isArray(value)) {
-        return value.includes(condition.value);
-      }
-      if (typeof value === "string" && typeof condition.value === "string") {
-        return value.includes(condition.value);
-      }
-      return false;
-    case "truthy":
-      return !!value;
-    case "greater_than":
-      if (typeof value === "number" && typeof condition.value === "number") {
-        return value > condition.value;
-      }
-      return false;
-    case "less_than":
-      if (typeof value === "number" && typeof condition.value === "number") {
-        return value < condition.value;
-      }
-      return false;
-    default:
-      return false;
-  }
-}
-function updateTaskStatus(task, status) {
-  const now = Date.now();
-  const updated = {
-    ...task,
-    status,
-    lastUpdatedAt: now
-  };
-  if (status === "in_progress") {
-    if (!updated.startedAt) {
-      updated.startedAt = now;
-    }
-    updated.attempts += 1;
-  }
-  if ((status === "completed" || status === "failed") && !updated.completedAt) {
-    updated.completedAt = now;
-  }
-  return updated;
-}
-function isTaskBlocked(task, allTasks) {
-  if (task.dependsOn.length === 0) {
-    return false;
-  }
-  for (const depId of task.dependsOn) {
-    const depTask = allTasks.find((t) => t.id === depId);
-    if (!depTask) {
-      return true;
-    }
-    if (depTask.status !== "completed") {
-      return true;
-    }
-  }
-  return false;
-}
-function getTaskDependencies(task, allTasks) {
-  if (task.dependsOn.length === 0) {
-    return [];
-  }
-  return task.dependsOn.map((depId) => allTasks.find((t) => t.id === depId)).filter((t) => t !== void 0);
-}
-function resolveDependencies(taskInputs, tasks) {
-  const nameToId = /* @__PURE__ */ new Map();
-  for (const task of tasks) {
-    nameToId.set(task.name, task.id);
-  }
-  for (const input of taskInputs) {
-    if (input.dependsOn && input.dependsOn.length > 0) {
-      input.dependsOn = input.dependsOn.map((dep) => {
-        if (dep.startsWith("task-")) {
-          return dep;
-        }
-        const resolvedId = nameToId.get(dep);
-        if (!resolvedId) {
-          throw new Error(`Task dependency "${dep}" not found`);
-        }
-        return resolvedId;
-      });
-    }
-  }
-}
-function detectDependencyCycle(tasks) {
-  const visited = /* @__PURE__ */ new Set();
-  const recStack = /* @__PURE__ */ new Set();
-  const taskMap = new Map(tasks.map((t) => [t.id, t]));
-  function dfs(taskId, path6) {
-    if (recStack.has(taskId)) {
-      const cycleStart = path6.indexOf(taskId);
-      return [...path6.slice(cycleStart), taskId];
-    }
-    if (visited.has(taskId)) {
-      return null;
-    }
-    visited.add(taskId);
-    recStack.add(taskId);
-    const task = taskMap.get(taskId);
-    if (task) {
-      for (const depId of task.dependsOn) {
-        const cycle = dfs(depId, [...path6, taskId]);
-        if (cycle) {
-          return cycle;
-        }
-      }
-    }
-    recStack.delete(taskId);
-    return null;
-  }
-  for (const task of tasks) {
-    if (!visited.has(task.id)) {
-      const cycle = dfs(task.id, []);
-      if (cycle) {
-        return cycle;
-      }
-    }
-  }
-  return null;
-}
-
 // src/capabilities/taskAgent/PlanningAgent.ts
 var PLANNING_SYSTEM_PROMPT = `You are an AI planning agent. Your job is to analyze goals and break them down into structured, executable task plans.
 
@@ -36981,11 +37781,11 @@ var FileContextStorage = class {
     const data = this.prettyPrint ? JSON.stringify(storedSession, null, 2) : JSON.stringify(storedSession);
     const tempPath = `${filePath}.tmp`;
     try {
-      await fs18.promises.writeFile(tempPath, data, "utf-8");
-      await fs18.promises.rename(tempPath, filePath);
+      await fs19.promises.writeFile(tempPath, data, "utf-8");
+      await fs19.promises.rename(tempPath, filePath);
     } catch (error) {
       try {
-        await fs18.promises.unlink(tempPath);
+        await fs19.promises.unlink(tempPath);
       } catch {
       }
       throw error;
@@ -37006,7 +37806,7 @@ var FileContextStorage = class {
     const sanitizedSessionId = sanitizeId(sessionId);
     const filePath = this.getFilePath(sanitizedSessionId);
     try {
-      await fs18.promises.unlink(filePath);
+      await fs19.promises.unlink(filePath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
         throw error;
@@ -37021,7 +37821,7 @@ var FileContextStorage = class {
     const sanitizedSessionId = sanitizeId(sessionId);
     const filePath = this.getFilePath(sanitizedSessionId);
     try {
-      await fs18.promises.access(filePath);
+      await fs19.promises.access(filePath);
       return true;
     } catch {
       return false;
@@ -37086,7 +37886,7 @@ var FileContextStorage = class {
     const sanitizedSessionId = sanitizeId(sessionId);
     const filePath = this.getFilePath(sanitizedSessionId);
     const data = this.prettyPrint ? JSON.stringify(stored, null, 2) : JSON.stringify(stored);
-    await fs18.promises.writeFile(filePath, data, "utf-8");
+    await fs19.promises.writeFile(filePath, data, "utf-8");
     await this.updateIndex(stored);
   }
   /**
@@ -37114,13 +37914,13 @@ var FileContextStorage = class {
    */
   async rebuildIndex() {
     await this.ensureDirectory();
-    const files = await fs18.promises.readdir(this.sessionsDirectory);
+    const files = await fs19.promises.readdir(this.sessionsDirectory);
     const sessionFiles = files.filter((f) => f.endsWith(".json") && !f.startsWith("_"));
     const entries = [];
     for (const file of sessionFiles) {
       try {
         const filePath = path2.join(this.sessionsDirectory, file);
-        const data = await fs18.promises.readFile(filePath, "utf-8");
+        const data = await fs19.promises.readFile(filePath, "utf-8");
         const stored = JSON.parse(data);
         entries.push(this.storedToIndexEntry(stored));
       } catch {
@@ -37142,7 +37942,7 @@ var FileContextStorage = class {
   }
   async ensureDirectory() {
     try {
-      await fs18.promises.mkdir(this.sessionsDirectory, { recursive: true });
+      await fs19.promises.mkdir(this.sessionsDirectory, { recursive: true });
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "EEXIST") {
         throw error;
@@ -37152,7 +37952,7 @@ var FileContextStorage = class {
   async loadRaw(sanitizedSessionId) {
     const filePath = this.getFilePath(sanitizedSessionId);
     try {
-      const data = await fs18.promises.readFile(filePath, "utf-8");
+      const data = await fs19.promises.readFile(filePath, "utf-8");
       return JSON.parse(data);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -37170,7 +37970,7 @@ var FileContextStorage = class {
       return this.index;
     }
     try {
-      const data = await fs18.promises.readFile(this.indexPath, "utf-8");
+      const data = await fs19.promises.readFile(this.indexPath, "utf-8");
       this.index = JSON.parse(data);
       return this.index;
     } catch (error) {
@@ -37191,7 +37991,7 @@ var FileContextStorage = class {
     await this.ensureDirectory();
     this.index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
     const data = this.prettyPrint ? JSON.stringify(this.index, null, 2) : JSON.stringify(this.index);
-    await fs18.promises.writeFile(this.indexPath, data, "utf-8");
+    await fs19.promises.writeFile(this.indexPath, data, "utf-8");
   }
   async updateIndex(stored) {
     const index = await this.loadIndex();
@@ -37265,11 +38065,11 @@ var FileAgentDefinitionStorage = class {
     const data = this.prettyPrint ? JSON.stringify(definition, null, 2) : JSON.stringify(definition);
     const tempPath = `${filePath}.tmp`;
     try {
-      await fs18.promises.writeFile(tempPath, data, "utf-8");
-      await fs18.promises.rename(tempPath, filePath);
+      await fs19.promises.writeFile(tempPath, data, "utf-8");
+      await fs19.promises.rename(tempPath, filePath);
     } catch (error) {
       try {
-        await fs18.promises.unlink(tempPath);
+        await fs19.promises.unlink(tempPath);
       } catch {
       }
       throw error;
@@ -37291,7 +38091,7 @@ var FileAgentDefinitionStorage = class {
     const agentDir = path2.join(this.baseDirectory, sanitizedId);
     const filePath = path2.join(agentDir, "definition.json");
     try {
-      await fs18.promises.unlink(filePath);
+      await fs19.promises.unlink(filePath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
         throw error;
@@ -37306,7 +38106,7 @@ var FileAgentDefinitionStorage = class {
     const sanitizedId = sanitizeAgentId2(agentId);
     const filePath = path2.join(this.baseDirectory, sanitizedId, "definition.json");
     try {
-      await fs18.promises.access(filePath);
+      await fs19.promises.access(filePath);
       return true;
     } catch {
       return false;
@@ -37368,13 +38168,13 @@ var FileAgentDefinitionStorage = class {
    */
   async rebuildIndex() {
     await this.ensureDirectory(this.baseDirectory);
-    const entries = await fs18.promises.readdir(this.baseDirectory, { withFileTypes: true });
+    const entries = await fs19.promises.readdir(this.baseDirectory, { withFileTypes: true });
     const agentDirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith("_"));
     const indexEntries = [];
     for (const dir of agentDirs) {
       try {
         const filePath = path2.join(this.baseDirectory, dir.name, "definition.json");
-        const data = await fs18.promises.readFile(filePath, "utf-8");
+        const data = await fs19.promises.readFile(filePath, "utf-8");
         const definition = JSON.parse(data);
         indexEntries.push(this.definitionToIndexEntry(definition));
       } catch {
@@ -37392,7 +38192,7 @@ var FileAgentDefinitionStorage = class {
   // ==========================================================================
   async ensureDirectory(dir) {
     try {
-      await fs18.promises.mkdir(dir, { recursive: true });
+      await fs19.promises.mkdir(dir, { recursive: true });
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "EEXIST") {
         throw error;
@@ -37402,7 +38202,7 @@ var FileAgentDefinitionStorage = class {
   async loadRaw(sanitizedId) {
     const filePath = path2.join(this.baseDirectory, sanitizedId, "definition.json");
     try {
-      const data = await fs18.promises.readFile(filePath, "utf-8");
+      const data = await fs19.promises.readFile(filePath, "utf-8");
       return JSON.parse(data);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -37420,7 +38220,7 @@ var FileAgentDefinitionStorage = class {
       return this.index;
     }
     try {
-      const data = await fs18.promises.readFile(this.indexPath, "utf-8");
+      const data = await fs19.promises.readFile(this.indexPath, "utf-8");
       this.index = JSON.parse(data);
       return this.index;
     } catch (error) {
@@ -37440,7 +38240,7 @@ var FileAgentDefinitionStorage = class {
     await this.ensureDirectory(this.baseDirectory);
     this.index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
     const data = this.prettyPrint ? JSON.stringify(this.index, null, 2) : JSON.stringify(this.index);
-    await fs18.promises.writeFile(this.indexPath, data, "utf-8");
+    await fs19.promises.writeFile(this.indexPath, data, "utf-8");
   }
   async updateIndex(definition) {
     const index = await this.loadIndex();
@@ -37498,10 +38298,10 @@ var FileMediaStorage = class {
   }
   async save(data, metadata) {
     const dir = metadata.userId ? path2__namespace.join(this.outputDir, metadata.userId) : this.outputDir;
-    await fs17__namespace.mkdir(dir, { recursive: true });
+    await fs18__namespace.mkdir(dir, { recursive: true });
     const filename = metadata.suggestedFilename ?? this.generateFilename(metadata);
     const filePath = path2__namespace.join(dir, filename);
-    await fs17__namespace.writeFile(filePath, data);
+    await fs18__namespace.writeFile(filePath, data);
     const format = metadata.format.toLowerCase();
     const mimeType = MIME_TYPES2[format] ?? "application/octet-stream";
     return {
@@ -37512,7 +38312,7 @@ var FileMediaStorage = class {
   }
   async read(location) {
     try {
-      return await fs17__namespace.readFile(location);
+      return await fs18__namespace.readFile(location);
     } catch (err) {
       if (err.code === "ENOENT") {
         return null;
@@ -37522,7 +38322,7 @@ var FileMediaStorage = class {
   }
   async delete(location) {
     try {
-      await fs17__namespace.unlink(location);
+      await fs18__namespace.unlink(location);
     } catch (err) {
       if (err.code === "ENOENT") {
         return;
@@ -37532,7 +38332,7 @@ var FileMediaStorage = class {
   }
   async exists(location) {
     try {
-      await fs17__namespace.access(location);
+      await fs18__namespace.access(location);
       return true;
     } catch {
       return false;
@@ -37541,11 +38341,11 @@ var FileMediaStorage = class {
   async list(options) {
     await this.ensureDir();
     let entries = [];
-    const files = await fs17__namespace.readdir(this.outputDir);
+    const files = await fs18__namespace.readdir(this.outputDir);
     for (const file of files) {
       const filePath = path2__namespace.join(this.outputDir, file);
       try {
-        const stat6 = await fs17__namespace.stat(filePath);
+        const stat6 = await fs18__namespace.stat(filePath);
         if (!stat6.isFile()) continue;
         const ext = path2__namespace.extname(file).slice(1).toLowerCase();
         const mimeType = MIME_TYPES2[ext] ?? "application/octet-stream";
@@ -37585,7 +38385,7 @@ var FileMediaStorage = class {
   }
   async ensureDir() {
     if (!this.initialized) {
-      await fs17__namespace.mkdir(this.outputDir, { recursive: true });
+      await fs18__namespace.mkdir(this.outputDir, { recursive: true });
       this.initialized = true;
     }
   }
@@ -37650,11 +38450,11 @@ var FileCustomToolStorage = class {
     const data = this.prettyPrint ? JSON.stringify(definition, null, 2) : JSON.stringify(definition);
     const tempPath = `${filePath}.tmp`;
     try {
-      await fs18.promises.writeFile(tempPath, data, "utf-8");
-      await fs18.promises.rename(tempPath, filePath);
+      await fs19.promises.writeFile(tempPath, data, "utf-8");
+      await fs19.promises.rename(tempPath, filePath);
     } catch (error) {
       try {
-        await fs18.promises.unlink(tempPath);
+        await fs19.promises.unlink(tempPath);
       } catch {
       }
       throw error;
@@ -37668,7 +38468,7 @@ var FileCustomToolStorage = class {
     const sanitized = sanitizeName(name);
     const filePath = this.getToolPath(userId, sanitized);
     try {
-      const data = await fs18.promises.readFile(filePath, "utf-8");
+      const data = await fs19.promises.readFile(filePath, "utf-8");
       return JSON.parse(data);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -37687,7 +38487,7 @@ var FileCustomToolStorage = class {
     const sanitized = sanitizeName(name);
     const filePath = this.getToolPath(userId, sanitized);
     try {
-      await fs18.promises.unlink(filePath);
+      await fs19.promises.unlink(filePath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
         throw error;
@@ -37702,7 +38502,7 @@ var FileCustomToolStorage = class {
     const sanitized = sanitizeName(name);
     const filePath = this.getToolPath(userId, sanitized);
     try {
-      await fs18.promises.access(filePath);
+      await fs19.promises.access(filePath);
       return true;
     } catch {
       return false;
@@ -37773,7 +38573,7 @@ var FileCustomToolStorage = class {
   // ==========================================================================
   async ensureDirectory(dir) {
     try {
-      await fs18.promises.mkdir(dir, { recursive: true });
+      await fs19.promises.mkdir(dir, { recursive: true });
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "EEXIST") {
         throw error;
@@ -37783,7 +38583,7 @@ var FileCustomToolStorage = class {
   async loadIndex(userId) {
     const indexPath = this.getUserIndexPath(userId);
     try {
-      const data = await fs18.promises.readFile(indexPath, "utf-8");
+      const data = await fs19.promises.readFile(indexPath, "utf-8");
       return JSON.parse(data);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -37802,7 +38602,7 @@ var FileCustomToolStorage = class {
     await this.ensureDirectory(directory);
     index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
     const data = this.prettyPrint ? JSON.stringify(index, null, 2) : JSON.stringify(index);
-    await fs18.promises.writeFile(indexPath, data, "utf-8");
+    await fs19.promises.writeFile(indexPath, data, "utf-8");
   }
   async updateIndex(userId, definition) {
     const index = await this.loadIndex(userId);
@@ -37835,6 +38635,234 @@ var FileCustomToolStorage = class {
 function createFileCustomToolStorage(config) {
   return new FileCustomToolStorage(config);
 }
+var STORAGE_VERSION = 1;
+var DEFAULT_USER_ID3 = "default";
+function getDefaultBaseDirectory6() {
+  const platform2 = process.platform;
+  if (platform2 === "win32") {
+    const appData = process.env.APPDATA || process.env.LOCALAPPDATA;
+    if (appData) {
+      return path2.join(appData, "oneringai", "users");
+    }
+  }
+  return path2.join(os2.homedir(), ".oneringai", "users");
+}
+function sanitizeUserId3(userId) {
+  if (!userId) {
+    return DEFAULT_USER_ID3;
+  }
+  return userId.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase() || DEFAULT_USER_ID3;
+}
+function sanitizeId2(id) {
+  return id.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase() || "default";
+}
+var FileRoutineDefinitionStorage = class {
+  baseDirectory;
+  prettyPrint;
+  constructor(config = {}) {
+    this.baseDirectory = config.baseDirectory ?? getDefaultBaseDirectory6();
+    this.prettyPrint = config.prettyPrint ?? true;
+  }
+  getUserDirectory(userId) {
+    const sanitizedId = sanitizeUserId3(userId);
+    return path2.join(this.baseDirectory, sanitizedId, "routines");
+  }
+  getIndexPath(userId) {
+    return path2.join(this.getUserDirectory(userId), "_index.json");
+  }
+  getRoutinePath(userId, sanitizedId) {
+    return path2.join(this.getUserDirectory(userId), `${sanitizedId}.json`);
+  }
+  async save(userId, definition) {
+    const directory = this.getUserDirectory(userId);
+    const sanitized = sanitizeId2(definition.id);
+    const filePath = this.getRoutinePath(userId, sanitized);
+    await this.ensureDirectory(directory);
+    const stored = { version: STORAGE_VERSION, definition };
+    const data = this.prettyPrint ? JSON.stringify(stored, null, 2) : JSON.stringify(stored);
+    const tempPath = `${filePath}.tmp`;
+    try {
+      await fs19.promises.writeFile(tempPath, data, "utf-8");
+      await fs19.promises.rename(tempPath, filePath);
+    } catch (error) {
+      try {
+        await fs19.promises.unlink(tempPath);
+      } catch {
+      }
+      throw error;
+    }
+    await this.updateIndex(userId, definition);
+  }
+  async load(userId, id) {
+    const sanitized = sanitizeId2(id);
+    const filePath = this.getRoutinePath(userId, sanitized);
+    try {
+      const data = await fs19.promises.readFile(filePath, "utf-8");
+      const stored = JSON.parse(data);
+      return stored.definition;
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        return null;
+      }
+      if (error instanceof SyntaxError) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async delete(userId, id) {
+    const sanitized = sanitizeId2(id);
+    const filePath = this.getRoutinePath(userId, sanitized);
+    try {
+      await fs19.promises.unlink(filePath);
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    await this.removeFromIndex(userId, id);
+  }
+  async exists(userId, id) {
+    const sanitized = sanitizeId2(id);
+    const filePath = this.getRoutinePath(userId, sanitized);
+    try {
+      await fs19.promises.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async list(userId, options) {
+    const index = await this.loadIndex(userId);
+    let entries = [...index.routines];
+    if (options?.tags && options.tags.length > 0) {
+      entries = entries.filter((e) => {
+        const entryTags = e.tags ?? [];
+        return options.tags.some((t) => entryTags.includes(t));
+      });
+    }
+    if (options?.search) {
+      const searchLower = options.search.toLowerCase();
+      entries = entries.filter(
+        (e) => e.name.toLowerCase().includes(searchLower) || e.description.toLowerCase().includes(searchLower)
+      );
+    }
+    entries.sort(
+      (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+    );
+    if (options?.offset) {
+      entries = entries.slice(options.offset);
+    }
+    if (options?.limit) {
+      entries = entries.slice(0, options.limit);
+    }
+    const results = [];
+    for (const entry of entries) {
+      const def = await this.load(userId, entry.id);
+      if (def) {
+        results.push(def);
+      }
+    }
+    return results;
+  }
+  getPath(userId) {
+    return this.getUserDirectory(userId);
+  }
+  // ==========================================================================
+  // Private Helpers
+  // ==========================================================================
+  async ensureDirectory(dir) {
+    try {
+      await fs19.promises.mkdir(dir, { recursive: true });
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code !== "EEXIST") {
+        throw error;
+      }
+    }
+  }
+  async loadIndex(userId) {
+    const indexPath = this.getIndexPath(userId);
+    try {
+      const data = await fs19.promises.readFile(indexPath, "utf-8");
+      return JSON.parse(data);
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        return await this.rebuildIndex(userId);
+      }
+      throw error;
+    }
+  }
+  async saveIndex(userId, index) {
+    const directory = this.getUserDirectory(userId);
+    const indexPath = this.getIndexPath(userId);
+    await this.ensureDirectory(directory);
+    index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    const data = this.prettyPrint ? JSON.stringify(index, null, 2) : JSON.stringify(index);
+    await fs19.promises.writeFile(indexPath, data, "utf-8");
+  }
+  async updateIndex(userId, definition) {
+    const index = await this.loadIndex(userId);
+    const entry = this.definitionToIndexEntry(definition);
+    const existingIdx = index.routines.findIndex((e) => e.id === definition.id);
+    if (existingIdx >= 0) {
+      index.routines[existingIdx] = entry;
+    } else {
+      index.routines.push(entry);
+    }
+    await this.saveIndex(userId, index);
+  }
+  async removeFromIndex(userId, id) {
+    const index = await this.loadIndex(userId);
+    index.routines = index.routines.filter((e) => e.id !== id);
+    await this.saveIndex(userId, index);
+  }
+  definitionToIndexEntry(definition) {
+    return {
+      id: definition.id,
+      name: definition.name,
+      description: definition.description,
+      tags: definition.tags,
+      author: definition.author,
+      updatedAt: definition.updatedAt
+    };
+  }
+  /**
+   * Rebuild index by scanning directory for .json files (excluding _index.json).
+   * Returns empty index if directory doesn't exist.
+   */
+  async rebuildIndex(userId) {
+    const directory = this.getUserDirectory(userId);
+    const index = {
+      version: 1,
+      routines: [],
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    let files;
+    try {
+      files = await fs19.promises.readdir(directory);
+    } catch {
+      return index;
+    }
+    for (const file of files) {
+      if (!file.endsWith(".json") || file === "_index.json") continue;
+      try {
+        const data = await fs19.promises.readFile(path2.join(directory, file), "utf-8");
+        const stored = JSON.parse(data);
+        if (stored.definition) {
+          index.routines.push(this.definitionToIndexEntry(stored.definition));
+        }
+      } catch {
+      }
+    }
+    if (index.routines.length > 0) {
+      await this.saveIndex(userId, index);
+    }
+    return index;
+  }
+};
+function createFileRoutineDefinitionStorage(config) {
+  return new FileRoutineDefinitionStorage(config);
+}
 
 // src/domain/entities/CustomToolDefinition.ts
 var CUSTOM_TOOL_DEFINITION_VERSION = 1;
@@ -38935,8 +39963,8 @@ var FileStorage = class {
   }
   async ensureDirectory() {
     try {
-      await fs17__namespace.mkdir(this.directory, { recursive: true });
-      await fs17__namespace.chmod(this.directory, 448);
+      await fs18__namespace.mkdir(this.directory, { recursive: true });
+      await fs18__namespace.chmod(this.directory, 448);
     } catch (error) {
     }
   }
@@ -38952,13 +39980,13 @@ var FileStorage = class {
     const filePath = this.getFilePath(key);
     const plaintext = JSON.stringify(token);
     const encrypted = encrypt(plaintext, this.encryptionKey);
-    await fs17__namespace.writeFile(filePath, encrypted, "utf8");
-    await fs17__namespace.chmod(filePath, 384);
+    await fs18__namespace.writeFile(filePath, encrypted, "utf8");
+    await fs18__namespace.chmod(filePath, 384);
   }
   async getToken(key) {
     const filePath = this.getFilePath(key);
     try {
-      const encrypted = await fs17__namespace.readFile(filePath, "utf8");
+      const encrypted = await fs18__namespace.readFile(filePath, "utf8");
       const decrypted = decrypt(encrypted, this.encryptionKey);
       return JSON.parse(decrypted);
     } catch (error) {
@@ -38967,7 +39995,7 @@ var FileStorage = class {
       }
       console.error("Failed to read/decrypt token file:", error);
       try {
-        await fs17__namespace.unlink(filePath);
+        await fs18__namespace.unlink(filePath);
       } catch {
       }
       return null;
@@ -38976,7 +40004,7 @@ var FileStorage = class {
   async deleteToken(key) {
     const filePath = this.getFilePath(key);
     try {
-      await fs17__namespace.unlink(filePath);
+      await fs18__namespace.unlink(filePath);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -38986,7 +40014,7 @@ var FileStorage = class {
   async hasToken(key) {
     const filePath = this.getFilePath(key);
     try {
-      await fs17__namespace.access(filePath);
+      await fs18__namespace.access(filePath);
       return true;
     } catch {
       return false;
@@ -38997,7 +40025,7 @@ var FileStorage = class {
    */
   async listTokens() {
     try {
-      const files = await fs17__namespace.readdir(this.directory);
+      const files = await fs18__namespace.readdir(this.directory);
       return files.filter((f) => f.endsWith(".token")).map((f) => f.replace(".token", ""));
     } catch {
       return [];
@@ -39008,10 +40036,10 @@ var FileStorage = class {
    */
   async clearAll() {
     try {
-      const files = await fs17__namespace.readdir(this.directory);
+      const files = await fs18__namespace.readdir(this.directory);
       const tokenFiles = files.filter((f) => f.endsWith(".token"));
       await Promise.all(
-        tokenFiles.map((f) => fs17__namespace.unlink(path2__namespace.join(this.directory, f)).catch(() => {
+        tokenFiles.map((f) => fs18__namespace.unlink(path2__namespace.join(this.directory, f)).catch(() => {
         }))
       );
     } catch {
@@ -39459,14 +40487,14 @@ var FileConnectorStorage = class {
     await this.ensureDirectory();
     const filePath = this.getFilePath(name);
     const json = JSON.stringify(stored, null, 2);
-    await fs17__namespace.writeFile(filePath, json, "utf8");
-    await fs17__namespace.chmod(filePath, 384);
+    await fs18__namespace.writeFile(filePath, json, "utf8");
+    await fs18__namespace.chmod(filePath, 384);
     await this.updateIndex(name, "add");
   }
   async get(name) {
     const filePath = this.getFilePath(name);
     try {
-      const json = await fs17__namespace.readFile(filePath, "utf8");
+      const json = await fs18__namespace.readFile(filePath, "utf8");
       return JSON.parse(json);
     } catch (error) {
       const err = error;
@@ -39479,7 +40507,7 @@ var FileConnectorStorage = class {
   async delete(name) {
     const filePath = this.getFilePath(name);
     try {
-      await fs17__namespace.unlink(filePath);
+      await fs18__namespace.unlink(filePath);
       await this.updateIndex(name, "remove");
       return true;
     } catch (error) {
@@ -39493,7 +40521,7 @@ var FileConnectorStorage = class {
   async has(name) {
     const filePath = this.getFilePath(name);
     try {
-      await fs17__namespace.access(filePath);
+      await fs18__namespace.access(filePath);
       return true;
     } catch {
       return false;
@@ -39519,13 +40547,13 @@ var FileConnectorStorage = class {
    */
   async clear() {
     try {
-      const files = await fs17__namespace.readdir(this.directory);
+      const files = await fs18__namespace.readdir(this.directory);
       const connectorFiles = files.filter(
         (f) => f.endsWith(".connector.json") || f === "_index.json"
       );
       await Promise.all(
         connectorFiles.map(
-          (f) => fs17__namespace.unlink(path2__namespace.join(this.directory, f)).catch(() => {
+          (f) => fs18__namespace.unlink(path2__namespace.join(this.directory, f)).catch(() => {
           })
         )
       );
@@ -39552,8 +40580,8 @@ var FileConnectorStorage = class {
   async ensureDirectory() {
     if (this.initialized) return;
     try {
-      await fs17__namespace.mkdir(this.directory, { recursive: true });
-      await fs17__namespace.chmod(this.directory, 448);
+      await fs18__namespace.mkdir(this.directory, { recursive: true });
+      await fs18__namespace.chmod(this.directory, 448);
       this.initialized = true;
     } catch {
       this.initialized = true;
@@ -39564,7 +40592,7 @@ var FileConnectorStorage = class {
    */
   async loadIndex() {
     try {
-      const json = await fs17__namespace.readFile(this.indexPath, "utf8");
+      const json = await fs18__namespace.readFile(this.indexPath, "utf8");
       return JSON.parse(json);
     } catch {
       return { connectors: {} };
@@ -39582,8 +40610,8 @@ var FileConnectorStorage = class {
       delete index.connectors[hash];
     }
     const json = JSON.stringify(index, null, 2);
-    await fs17__namespace.writeFile(this.indexPath, json, "utf8");
-    await fs17__namespace.chmod(this.indexPath, 384);
+    await fs18__namespace.writeFile(this.indexPath, json, "utf8");
+    await fs18__namespace.chmod(this.indexPath, 384);
   }
 };
 
@@ -42038,8 +43066,8 @@ function createMessageWithImages(text, imageUrls, role = "user" /* USER */) {
 var execAsync = util.promisify(child_process.exec);
 function cleanupTempFile(filePath) {
   try {
-    if (fs18__namespace.existsSync(filePath)) {
-      fs18__namespace.unlinkSync(filePath);
+    if (fs19__namespace.existsSync(filePath)) {
+      fs19__namespace.unlinkSync(filePath);
     }
   } catch {
   }
@@ -42090,7 +43118,7 @@ async function readClipboardImageMac() {
         end try
       `;
       const { stdout } = await execAsync(`osascript -e '${script}'`);
-      if (stdout.includes("success") || fs18__namespace.existsSync(tempFile)) {
+      if (stdout.includes("success") || fs19__namespace.existsSync(tempFile)) {
         return await convertFileToDataUri(tempFile);
       }
       return {
@@ -42107,14 +43135,14 @@ async function readClipboardImageLinux() {
   try {
     try {
       await execAsync(`xclip -selection clipboard -t image/png -o > "${tempFile}"`);
-      if (fs18__namespace.existsSync(tempFile) && fs18__namespace.statSync(tempFile).size > 0) {
+      if (fs19__namespace.existsSync(tempFile) && fs19__namespace.statSync(tempFile).size > 0) {
         return await convertFileToDataUri(tempFile);
       }
     } catch {
     }
     try {
       await execAsync(`wl-paste -t image/png > "${tempFile}"`);
-      if (fs18__namespace.existsSync(tempFile) && fs18__namespace.statSync(tempFile).size > 0) {
+      if (fs19__namespace.existsSync(tempFile) && fs19__namespace.statSync(tempFile).size > 0) {
         return await convertFileToDataUri(tempFile);
       }
     } catch {
@@ -42141,7 +43169,7 @@ async function readClipboardImageWindows() {
       }
     `;
     await execAsync(`powershell -Command "${psScript}"`);
-    if (fs18__namespace.existsSync(tempFile) && fs18__namespace.statSync(tempFile).size > 0) {
+    if (fs19__namespace.existsSync(tempFile) && fs19__namespace.statSync(tempFile).size > 0) {
       return await convertFileToDataUri(tempFile);
     }
     return {
@@ -42154,7 +43182,7 @@ async function readClipboardImageWindows() {
 }
 async function convertFileToDataUri(filePath) {
   try {
-    const imageBuffer = fs18__namespace.readFileSync(filePath);
+    const imageBuffer = fs19__namespace.readFileSync(filePath);
     const base64Image = imageBuffer.toString("base64");
     const magic = imageBuffer.slice(0, 4).toString("hex");
     let mimeType = "image/png";
@@ -42213,186 +43241,6 @@ async function hasClipboardImage() {
   }
 }
 
-// src/utils/jsonExtractor.ts
-function extractJSON(text) {
-  if (!text || typeof text !== "string") {
-    return {
-      success: false,
-      error: "Input is empty or not a string"
-    };
-  }
-  const trimmedText = text.trim();
-  const codeBlockResult = extractFromCodeBlock(trimmedText);
-  if (codeBlockResult.success) {
-    return codeBlockResult;
-  }
-  const inlineResult = extractInlineJSON(trimmedText);
-  if (inlineResult.success) {
-    return inlineResult;
-  }
-  try {
-    const data = JSON.parse(trimmedText);
-    return {
-      success: true,
-      data,
-      rawJson: trimmedText,
-      method: "raw"
-    };
-  } catch (e) {
-    return {
-      success: false,
-      error: `Could not extract JSON from text: ${e instanceof Error ? e.message : String(e)}`
-    };
-  }
-}
-function extractFromCodeBlock(text) {
-  const codeBlockRegex = /```(?:json)?\s*([\s\S]*?)```/g;
-  let match;
-  while ((match = codeBlockRegex.exec(text)) !== null) {
-    const content = match[1];
-    if (content) {
-      const trimmed = content.trim();
-      try {
-        const data = JSON.parse(trimmed);
-        return {
-          success: true,
-          data,
-          rawJson: trimmed,
-          method: "code_block"
-        };
-      } catch {
-        continue;
-      }
-    }
-  }
-  return { success: false };
-}
-function extractInlineJSON(text) {
-  const objectMatch = findJSONObject(text);
-  if (objectMatch) {
-    try {
-      const data = JSON.parse(objectMatch);
-      return {
-        success: true,
-        data,
-        rawJson: objectMatch,
-        method: "inline"
-      };
-    } catch {
-    }
-  }
-  const arrayMatch = findJSONArray(text);
-  if (arrayMatch) {
-    try {
-      const data = JSON.parse(arrayMatch);
-      return {
-        success: true,
-        data,
-        rawJson: arrayMatch,
-        method: "inline"
-      };
-    } catch {
-    }
-  }
-  return { success: false };
-}
-function findJSONObject(text) {
-  const startIndex = text.indexOf("{");
-  if (startIndex === -1) return null;
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let i = startIndex; i < text.length; i++) {
-    const char = text[i];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (char === "\\" && inString) {
-      escaped = true;
-      continue;
-    }
-    if (char === '"') {
-      inString = !inString;
-      continue;
-    }
-    if (inString) continue;
-    if (char === "{") {
-      depth++;
-    } else if (char === "}") {
-      depth--;
-      if (depth === 0) {
-        return text.slice(startIndex, i + 1);
-      }
-    }
-  }
-  return null;
-}
-function findJSONArray(text) {
-  const startIndex = text.indexOf("[");
-  if (startIndex === -1) return null;
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let i = startIndex; i < text.length; i++) {
-    const char = text[i];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (char === "\\" && inString) {
-      escaped = true;
-      continue;
-    }
-    if (char === '"') {
-      inString = !inString;
-      continue;
-    }
-    if (inString) continue;
-    if (char === "[") {
-      depth++;
-    } else if (char === "]") {
-      depth--;
-      if (depth === 0) {
-        return text.slice(startIndex, i + 1);
-      }
-    }
-  }
-  return null;
-}
-function extractJSONField(text, field, defaultValue) {
-  const result = extractJSON(text);
-  if (result.success && result.data && field in result.data) {
-    return result.data[field];
-  }
-  return defaultValue;
-}
-function extractNumber(text, patterns = [
-  /(\d{1,3})%?\s*(?:complete|score|percent)/i,
-  /(?:score|completion|rating)[:\s]+(\d{1,3})/i,
-  /(\d{1,3})\s*(?:out of|\/)\s*100/i
-], defaultValue = 0) {
-  const jsonResult = extractJSON(text);
-  if (jsonResult.success && jsonResult.data) {
-    const scoreFields = ["score", "completionScore", "completion_score", "rating", "percent", "value"];
-    for (const field of scoreFields) {
-      if (field in jsonResult.data && typeof jsonResult.data[field] === "number") {
-        return jsonResult.data[field];
-      }
-    }
-  }
-  for (const pattern of patterns) {
-    const match = text.match(pattern);
-    if (match && match[1]) {
-      const num = parseInt(match[1], 10);
-      if (!isNaN(num)) {
-        return num;
-      }
-    }
-  }
-  return defaultValue;
-}
-
 // src/tools/index.ts
 var tools_exports = {};
 __export(tools_exports, {
@@ -42428,19 +43276,25 @@ __export(tools_exports, {
   createDesktopScreenshotTool: () => createDesktopScreenshotTool,
   createDesktopWindowFocusTool: () => createDesktopWindowFocusTool,
   createDesktopWindowListTool: () => createDesktopWindowListTool,
+  createDraftEmailTool: () => createDraftEmailTool,
   createEditFileTool: () => createEditFileTool,
+  createEditMeetingTool: () => createEditMeetingTool,
   createExecuteJavaScriptTool: () => createExecuteJavaScriptTool,
+  createFindMeetingSlotsTool: () => createFindMeetingSlotsTool,
+  createGetMeetingTranscriptTool: () => createGetMeetingTranscriptTool,
   createGetPRTool: () => createGetPRTool,
   createGitHubReadFileTool: () => createGitHubReadFileTool,
   createGlobTool: () => createGlobTool,
   createGrepTool: () => createGrepTool,
   createImageGenerationTool: () => createImageGenerationTool,
   createListDirectoryTool: () => createListDirectoryTool,
+  createMeetingTool: () => createMeetingTool,
   createPRCommentsTool: () => createPRCommentsTool,
   createPRFilesTool: () => createPRFilesTool,
   createReadFileTool: () => createReadFileTool,
   createSearchCodeTool: () => createSearchCodeTool,
   createSearchFilesTool: () => createSearchFilesTool,
+  createSendEmailTool: () => createSendEmailTool,
   createSpeechToTextTool: () => createSpeechToTextTool,
   createTextToSpeechTool: () => createTextToSpeechTool,
   createVideoTools: () => createVideoTools,
@@ -42470,6 +43324,8 @@ __export(tools_exports, {
   executeInVM: () => executeInVM,
   executeJavaScript: () => executeJavaScript,
   expandTilde: () => expandTilde,
+  formatAttendees: () => formatAttendees,
+  formatRecipients: () => formatRecipients,
   getAllBuiltInTools: () => getAllBuiltInTools,
   getBackgroundOutput: () => getBackgroundOutput,
   getDesktopDriver: () => getDesktopDriver,
@@ -42480,19 +43336,24 @@ __export(tools_exports, {
   getToolRegistry: () => getToolRegistry,
   getToolsByCategory: () => getToolsByCategory,
   getToolsRequiringConnector: () => getToolsRequiringConnector,
+  getUserPathPrefix: () => getUserPathPrefix,
   glob: () => glob,
   grep: () => grep,
   hydrateCustomTool: () => hydrateCustomTool,
   isBlockedCommand: () => isBlockedCommand,
   isExcludedExtension: () => isExcludedExtension,
+  isTeamsMeetingUrl: () => isTeamsMeetingUrl,
   jsonManipulator: () => jsonManipulator,
   killBackgroundProcess: () => killBackgroundProcess,
   listDirectory: () => listDirectory,
   mergeTextPieces: () => mergeTextPieces,
+  microsoftFetch: () => microsoftFetch,
+  normalizeEmails: () => normalizeEmails,
   parseKeyCombo: () => parseKeyCombo,
   parseRepository: () => parseRepository,
   readFile: () => readFile5,
   resetDefaultDriver: () => resetDefaultDriver,
+  resolveMeetingId: () => resolveMeetingId,
   resolveRepository: () => resolveRepository,
   setMediaOutputHandler: () => setMediaOutputHandler,
   setMediaStorage: () => setMediaStorage,
@@ -42703,7 +43564,7 @@ EXAMPLES:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      if (!fs18.existsSync(resolvedPath)) {
+      if (!fs19.existsSync(resolvedPath)) {
         return {
           success: false,
           error: `File not found: ${file_path}`,
@@ -42711,7 +43572,7 @@ EXAMPLES:
         };
       }
       try {
-        const stats = await fs17.stat(resolvedPath);
+        const stats = await fs18.stat(resolvedPath);
         if (!stats.isFile()) {
           return {
             success: false,
@@ -42753,7 +43614,7 @@ EXAMPLES:
           } catch {
           }
         }
-        const content = await fs17.readFile(resolvedPath, "utf-8");
+        const content = await fs18.readFile(resolvedPath, "utf-8");
         const allLines = content.split("\n");
         const totalLines = allLines.length;
         const startIndex = Math.max(0, offset - 1);
@@ -42858,13 +43719,13 @@ EXAMPLES:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      const fileExists = fs18.existsSync(resolvedPath);
+      const fileExists = fs19.existsSync(resolvedPath);
       try {
         const parentDir = path2.dirname(resolvedPath);
-        if (!fs18.existsSync(parentDir)) {
-          await fs17.mkdir(parentDir, { recursive: true });
+        if (!fs19.existsSync(parentDir)) {
+          await fs18.mkdir(parentDir, { recursive: true });
         }
-        await fs17.writeFile(resolvedPath, content, "utf-8");
+        await fs18.writeFile(resolvedPath, content, "utf-8");
         return {
           success: true,
           path: file_path,
@@ -42967,7 +43828,7 @@ EXAMPLES:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      if (!fs18.existsSync(resolvedPath)) {
+      if (!fs19.existsSync(resolvedPath)) {
         return {
           success: false,
           error: `File not found: ${file_path}`,
@@ -42975,7 +43836,7 @@ EXAMPLES:
         };
       }
       try {
-        const content = await fs17.readFile(resolvedPath, "utf-8");
+        const content = await fs18.readFile(resolvedPath, "utf-8");
         let occurrences = 0;
         let searchIndex = 0;
         while (true) {
@@ -43014,7 +43875,7 @@ EXAMPLES:
         } else {
           newContent = content.replace(old_string, new_string);
         }
-        await fs17.writeFile(resolvedPath, newContent, "utf-8");
+        await fs18.writeFile(resolvedPath, newContent, "utf-8");
         const diffPreview = generateDiffPreview(old_string, new_string);
         return {
           success: true,
@@ -43070,7 +43931,7 @@ async function findFiles(dir, pattern, baseDir, config, results = [], depth = 0)
     return results;
   }
   try {
-    const entries = await fs17.readdir(dir, { withFileTypes: true });
+    const entries = await fs18.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (results.length >= config.maxResults) break;
       const fullPath = path2.join(dir, entry.name);
@@ -43084,7 +43945,7 @@ async function findFiles(dir, pattern, baseDir, config, results = [], depth = 0)
       } else if (entry.isFile()) {
         if (matchGlobPattern(pattern, relativePath)) {
           try {
-            const stats = await fs17.stat(fullPath);
+            const stats = await fs18.stat(fullPath);
             results.push({
               path: relativePath,
               mtime: stats.mtimeMs
@@ -43166,7 +44027,7 @@ WHEN TO USE:
         };
       }
       const resolvedDir = validation.resolvedPath;
-      if (!fs18.existsSync(resolvedDir)) {
+      if (!fs19.existsSync(resolvedDir)) {
         return {
           success: false,
           error: `Directory not found: ${searchDir}`
@@ -43221,7 +44082,7 @@ async function findFilesToSearch(dir, baseDir, config, globPattern, fileType, fi
     return files;
   }
   try {
-    const entries = await fs17.readdir(dir, { withFileTypes: true });
+    const entries = await fs18.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path2.join(dir, entry.name);
       if (entry.isDirectory()) {
@@ -43254,7 +44115,7 @@ async function findFilesToSearch(dir, baseDir, config, globPattern, fileType, fi
 async function searchFile(filePath, regex, contextBefore, contextAfter) {
   const matches = [];
   try {
-    const content = await fs17.readFile(filePath, "utf-8");
+    const content = await fs18.readFile(filePath, "utf-8");
     const lines = content.split("\n");
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i] ?? "";
@@ -43395,7 +44256,7 @@ WHEN TO USE:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      if (!fs18.existsSync(resolvedPath)) {
+      if (!fs19.existsSync(resolvedPath)) {
         return {
           success: false,
           error: `Path not found: ${searchPath}`
@@ -43411,7 +44272,7 @@ WHEN TO USE:
         };
       }
       try {
-        const stats = await fs17.stat(resolvedPath);
+        const stats = await fs18.stat(resolvedPath);
         let filesToSearch;
         if (stats.isFile()) {
           filesToSearch = [resolvedPath];
@@ -43499,7 +44360,7 @@ async function listDir(dir, baseDir, config, recursive, filter, maxDepth = 3, cu
     return entries;
   }
   try {
-    const dirEntries = await fs17.readdir(dir, { withFileTypes: true });
+    const dirEntries = await fs18.readdir(dir, { withFileTypes: true });
     for (const entry of dirEntries) {
       if (entries.length >= config.maxResults) break;
       const fullPath = path2.join(dir, entry.name);
@@ -43517,7 +44378,7 @@ async function listDir(dir, baseDir, config, recursive, filter, maxDepth = 3, cu
       }
       if (filter === "directories" && !isDir) continue;
       try {
-        const stats = await fs17.stat(fullPath);
+        const stats = await fs18.stat(fullPath);
         const dirEntry = {
           name: entry.name,
           path: relativePath,
@@ -43613,14 +44474,14 @@ EXAMPLES:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      if (!fs18.existsSync(resolvedPath)) {
+      if (!fs19.existsSync(resolvedPath)) {
         return {
           success: false,
           error: `Directory not found: ${path6}`
         };
       }
       try {
-        const stats = await fs17.stat(resolvedPath);
+        const stats = await fs18.stat(resolvedPath);
         if (!stats.isDirectory()) {
           return {
             success: false,
@@ -46574,6 +47435,840 @@ function registerGitHubTools() {
 // src/tools/github/index.ts
 registerGitHubTools();
 
+// src/tools/microsoft/types.ts
+function getUserPathPrefix(connector, targetUser) {
+  const auth2 = connector.config.auth;
+  if (auth2.type === "oauth" && auth2.flow === "client_credentials") {
+    if (!targetUser) {
+      throw new Error(
+        'targetUser is required when using client_credentials (application) flow. Provide a user ID or UPN (e.g., "user@domain.com").'
+      );
+    }
+    return `/users/${targetUser}`;
+  }
+  return "/me";
+}
+var MicrosoftAPIError = class extends Error {
+  constructor(status, statusText, body) {
+    const msg = typeof body === "object" && body !== null && "error" in body ? body.error?.message ?? statusText : statusText;
+    super(`Microsoft Graph API error ${status}: ${msg}`);
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.name = "MicrosoftAPIError";
+  }
+};
+async function microsoftFetch(connector, endpoint, options) {
+  let url2 = endpoint;
+  if (options?.queryParams && Object.keys(options.queryParams).length > 0) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(options.queryParams)) {
+      params.append(key, String(value));
+    }
+    url2 += (url2.includes("?") ? "&" : "?") + params.toString();
+  }
+  const headers = {
+    "Accept": options?.accept ?? "application/json"
+  };
+  if (options?.body) {
+    headers["Content-Type"] = "application/json";
+  }
+  const response = await connector.fetch(
+    url2,
+    {
+      method: options?.method ?? "GET",
+      headers,
+      body: options?.body ? JSON.stringify(options.body) : void 0
+    },
+    options?.userId
+  );
+  const text = await response.text();
+  if (!response.ok) {
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      data = text;
+    }
+    throw new MicrosoftAPIError(response.status, response.statusText, data);
+  }
+  if (!text || text.trim().length === 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function normalizeEmails(input) {
+  return input.map((item) => {
+    if (typeof item === "string") return item;
+    if (typeof item === "object" && item !== null) {
+      const obj = item;
+      if (obj.emailAddress && typeof obj.emailAddress === "object") {
+        const ea = obj.emailAddress;
+        if (typeof ea.address === "string") return ea.address;
+      }
+      if (typeof obj.address === "string") return obj.address;
+      if (typeof obj.email === "string") return obj.email;
+    }
+    return String(item);
+  });
+}
+function formatRecipients(emails) {
+  return normalizeEmails(emails).map((address) => ({ emailAddress: { address } }));
+}
+function formatAttendees(emails) {
+  return normalizeEmails(emails).map((address) => ({
+    emailAddress: { address },
+    type: "required"
+  }));
+}
+function isTeamsMeetingUrl(input) {
+  try {
+    const url2 = new URL(input.trim());
+    return (url2.hostname === "teams.microsoft.com" || url2.hostname === "teams.live.com") && url2.pathname.includes("meetup-join");
+  } catch {
+    return false;
+  }
+}
+async function resolveMeetingId(connector, input, prefix, effectiveUserId) {
+  if (!input || input.trim().length === 0) {
+    throw new Error("Meeting ID cannot be empty");
+  }
+  const trimmed = input.trim();
+  if (!isTeamsMeetingUrl(trimmed)) {
+    return { meetingId: trimmed };
+  }
+  const meetings = await microsoftFetch(
+    connector,
+    `${prefix}/onlineMeetings`,
+    {
+      userId: effectiveUserId,
+      queryParams: { "$filter": `JoinWebUrl eq '${trimmed}'` }
+    }
+  );
+  if (!meetings.value || meetings.value.length === 0) {
+    throw new Error(
+      `Could not find an online meeting matching the provided Teams URL. Make sure the URL is correct and you have access to this meeting.`
+    );
+  }
+  return {
+    meetingId: meetings.value[0].id,
+    subject: meetings.value[0].subject
+  };
+}
+
+// src/tools/microsoft/createDraftEmail.ts
+function createDraftEmailTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "create_draft_email",
+        description: `Create a draft email or draft reply in the user's Outlook mailbox via Microsoft Graph. The draft is saved but NOT sent \u2014 use send_email to send immediately instead.
+
+PARAMETER FORMATS:
+- to/cc: plain string array of email addresses. Example: ["alice@contoso.com", "bob@contoso.com"]. Do NOT use objects.
+- subject: plain string. Example: "Project update" or "Re: Project update" for replies.
+- body: HTML string. Example: "<p>Hi Alice,</p><p>Here is the update.</p>". Use <p>, <br>, <b>, <ul> tags for formatting.
+- replyToMessageId: Graph message ID string (starts with "AAMk..."). Only set when replying to an existing email.
+
+EXAMPLES:
+- New draft: { "to": ["alice@contoso.com"], "subject": "Project update", "body": "<p>Hi Alice,</p><p>Here is the update.</p>" }
+- Reply draft: { "to": ["alice@contoso.com"], "subject": "Re: Project update", "body": "<p>Thanks!</p>", "replyToMessageId": "AAMkADI1..." }
+- With CC: { "to": ["alice@contoso.com"], "subject": "Notes", "body": "<p>See attached.</p>", "cc": ["bob@contoso.com"] }`,
+        parameters: {
+          type: "object",
+          properties: {
+            to: {
+              type: "array",
+              items: { type: "string" },
+              description: 'Recipient email addresses as plain strings. Example: ["alice@contoso.com", "bob@contoso.com"]'
+            },
+            subject: {
+              type: "string",
+              description: 'Email subject as plain string. Example: "Project update" or "Re: Original subject" for replies.'
+            },
+            body: {
+              type: "string",
+              description: 'Email body as an HTML string. Example: "<p>Hello!</p><p>See you tomorrow.</p>"'
+            },
+            cc: {
+              type: "array",
+              items: { type: "string" },
+              description: 'CC email addresses as plain strings. Example: ["bob@contoso.com"]. Optional.'
+            },
+            replyToMessageId: {
+              type: "string",
+              description: 'Graph message ID of the email to reply to. Example: "AAMkADI1M2I3YzgtODg...". When set, creates a threaded reply draft.'
+            },
+            targetUser: {
+              type: "string",
+              description: 'User ID or email (UPN) for app-only auth. Example: "alice@contoso.com". Ignored in delegated auth.'
+            }
+          },
+          required: ["to", "subject", "body"]
+        }
+      }
+    },
+    describeCall: (args) => {
+      const action = args.replyToMessageId ? "Reply draft" : "Draft";
+      return `${action} to ${args.to.join(", ")}: ${args.subject}`;
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "medium",
+      approvalMessage: `Create a draft email via ${connector.displayName}`
+    },
+    execute: async (args, context) => {
+      const effectiveUserId = context?.userId ?? userId;
+      try {
+        const prefix = getUserPathPrefix(connector, args.targetUser);
+        if (args.replyToMessageId) {
+          const replyDraft = await microsoftFetch(
+            connector,
+            `${prefix}/messages/${args.replyToMessageId}/createReply`,
+            { method: "POST", userId: effectiveUserId, body: {} }
+          );
+          const updated = await microsoftFetch(
+            connector,
+            `${prefix}/messages/${replyDraft.id}`,
+            {
+              method: "PATCH",
+              userId: effectiveUserId,
+              body: {
+                subject: args.subject,
+                body: { contentType: "HTML", content: args.body },
+                toRecipients: formatRecipients(args.to),
+                ...args.cc && { ccRecipients: formatRecipients(args.cc) }
+              }
+            }
+          );
+          return {
+            success: true,
+            draftId: updated.id,
+            webLink: updated.webLink
+          };
+        }
+        const draft = await microsoftFetch(
+          connector,
+          `${prefix}/messages`,
+          {
+            method: "POST",
+            userId: effectiveUserId,
+            body: {
+              isDraft: true,
+              subject: args.subject,
+              body: { contentType: "HTML", content: args.body },
+              toRecipients: formatRecipients(args.to),
+              ...args.cc && { ccRecipients: formatRecipients(args.cc) }
+            }
+          }
+        );
+        return {
+          success: true,
+          draftId: draft.id,
+          webLink: draft.webLink
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to create draft email: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+
+// src/tools/microsoft/sendEmail.ts
+function createSendEmailTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "send_email",
+        description: `Send an email immediately or reply to an existing message via Microsoft Graph (Outlook). The email is sent right away \u2014 use create_draft_email to save a draft instead.
+
+PARAMETER FORMATS:
+- to/cc: plain string array of email addresses. Example: ["alice@contoso.com", "bob@contoso.com"]. Do NOT use objects.
+- subject: plain string. Example: "Meeting tomorrow" or "Re: Meeting tomorrow" for replies.
+- body: HTML string. Example: "<p>Hi Alice,</p><p>Can we meet at 2pm?</p>". Use <p>, <br>, <b>, <ul> tags.
+- replyToMessageId: Graph message ID string (starts with "AAMk..."). Only set when replying to an existing email.
+
+EXAMPLES:
+- Send email: { "to": ["alice@contoso.com"], "subject": "Meeting tomorrow", "body": "<p>Can we meet at 2pm?</p>" }
+- Reply: { "to": ["alice@contoso.com"], "subject": "Re: Meeting", "body": "<p>Confirmed!</p>", "replyToMessageId": "AAMkADI1..." }
+- With CC: { "to": ["alice@contoso.com"], "subject": "Update", "body": "<p>FYI</p>", "cc": ["bob@contoso.com"] }`,
+        parameters: {
+          type: "object",
+          properties: {
+            to: {
+              type: "array",
+              items: { type: "string" },
+              description: 'Recipient email addresses as plain strings. Example: ["alice@contoso.com", "bob@contoso.com"]'
+            },
+            subject: {
+              type: "string",
+              description: 'Email subject as plain string. Example: "Meeting tomorrow" or "Re: Original subject" for replies.'
+            },
+            body: {
+              type: "string",
+              description: 'Email body as an HTML string. Example: "<p>Hi!</p><p>Can we meet at 2pm?</p>"'
+            },
+            cc: {
+              type: "array",
+              items: { type: "string" },
+              description: 'CC email addresses as plain strings. Example: ["bob@contoso.com"]. Optional.'
+            },
+            replyToMessageId: {
+              type: "string",
+              description: 'Graph message ID of the email to reply to. Example: "AAMkADI1M2I3YzgtODg...". When set, sends a threaded reply.'
+            },
+            targetUser: {
+              type: "string",
+              description: 'User ID or email (UPN) for app-only auth. Example: "alice@contoso.com". Ignored in delegated auth.'
+            }
+          },
+          required: ["to", "subject", "body"]
+        }
+      }
+    },
+    describeCall: (args) => {
+      const action = args.replyToMessageId ? "Reply" : "Send";
+      return `${action} to ${args.to.join(", ")}: ${args.subject}`;
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "medium",
+      approvalMessage: `Send an email via ${connector.displayName}`
+    },
+    execute: async (args, context) => {
+      const effectiveUserId = context?.userId ?? userId;
+      try {
+        const prefix = getUserPathPrefix(connector, args.targetUser);
+        if (args.replyToMessageId) {
+          await microsoftFetch(
+            connector,
+            `${prefix}/messages/${args.replyToMessageId}/reply`,
+            {
+              method: "POST",
+              userId: effectiveUserId,
+              body: {
+                message: {
+                  toRecipients: formatRecipients(args.to),
+                  ...args.cc && { ccRecipients: formatRecipients(args.cc) }
+                },
+                comment: args.body
+              }
+            }
+          );
+        } else {
+          await microsoftFetch(
+            connector,
+            `${prefix}/sendMail`,
+            {
+              method: "POST",
+              userId: effectiveUserId,
+              body: {
+                message: {
+                  subject: args.subject,
+                  body: { contentType: "HTML", content: args.body },
+                  toRecipients: formatRecipients(args.to),
+                  ...args.cc && { ccRecipients: formatRecipients(args.cc) }
+                },
+                saveToSentItems: true
+              }
+            }
+          );
+        }
+        return { success: true };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to send email: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+
+// src/tools/microsoft/createMeeting.ts
+function createMeetingTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "create_meeting",
+        description: `Create a calendar event on the user's Outlook calendar via Microsoft Graph, optionally with a Teams online meeting link.
+
+PARAMETER FORMATS:
+- subject: plain string. Example: "Sprint Review"
+- startDateTime/endDateTime: ISO 8601 string WITHOUT timezone suffix (timezone is a separate param). Example: "2025-01-15T09:00:00"
+- attendees: plain string array of email addresses. Example: ["alice@contoso.com", "bob@contoso.com"]. Do NOT use objects.
+- body: HTML string for the invitation body. Example: "<p>Agenda: discuss Q1 goals</p>". Optional.
+- timeZone: IANA timezone string. Example: "America/New_York", "Europe/Zurich". Default: "UTC".
+- isOnlineMeeting: boolean. Set true to auto-generate a Teams meeting link.
+- location: plain string. Example: "Conference Room A". Optional.
+
+EXAMPLES:
+- Simple: { "subject": "Standup", "startDateTime": "2025-01-15T09:00:00", "endDateTime": "2025-01-15T09:30:00", "attendees": ["alice@contoso.com"], "timeZone": "America/New_York" }
+- Teams: { "subject": "Sprint Review", "startDateTime": "2025-01-15T14:00:00", "endDateTime": "2025-01-15T15:00:00", "attendees": ["alice@contoso.com", "bob@contoso.com"], "isOnlineMeeting": true }`,
+        parameters: {
+          type: "object",
+          properties: {
+            subject: {
+              type: "string",
+              description: 'Meeting title as plain string. Example: "Sprint Review"'
+            },
+            startDateTime: {
+              type: "string",
+              description: 'Start date/time as ISO 8601 string without timezone suffix. Example: "2025-01-15T09:00:00"'
+            },
+            endDateTime: {
+              type: "string",
+              description: 'End date/time as ISO 8601 string without timezone suffix. Example: "2025-01-15T09:30:00"'
+            },
+            attendees: {
+              type: "array",
+              items: { type: "string" },
+              description: 'Attendee email addresses as plain strings. Example: ["alice@contoso.com", "bob@contoso.com"]'
+            },
+            body: {
+              type: "string",
+              description: 'Meeting description as HTML string. Example: "<p>Agenda: discuss Q1 goals</p>". Optional.'
+            },
+            isOnlineMeeting: {
+              type: "boolean",
+              description: "Set to true to generate a Teams online meeting link. Default: false."
+            },
+            location: {
+              type: "string",
+              description: 'Physical location as plain string. Example: "Conference Room A". Optional.'
+            },
+            timeZone: {
+              type: "string",
+              description: 'IANA timezone string for start/end times. Example: "America/New_York", "Europe/Zurich". Default: "UTC".'
+            },
+            targetUser: {
+              type: "string",
+              description: 'User ID or email (UPN) for app-only auth. Example: "alice@contoso.com". Ignored in delegated auth.'
+            }
+          },
+          required: ["subject", "startDateTime", "endDateTime", "attendees"]
+        }
+      }
+    },
+    describeCall: (args) => {
+      return `Create meeting: ${args.subject} (${args.attendees.length} attendees)`;
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "medium",
+      approvalMessage: `Create a calendar event via ${connector.displayName}`
+    },
+    execute: async (args, context) => {
+      const effectiveUserId = context?.userId ?? userId;
+      try {
+        const prefix = getUserPathPrefix(connector, args.targetUser);
+        const tz = args.timeZone ?? "UTC";
+        const eventBody = {
+          subject: args.subject,
+          start: { dateTime: args.startDateTime, timeZone: tz },
+          end: { dateTime: args.endDateTime, timeZone: tz },
+          attendees: formatAttendees(args.attendees)
+        };
+        if (args.body) {
+          eventBody.body = { contentType: "HTML", content: args.body };
+        }
+        if (args.isOnlineMeeting) {
+          eventBody.isOnlineMeeting = true;
+          eventBody.onlineMeetingProvider = "teamsForBusiness";
+        }
+        if (args.location) {
+          eventBody.location = { displayName: args.location };
+        }
+        const event = await microsoftFetch(
+          connector,
+          `${prefix}/events`,
+          { method: "POST", userId: effectiveUserId, body: eventBody }
+        );
+        return {
+          success: true,
+          eventId: event.id,
+          webLink: event.webLink,
+          onlineMeetingUrl: event.onlineMeeting?.joinUrl
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to create meeting: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+
+// src/tools/microsoft/editMeeting.ts
+function createEditMeetingTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "edit_meeting",
+        description: `Update an existing Outlook calendar event via Microsoft Graph. Only the fields you provide will be changed \u2014 omitted fields keep their current values.
+
+IMPORTANT: The "attendees" field REPLACES the entire attendee list. Include ALL desired attendees (both new and existing), not just the ones you want to add.
+
+PARAMETER FORMATS:
+- eventId: Graph event ID string (starts with "AAMk..."). Get this from a previous create_meeting result.
+- subject: plain string. Example: "Updated: Sprint Review"
+- startDateTime/endDateTime: ISO 8601 string without timezone suffix. Example: "2025-01-15T10:00:00"
+- attendees: plain string array of email addresses. Example: ["alice@contoso.com", "charlie@contoso.com"]. Do NOT use objects. REPLACES all attendees.
+- body: HTML string. Example: "<p>Updated agenda</p>"
+- timeZone: IANA timezone string. Example: "Europe/Zurich". Default: "UTC".
+- isOnlineMeeting: boolean. true = add Teams link, false = remove it.
+- location: plain string. Example: "Room 201"
+
+EXAMPLES:
+- Reschedule: { "eventId": "AAMkADI1...", "startDateTime": "2025-01-15T10:00:00", "endDateTime": "2025-01-15T10:30:00", "timeZone": "America/New_York" }
+- Change attendees: { "eventId": "AAMkADI1...", "attendees": ["alice@contoso.com", "charlie@contoso.com"] }
+- Add Teams link: { "eventId": "AAMkADI1...", "isOnlineMeeting": true }`,
+        parameters: {
+          type: "object",
+          properties: {
+            eventId: {
+              type: "string",
+              description: 'Calendar event ID string from create_meeting result. Example: "AAMkADI1M2I3YzgtODg..."'
+            },
+            subject: {
+              type: "string",
+              description: 'New meeting title as plain string. Example: "Updated: Sprint Review"'
+            },
+            startDateTime: {
+              type: "string",
+              description: 'New start date/time as ISO 8601 string without timezone suffix. Example: "2025-01-15T10:00:00"'
+            },
+            endDateTime: {
+              type: "string",
+              description: 'New end date/time as ISO 8601 string without timezone suffix. Example: "2025-01-15T10:30:00"'
+            },
+            attendees: {
+              type: "array",
+              items: { type: "string" },
+              description: 'FULL replacement attendee list as plain email strings. Example: ["alice@contoso.com", "charlie@contoso.com"]. Include ALL attendees.'
+            },
+            body: {
+              type: "string",
+              description: 'New meeting description as HTML string. Example: "<p>Updated agenda</p>"'
+            },
+            isOnlineMeeting: {
+              type: "boolean",
+              description: "true to add Teams meeting link, false to remove it."
+            },
+            location: {
+              type: "string",
+              description: 'New location as plain string. Example: "Conference Room A"'
+            },
+            timeZone: {
+              type: "string",
+              description: 'IANA timezone string for start/end times. Example: "Europe/Zurich". Default: "UTC".'
+            },
+            targetUser: {
+              type: "string",
+              description: 'User ID or email (UPN) for app-only auth. Example: "alice@contoso.com". Ignored in delegated auth.'
+            }
+          },
+          required: ["eventId"]
+        }
+      }
+    },
+    describeCall: (args) => {
+      const fields = ["subject", "startDateTime", "endDateTime", "attendees", "body", "location"];
+      const changed = fields.filter((f) => args[f] !== void 0);
+      return `Edit meeting ${args.eventId.slice(0, 12)}... (${changed.join(", ") || "no changes"})`;
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "medium",
+      approvalMessage: `Update a calendar event via ${connector.displayName}`
+    },
+    execute: async (args, context) => {
+      const effectiveUserId = context?.userId ?? userId;
+      try {
+        const prefix = getUserPathPrefix(connector, args.targetUser);
+        const tz = args.timeZone ?? "UTC";
+        const patchBody = {};
+        if (args.subject !== void 0) patchBody.subject = args.subject;
+        if (args.body !== void 0) patchBody.body = { contentType: "HTML", content: args.body };
+        if (args.startDateTime !== void 0) patchBody.start = { dateTime: args.startDateTime, timeZone: tz };
+        if (args.endDateTime !== void 0) patchBody.end = { dateTime: args.endDateTime, timeZone: tz };
+        if (args.attendees !== void 0) {
+          patchBody.attendees = formatAttendees(args.attendees);
+        }
+        if (args.isOnlineMeeting !== void 0) {
+          patchBody.isOnlineMeeting = args.isOnlineMeeting;
+          if (args.isOnlineMeeting) {
+            patchBody.onlineMeetingProvider = "teamsForBusiness";
+          }
+        }
+        if (args.location !== void 0) {
+          patchBody.location = { displayName: args.location };
+        }
+        const event = await microsoftFetch(
+          connector,
+          `${prefix}/events/${args.eventId}`,
+          { method: "PATCH", userId: effectiveUserId, body: patchBody }
+        );
+        return {
+          success: true,
+          eventId: event.id,
+          webLink: event.webLink
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to edit meeting: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+
+// src/tools/microsoft/getMeetingTranscript.ts
+function parseVttToText(vtt) {
+  const lines = vtt.split("\n");
+  const textLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed === "WEBVTT" || trimmed.startsWith("NOTE") || /^\d+$/.test(trimmed) || /^\d{2}:\d{2}/.test(trimmed)) {
+      continue;
+    }
+    textLines.push(trimmed);
+  }
+  return textLines.join("\n");
+}
+function createGetMeetingTranscriptTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "get_meeting_transcript",
+        description: `Retrieve the transcript from a Teams online meeting via Microsoft Graph. Returns plain text with speaker labels (VTT timestamps are stripped).
+
+NOTE: Requires the OnlineMeetingTranscript.Read.All permission. Transcription must have been enabled during the meeting.
+
+USAGE:
+- Provide the Teams online meeting ID (NOT the calendar event ID \u2014 this is different) or a Teams meeting join URL
+- The meetingId can be found in the Teams meeting details or extracted from the join URL
+
+EXAMPLES:
+- By meeting ID: { "meetingId": "MSo1N2Y5ZGFjYy03MWJmLTQ3NDMtYjQxMy01M2EdFGkdRWHJlQ" }
+- By Teams join URL: { "meetingId": "https://teams.microsoft.com/l/meetup-join/19%3ameeting_MjA5YjFi..." }`,
+        parameters: {
+          type: "object",
+          properties: {
+            meetingId: {
+              type: "string",
+              description: 'Teams online meeting ID (e.g. "MSo1N2Y5...") or Teams meeting join URL. This is NOT the calendar event ID.'
+            },
+            targetUser: {
+              type: "string",
+              description: "User ID or email (UPN) to act on behalf of. Only needed for app-only (client_credentials) auth. Ignored in delegated auth."
+            }
+          },
+          required: ["meetingId"]
+        }
+      }
+    },
+    describeCall: (args) => {
+      return `Get transcript for meeting ${args.meetingId.slice(0, 20)}...`;
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "low",
+      approvalMessage: `Get a meeting transcript via ${connector.displayName}`
+    },
+    execute: async (args, context) => {
+      const effectiveUserId = context?.userId ?? userId;
+      try {
+        const prefix = getUserPathPrefix(connector, args.targetUser);
+        const resolved = await resolveMeetingId(connector, args.meetingId, prefix, effectiveUserId);
+        const meetingId = resolved.meetingId;
+        const transcriptList = await microsoftFetch(
+          connector,
+          `${prefix}/onlineMeetings/${meetingId}/transcripts`,
+          { userId: effectiveUserId }
+        );
+        if (!transcriptList.value || transcriptList.value.length === 0) {
+          return {
+            success: false,
+            error: "No transcripts found for this meeting. The meeting may not have had transcription enabled."
+          };
+        }
+        const transcriptId = transcriptList.value[0].id;
+        const contentUrl = `${prefix}/onlineMeetings/${meetingId}/transcripts/${transcriptId}/content`;
+        const response = await connector.fetch(
+          contentUrl + "?$format=text/vtt",
+          { method: "GET", headers: { "Accept": "text/vtt" } },
+          effectiveUserId
+        );
+        if (!response.ok) {
+          const errorText = await response.text();
+          return {
+            success: false,
+            error: `Failed to fetch transcript content: ${response.status} ${errorText}`
+          };
+        }
+        const vttContent = await response.text();
+        const transcript = parseVttToText(vttContent);
+        return {
+          success: true,
+          transcript,
+          meetingSubject: resolved.subject
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to get meeting transcript: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+
+// src/tools/microsoft/findMeetingSlots.ts
+function createFindMeetingSlotsTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "find_meeting_slots",
+        description: `Find available meeting time slots when all attendees are free, via Microsoft Graph. Checks each attendee's Outlook calendar and suggests times when everyone is available.
+
+PARAMETER FORMATS:
+- attendees: plain string array of email addresses. Example: ["alice@contoso.com", "bob@contoso.com"]. Do NOT use objects \u2014 just plain email strings.
+- startDateTime/endDateTime: ISO 8601 string without timezone suffix. Example: "2025-01-15T08:00:00". Can span multiple days.
+- duration: number of minutes as integer. Example: 30 or 60.
+- timeZone: IANA timezone string. Example: "America/New_York", "Europe/Zurich". Default: "UTC".
+- maxResults: integer. Default: 5.
+
+EXAMPLES:
+- Find 30min slot: { "attendees": ["alice@contoso.com", "bob@contoso.com"], "startDateTime": "2025-01-15T08:00:00", "endDateTime": "2025-01-15T18:00:00", "duration": 30, "timeZone": "America/New_York" }
+- Find 1hr slot across days: { "attendees": ["alice@contoso.com"], "startDateTime": "2025-01-15T08:00:00", "endDateTime": "2025-01-17T18:00:00", "duration": 60, "maxResults": 10 }`,
+        parameters: {
+          type: "object",
+          properties: {
+            attendees: {
+              type: "array",
+              items: { type: "string" },
+              description: 'Attendee email addresses as plain strings. Example: ["alice@contoso.com", "bob@contoso.com"]. Do NOT pass objects.'
+            },
+            startDateTime: {
+              type: "string",
+              description: 'Search window start as ISO 8601 string without timezone suffix. Example: "2025-01-15T08:00:00"'
+            },
+            endDateTime: {
+              type: "string",
+              description: 'Search window end as ISO 8601 string without timezone suffix. Example: "2025-01-15T18:00:00". Can span multiple days.'
+            },
+            duration: {
+              type: "number",
+              description: "Meeting duration in minutes as integer. Example: 30 or 60."
+            },
+            timeZone: {
+              type: "string",
+              description: 'IANA timezone string for start/end times. Example: "America/New_York", "Europe/Zurich". Default: "UTC".'
+            },
+            maxResults: {
+              type: "number",
+              description: "Maximum number of time slot suggestions as integer. Default: 5."
+            },
+            targetUser: {
+              type: "string",
+              description: 'User ID or email (UPN) for app-only auth. Example: "alice@contoso.com". Ignored in delegated auth.'
+            }
+          },
+          required: ["attendees", "startDateTime", "endDateTime", "duration"]
+        }
+      }
+    },
+    describeCall: (args) => {
+      return `Find ${args.duration}min slots for ${args.attendees.length} attendees`;
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "low",
+      approvalMessage: `Find meeting time slots via ${connector.displayName}`
+    },
+    execute: async (args, context) => {
+      const effectiveUserId = context?.userId ?? userId;
+      try {
+        const prefix = getUserPathPrefix(connector, args.targetUser);
+        const tz = args.timeZone ?? "UTC";
+        const result = await microsoftFetch(
+          connector,
+          `${prefix}/findMeetingTimes`,
+          {
+            method: "POST",
+            userId: effectiveUserId,
+            body: {
+              attendees: formatAttendees(args.attendees),
+              timeConstraint: {
+                timeslots: [
+                  {
+                    start: { dateTime: args.startDateTime, timeZone: tz },
+                    end: { dateTime: args.endDateTime, timeZone: tz }
+                  }
+                ]
+              },
+              meetingDuration: `PT${args.duration}M`,
+              maxCandidates: args.maxResults ?? 5
+            }
+          }
+        );
+        const slots = (result.meetingTimeSuggestions ?? []).map((s) => ({
+          start: s.meetingTimeSlot.start.dateTime,
+          end: s.meetingTimeSlot.end.dateTime,
+          confidence: String(s.confidence),
+          attendeeAvailability: (s.attendeeAvailability ?? []).map((a) => ({
+            attendee: a.attendee.emailAddress.address,
+            availability: a.availability
+          }))
+        }));
+        return {
+          success: true,
+          slots,
+          emptySuggestionsReason: result.emptySuggestionsReason
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to find meeting slots: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+
+// src/tools/microsoft/register.ts
+function registerMicrosoftTools() {
+  ConnectorTools.registerService("microsoft", (connector, userId) => {
+    return [
+      createDraftEmailTool(connector, userId),
+      createSendEmailTool(connector, userId),
+      createMeetingTool(connector, userId),
+      createEditMeetingTool(connector, userId),
+      createGetMeetingTranscriptTool(connector, userId),
+      createFindMeetingSlotsTool(connector, userId)
+    ];
+  });
+}
+
+// src/tools/microsoft/index.ts
+registerMicrosoftTools();
+
 // src/tools/desktop/types.ts
 var DEFAULT_DESKTOP_CONFIG = {
   driver: null,
@@ -48605,6 +50300,7 @@ exports.FileCustomToolStorage = FileCustomToolStorage;
 exports.FileMediaOutputHandler = FileMediaStorage;
 exports.FileMediaStorage = FileMediaStorage;
 exports.FilePersistentInstructionsStorage = FilePersistentInstructionsStorage;
+exports.FileRoutineDefinitionStorage = FileRoutineDefinitionStorage;
 exports.FileStorage = FileStorage;
 exports.FileUserInfoStorage = FileUserInfoStorage;
 exports.FormatDetector = FormatDetector;
@@ -48732,13 +50428,18 @@ exports.createDesktopMouseScrollTool = createDesktopMouseScrollTool;
 exports.createDesktopScreenshotTool = createDesktopScreenshotTool;
 exports.createDesktopWindowFocusTool = createDesktopWindowFocusTool;
 exports.createDesktopWindowListTool = createDesktopWindowListTool;
+exports.createDraftEmailTool = createDraftEmailTool;
 exports.createEditFileTool = createEditFileTool;
+exports.createEditMeetingTool = createEditMeetingTool;
 exports.createEstimator = createEstimator;
 exports.createExecuteJavaScriptTool = createExecuteJavaScriptTool;
 exports.createFileAgentDefinitionStorage = createFileAgentDefinitionStorage;
 exports.createFileContextStorage = createFileContextStorage;
 exports.createFileCustomToolStorage = createFileCustomToolStorage;
 exports.createFileMediaStorage = createFileMediaStorage;
+exports.createFileRoutineDefinitionStorage = createFileRoutineDefinitionStorage;
+exports.createFindMeetingSlotsTool = createFindMeetingSlotsTool;
+exports.createGetMeetingTranscriptTool = createGetMeetingTranscriptTool;
 exports.createGetPRTool = createGetPRTool;
 exports.createGitHubReadFileTool = createGitHubReadFileTool;
 exports.createGlobTool = createGlobTool;
@@ -48746,6 +50447,7 @@ exports.createGrepTool = createGrepTool;
 exports.createImageGenerationTool = createImageGenerationTool;
 exports.createImageProvider = createImageProvider;
 exports.createListDirectoryTool = createListDirectoryTool;
+exports.createMeetingTool = createMeetingTool;
 exports.createMessageWithImages = createMessageWithImages;
 exports.createMetricsCollector = createMetricsCollector;
 exports.createPRCommentsTool = createPRCommentsTool;
@@ -48753,8 +50455,11 @@ exports.createPRFilesTool = createPRFilesTool;
 exports.createPlan = createPlan;
 exports.createProvider = createProvider;
 exports.createReadFileTool = createReadFileTool;
+exports.createRoutineDefinition = createRoutineDefinition;
+exports.createRoutineExecution = createRoutineExecution;
 exports.createSearchCodeTool = createSearchCodeTool;
 exports.createSearchFilesTool = createSearchFilesTool;
+exports.createSendEmailTool = createSendEmailTool;
 exports.createSpeechToTextTool = createSpeechToTextTool;
 exports.createTask = createTask;
 exports.createTextMessage = createTextMessage;
@@ -48787,12 +50492,15 @@ exports.developerTools = developerTools;
 exports.documentToContent = documentToContent;
 exports.editFile = editFile;
 exports.evaluateCondition = evaluateCondition;
+exports.executeRoutine = executeRoutine;
 exports.extractJSON = extractJSON;
 exports.extractJSONField = extractJSONField;
 exports.extractNumber = extractNumber;
 exports.findConnectorByServiceTypes = findConnectorByServiceTypes;
 exports.forPlan = forPlan;
 exports.forTasks = forTasks;
+exports.formatAttendees = formatAttendees;
+exports.formatRecipients = formatRecipients;
 exports.generateEncryptionKey = generateEncryptionKey;
 exports.generateSimplePlan = generateSimplePlan;
 exports.generateWebAPITool = generateWebAPITool;
@@ -48819,6 +50527,7 @@ exports.getModelInfo = getModelInfo;
 exports.getModelsByVendor = getModelsByVendor;
 exports.getNextExecutableTasks = getNextExecutableTasks;
 exports.getRegisteredScrapeProviders = getRegisteredScrapeProviders;
+exports.getRoutineProgress = getRoutineProgress;
 exports.getSTTModelInfo = getSTTModelInfo;
 exports.getSTTModelsByVendor = getSTTModelsByVendor;
 exports.getSTTModelsWithFeature = getSTTModelsWithFeature;
@@ -48835,6 +50544,7 @@ exports.getToolCategories = getToolCategories;
 exports.getToolRegistry = getToolRegistry;
 exports.getToolsByCategory = getToolsByCategory;
 exports.getToolsRequiringConnector = getToolsRequiringConnector;
+exports.getUserPathPrefix = getUserPathPrefix;
 exports.getVendorAuthTemplate = getVendorAuthTemplate;
 exports.getVendorColor = getVendorColor;
 exports.getVendorDefaultBaseURL = getVendorDefaultBaseURL;
@@ -48863,6 +50573,7 @@ exports.isSimpleScope = isSimpleScope;
 exports.isStreamEvent = isStreamEvent;
 exports.isTaskAwareScope = isTaskAwareScope;
 exports.isTaskBlocked = isTaskBlocked;
+exports.isTeamsMeetingUrl = isTeamsMeetingUrl;
 exports.isTerminalMemoryStatus = isTerminalMemoryStatus;
 exports.isTerminalStatus = isTerminalStatus;
 exports.isToolCallArgumentsDelta = isToolCallArgumentsDelta;
@@ -48878,6 +50589,8 @@ exports.listVendorsByAuthType = listVendorsByAuthType;
 exports.listVendorsByCategory = listVendorsByCategory;
 exports.listVendorsWithLogos = listVendorsWithLogos;
 exports.mergeTextPieces = mergeTextPieces;
+exports.microsoftFetch = microsoftFetch;
+exports.normalizeEmails = normalizeEmails;
 exports.parseKeyCombo = parseKeyCombo;
 exports.parseRepository = parseRepository;
 exports.readClipboardImage = readClipboardImage;
@@ -48888,6 +50601,7 @@ exports.resetDefaultDriver = resetDefaultDriver;
 exports.resolveConnector = resolveConnector;
 exports.resolveDependencies = resolveDependencies;
 exports.resolveMaxContextTokens = resolveMaxContextTokens;
+exports.resolveMeetingId = resolveMeetingId;
 exports.resolveModelCapabilities = resolveModelCapabilities;
 exports.resolveRepository = resolveRepository;
 exports.retryWithBackoff = retryWithBackoff;