@everworker/oneringai 0.3.1 → 0.4.0

package/dist/index.cjs

@@ -2,7 +2,7 @@
 
 var crypto2 = require('crypto');
 var jose = require('jose');
-var fs17 = 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 fs16 = 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 fs17__namespace = /*#__PURE__*/_interopNamespace(fs17);
+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 fs16__namespace = /*#__PURE__*/_interopNamespace(fs16);
+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 = fs17__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 (!fs17__namespace.existsSync(dir)) {
-            fs17__namespace.mkdirSync(dir, { recursive: true });
+          if (!fs19__namespace.existsSync(dir)) {
+            fs19__namespace.mkdirSync(dir, { recursive: true });
           }
-          this.fileStream = fs17__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, fs18, 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, fs18[f]);
+        ajv.addFormat(f, fs20[f]);
     }
     module.exports = exports$1 = formatsPlugin;
     Object.defineProperty(exports$1, "__esModule", { value: true });
@@ -10173,6 +10173,11 @@ var DEFAULT_ALLOWLIST = [
   "instructions_remove",
   "instructions_list",
   "instructions_clear",
+  // User info tools (user-specific data - safe)
+  "user_info_set",
+  "user_info_get",
+  "user_info_remove",
+  "user_info_clear",
   // Meta-tools (internal coordination)
   "_start_planning",
   "_modify_plan",
@@ -14897,7 +14902,7 @@ var FilePersistentInstructionsStorage = class {
    */
   async load() {
     try {
-      const raw = await fs17.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;
@@ -14909,7 +14914,7 @@ var FilePersistentInstructionsStorage = class {
       }
     }
     try {
-      const content = await fs17.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();
@@ -14939,11 +14944,11 @@ var FilePersistentInstructionsStorage = class {
     };
     const tempPath = `${this.filePath}.tmp`;
     try {
-      await fs17.promises.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
-      await fs17.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 fs17.promises.unlink(tempPath);
+        await fs19.promises.unlink(tempPath);
       } catch {
       }
       throw error;
@@ -14955,7 +14960,7 @@ var FilePersistentInstructionsStorage = class {
    */
   async delete() {
     try {
-      await fs17.promises.unlink(this.filePath);
+      await fs19.promises.unlink(this.filePath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
         throw error;
@@ -14968,11 +14973,11 @@ var FilePersistentInstructionsStorage = class {
    */
   async exists() {
     try {
-      await fs17.promises.access(this.filePath);
+      await fs19.promises.access(this.filePath);
       return true;
     } catch {
       try {
-        await fs17.promises.access(this.legacyFilePath);
+        await fs19.promises.access(this.legacyFilePath);
         return true;
       } catch {
         return false;
@@ -14996,7 +15001,7 @@ var FilePersistentInstructionsStorage = class {
    */
   async ensureDirectory() {
     try {
-      await fs17.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;
@@ -15008,7 +15013,7 @@ var FilePersistentInstructionsStorage = class {
    */
   async removeLegacyFile() {
     try {
-      await fs17.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}`);
@@ -15472,6 +15477,572 @@ ${entry.content}`).join("\n\n");
     };
   }
 };
+function getDefaultBaseDirectory2() {
+  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");
+}
+var DEFAULT_USER_ID = "default";
+function sanitizeUserId(userId) {
+  if (!userId) return DEFAULT_USER_ID;
+  return userId.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase() || DEFAULT_USER_ID;
+}
+var FileUserInfoStorage = class {
+  baseDirectory;
+  filename;
+  constructor(config) {
+    this.baseDirectory = config?.baseDirectory ?? getDefaultBaseDirectory2();
+    this.filename = config?.filename ?? "user_info.json";
+  }
+  /**
+   * Get the directory path for a specific user
+   */
+  getUserDirectory(userId) {
+    const sanitizedId = sanitizeUserId(userId);
+    return path2.join(this.baseDirectory, sanitizedId);
+  }
+  /**
+   * Get the file path for a specific user
+   */
+  getUserFilePath(userId) {
+    return path2.join(this.getUserDirectory(userId), this.filename);
+  }
+  /**
+   * Load user info entries from file for a specific user
+   */
+  async load(userId) {
+    const filePath = this.getUserFilePath(userId);
+    try {
+      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;
+      }
+      return null;
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
+        throw error;
+      }
+      return null;
+    }
+  }
+  /**
+   * Save user info entries to file for a specific user
+   * Creates directory if it doesn't exist.
+   */
+  async save(userId, entries) {
+    const directory = this.getUserDirectory(userId);
+    const filePath = this.getUserFilePath(userId);
+    await this.ensureDirectory(directory);
+    const data = {
+      version: 1,
+      userId: userId || DEFAULT_USER_ID,
+      entries
+    };
+    const tempPath = `${filePath}.tmp`;
+    try {
+      await fs19.promises.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
+      await fs19.promises.rename(tempPath, filePath);
+    } catch (error) {
+      try {
+        await fs19.promises.unlink(tempPath);
+      } catch {
+      }
+      throw error;
+    }
+  }
+  /**
+   * Delete user info file for a specific user
+   */
+  async delete(userId) {
+    const filePath = this.getUserFilePath(userId);
+    try {
+      await fs19.promises.unlink(filePath);
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Check if user info file exists for a specific user
+   */
+  async exists(userId) {
+    const filePath = this.getUserFilePath(userId);
+    try {
+      await fs19.promises.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the file path for a specific user (for display/debugging)
+   */
+  getPath(userId) {
+    return this.getUserFilePath(userId);
+  }
+  /**
+   * Ensure the directory exists
+   */
+  async ensureDirectory(directory) {
+    try {
+      await fs19.promises.mkdir(directory, { recursive: true });
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code !== "EEXIST") {
+        throw error;
+      }
+    }
+  }
+};
+
+// src/core/context-nextgen/plugins/UserInfoPluginNextGen.ts
+init_StorageRegistry();
+var DEFAULT_MAX_TOTAL_SIZE = 1e5;
+var DEFAULT_MAX_ENTRIES2 = 100;
+var KEY_MAX_LENGTH2 = 100;
+var KEY_PATTERN2 = /^[a-zA-Z0-9_-]+$/;
+var USER_INFO_INSTRUCTIONS = `User Info stores key-value information about the current user.
+Data is user-specific and persists across sessions and agents.
+User info is automatically shown in context \u2014 no need to call user_info_get every turn.
+
+**To manage:**
+- \`user_info_set(key, value, description?)\`: Store/update user information
+- \`user_info_get(key?)\`: Retrieve one entry by key, or all entries if no key
+- \`user_info_remove(key)\`: Remove a specific entry
+- \`user_info_clear(confirm: true)\`: Remove all entries (destructive!)
+
+**Use for:** User preferences, context, metadata (theme, language, timezone, role, etc.) It is also perfectly fine to search the web and other external sources for information about the user and then store it in user info for future use.
+
+**Important:** Do not store sensitive information (passwords, tokens, PII) in user info. It is not encrypted and may be accessible to other parts of the system. Always follow best practices for security.
+
+**Rules after each user message:** If the user provides new information about themselves, update user info accordingly. If they ask to change or remove existing information, do that as well. Always keep user info up to date with the latest information provided by the user. Learn about the user proactively!`;
+var userInfoSetDefinition = {
+  type: "function",
+  function: {
+    name: "user_info_set",
+    description: `Store or update user information by key. Data persists across sessions.
+If the key exists, it will be updated. If not, a new entry is created.`,
+    parameters: {
+      type: "object",
+      properties: {
+        key: {
+          type: "string",
+          description: "Unique key for the information (alphanumeric, dash, underscore; max 100 chars)"
+        },
+        value: {
+          description: "Value to store (any JSON-serializable data: string, number, boolean, object, array)"
+        },
+        description: {
+          type: "string",
+          description: "Optional description for self-documentation"
+        }
+      },
+      required: ["key", "value"]
+    }
+  }
+};
+var userInfoGetDefinition = {
+  type: "function",
+  function: {
+    name: "user_info_get",
+    description: "Retrieve user information. If key is provided, returns that entry. Otherwise returns all entries.",
+    parameters: {
+      type: "object",
+      properties: {
+        key: {
+          type: "string",
+          description: "Key of the entry to retrieve (optional - omit to get all entries)"
+        }
+      },
+      required: []
+    }
+  }
+};
+var userInfoRemoveDefinition = {
+  type: "function",
+  function: {
+    name: "user_info_remove",
+    description: "Remove a specific user information entry by key.",
+    parameters: {
+      type: "object",
+      properties: {
+        key: {
+          type: "string",
+          description: "Key of the entry to remove"
+        }
+      },
+      required: ["key"]
+    }
+  }
+};
+var userInfoClearDefinition = {
+  type: "function",
+  function: {
+    name: "user_info_clear",
+    description: "Clear all user information entries (DESTRUCTIVE). Requires confirmation.",
+    parameters: {
+      type: "object",
+      properties: {
+        confirm: {
+          type: "boolean",
+          description: "Must be true to confirm deletion"
+        }
+      },
+      required: ["confirm"]
+    }
+  }
+};
+function validateKey2(key) {
+  if (typeof key !== "string") return "Key must be a string";
+  const trimmed = key.trim();
+  if (trimmed.length === 0) return "Key cannot be empty";
+  if (trimmed.length > KEY_MAX_LENGTH2) return `Key exceeds maximum length (${KEY_MAX_LENGTH2} chars)`;
+  if (!KEY_PATTERN2.test(trimmed)) return "Key must contain only alphanumeric characters, dashes, and underscores";
+  return null;
+}
+function getValueType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function calculateValueSize(value) {
+  const json = JSON.stringify(value);
+  return Buffer.byteLength(json, "utf-8");
+}
+function buildStorageContext(toolContext) {
+  const global2 = exports.StorageRegistry.getContext();
+  if (global2) return global2;
+  if (toolContext?.userId) return { userId: toolContext.userId };
+  return void 0;
+}
+function formatValue(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
+}
+var UserInfoPluginNextGen = class {
+  name = "user_info";
+  _destroyed = false;
+  _storage = null;
+  /** In-memory cache of entries */
+  _entries = /* @__PURE__ */ new Map();
+  /** Whether entries have been loaded from storage */
+  _initialized = false;
+  maxTotalSize;
+  maxEntries;
+  estimator = simpleTokenEstimator;
+  explicitStorage;
+  /** UserId for getContent() and lazy initialization */
+  userId;
+  _tokenCache = null;
+  _instructionsTokenCache = null;
+  constructor(config) {
+    this.maxTotalSize = config?.maxTotalSize ?? DEFAULT_MAX_TOTAL_SIZE;
+    this.maxEntries = config?.maxEntries ?? DEFAULT_MAX_ENTRIES2;
+    this.explicitStorage = config?.storage;
+    this.userId = config?.userId;
+  }
+  // ============================================================================
+  // IContextPluginNextGen Implementation
+  // ============================================================================
+  getInstructions() {
+    return USER_INFO_INSTRUCTIONS;
+  }
+  async getContent() {
+    await this.ensureInitialized();
+    if (this._entries.size === 0) {
+      this._tokenCache = 0;
+      return null;
+    }
+    const rendered = this.renderContent();
+    this._tokenCache = this.estimator.estimateTokens(rendered);
+    return rendered;
+  }
+  getContents() {
+    return new Map(this._entries);
+  }
+  getTokenSize() {
+    return this._tokenCache ?? 0;
+  }
+  getInstructionsTokenSize() {
+    if (this._instructionsTokenCache === null) {
+      this._instructionsTokenCache = this.estimator.estimateTokens(USER_INFO_INSTRUCTIONS);
+    }
+    return this._instructionsTokenCache;
+  }
+  isCompactable() {
+    return false;
+  }
+  async compact(_targetTokensToFree) {
+    return 0;
+  }
+  getTools() {
+    return [
+      this.createUserInfoSetTool(),
+      this.createUserInfoGetTool(),
+      this.createUserInfoRemoveTool(),
+      this.createUserInfoClearTool()
+    ];
+  }
+  destroy() {
+    if (this._destroyed) return;
+    this._entries.clear();
+    this._destroyed = true;
+    this._tokenCache = null;
+  }
+  getState() {
+    return {
+      version: 1,
+      entries: Array.from(this._entries.values()),
+      userId: this.userId
+    };
+  }
+  restoreState(state) {
+    if (!state || typeof state !== "object") return;
+    const s = state;
+    if ("version" in s && s.version === 1 && Array.isArray(s.entries)) {
+      this._entries.clear();
+      for (const entry of s.entries) {
+        this._entries.set(entry.id, entry);
+      }
+      this._initialized = true;
+      this._tokenCache = null;
+    }
+  }
+  // ============================================================================
+  // Public API
+  // ============================================================================
+  /**
+   * Check if initialized
+   */
+  get isInitialized() {
+    return this._initialized;
+  }
+  // ============================================================================
+  // Private Helpers
+  // ============================================================================
+  assertNotDestroyed() {
+    if (this._destroyed) {
+      throw new Error("UserInfoPluginNextGen is destroyed");
+    }
+  }
+  /**
+   * Lazy load entries from storage
+   */
+  async ensureInitialized() {
+    if (this._initialized || this._destroyed) return;
+    try {
+      const storage = this.resolveStorage();
+      const entries = await storage.load(this.userId);
+      this._entries.clear();
+      if (entries) {
+        for (const entry of entries) {
+          this._entries.set(entry.id, entry);
+        }
+      }
+      this._initialized = true;
+    } catch (error) {
+      console.warn(`Failed to load user info for userId '${this.userId ?? "default"}':`, error);
+      this._entries.clear();
+      this._initialized = true;
+    }
+    this._tokenCache = null;
+  }
+  /**
+   * Render entries as markdown for context injection
+   */
+  renderContent() {
+    const sorted = Array.from(this._entries.values()).sort((a, b) => a.createdAt - b.createdAt);
+    return sorted.map((entry) => `### ${entry.id}
+${formatValue(entry.value)}`).join("\n\n");
+  }
+  /**
+   * Resolve storage instance (lazy singleton)
+   */
+  resolveStorage(context) {
+    if (this._storage) return this._storage;
+    if (this.explicitStorage) {
+      this._storage = this.explicitStorage;
+      return this._storage;
+    }
+    const factory = exports.StorageRegistry.get("userInfo");
+    if (factory) {
+      this._storage = factory(buildStorageContext(context));
+      return this._storage;
+    }
+    this._storage = new FileUserInfoStorage();
+    return this._storage;
+  }
+  /**
+   * Persist current entries to storage
+   */
+  async persistToStorage(userId) {
+    const storage = this.resolveStorage();
+    if (this._entries.size === 0) {
+      await storage.delete(userId);
+    } else {
+      await storage.save(userId, Array.from(this._entries.values()));
+    }
+  }
+  // ============================================================================
+  // Tool Factories
+  // ============================================================================
+  createUserInfoSetTool() {
+    return {
+      definition: userInfoSetDefinition,
+      execute: async (args, context) => {
+        this.assertNotDestroyed();
+        await this.ensureInitialized();
+        const userId = context?.userId ?? this.userId;
+        const key = args.key;
+        const value = args.value;
+        const description = args.description;
+        const keyError = validateKey2(key);
+        if (keyError) {
+          return { error: keyError };
+        }
+        const trimmedKey = key.trim();
+        if (value === void 0) {
+          return { error: "Value cannot be undefined. Use null for explicit null value." };
+        }
+        if (!this._entries.has(trimmedKey) && this._entries.size >= this.maxEntries) {
+          return { error: `Maximum number of entries reached (${this.maxEntries})` };
+        }
+        const valueSize = calculateValueSize(value);
+        let currentTotal = 0;
+        for (const e of this._entries.values()) {
+          currentTotal += calculateValueSize(e.value);
+        }
+        const existingSize = this._entries.has(trimmedKey) ? calculateValueSize(this._entries.get(trimmedKey).value) : 0;
+        const newTotal = currentTotal - existingSize + valueSize;
+        if (newTotal > this.maxTotalSize) {
+          return { error: `Total size would exceed maximum (${this.maxTotalSize} bytes)` };
+        }
+        const now = Date.now();
+        const existing = this._entries.get(trimmedKey);
+        const entry = {
+          id: trimmedKey,
+          value,
+          valueType: getValueType(value),
+          description,
+          createdAt: existing?.createdAt ?? now,
+          updatedAt: now
+        };
+        this._entries.set(trimmedKey, entry);
+        this._tokenCache = null;
+        await this.persistToStorage(userId);
+        return {
+          success: true,
+          message: existing ? `User info '${trimmedKey}' updated` : `User info '${trimmedKey}' added`,
+          key: trimmedKey,
+          valueType: entry.valueType,
+          valueSize
+        };
+      },
+      permission: { scope: "always", riskLevel: "low" },
+      describeCall: (args) => `set user info '${args.key}'`
+    };
+  }
+  createUserInfoGetTool() {
+    return {
+      definition: userInfoGetDefinition,
+      execute: async (args, _context) => {
+        this.assertNotDestroyed();
+        await this.ensureInitialized();
+        const key = args.key;
+        if (this._entries.size === 0) {
+          return { error: "User info not found" };
+        }
+        if (key !== void 0) {
+          const trimmedKey = key.trim();
+          const entry = this._entries.get(trimmedKey);
+          if (!entry) {
+            return { error: `User info '${trimmedKey}' not found` };
+          }
+          return {
+            key: entry.id,
+            value: entry.value,
+            valueType: entry.valueType,
+            description: entry.description,
+            createdAt: entry.createdAt,
+            updatedAt: entry.updatedAt
+          };
+        }
+        const entries = Array.from(this._entries.values());
+        return {
+          count: entries.length,
+          entries: entries.map((e) => ({
+            key: e.id,
+            value: e.value,
+            valueType: e.valueType,
+            description: e.description,
+            createdAt: e.createdAt,
+            updatedAt: e.updatedAt
+          }))
+        };
+      },
+      permission: { scope: "always", riskLevel: "low" },
+      describeCall: (args) => args.key ? `get user info '${args.key}'` : "get all user info"
+    };
+  }
+  createUserInfoRemoveTool() {
+    return {
+      definition: userInfoRemoveDefinition,
+      execute: async (args, context) => {
+        this.assertNotDestroyed();
+        await this.ensureInitialized();
+        const userId = context?.userId ?? this.userId;
+        const key = args.key;
+        if (!key || typeof key !== "string" || key.trim().length === 0) {
+          return { error: "Key is required" };
+        }
+        const trimmedKey = key.trim();
+        if (!this._entries.has(trimmedKey)) {
+          return { error: `User info '${trimmedKey}' not found` };
+        }
+        this._entries.delete(trimmedKey);
+        this._tokenCache = null;
+        await this.persistToStorage(userId);
+        return {
+          success: true,
+          message: `User info '${trimmedKey}' removed`,
+          key: trimmedKey
+        };
+      },
+      permission: { scope: "always", riskLevel: "low" },
+      describeCall: (args) => `remove user info '${args.key}'`
+    };
+  }
+  createUserInfoClearTool() {
+    return {
+      definition: userInfoClearDefinition,
+      execute: async (args, context) => {
+        this.assertNotDestroyed();
+        const userId = context?.userId ?? this.userId;
+        if (args.confirm !== true) {
+          return { error: "Must pass confirm: true to clear user info" };
+        }
+        this._entries.clear();
+        this._tokenCache = null;
+        const storage = this.resolveStorage(context);
+        await storage.delete(userId);
+        return {
+          success: true,
+          message: "All user information cleared"
+        };
+      },
+      permission: { scope: "once", riskLevel: "medium" },
+      describeCall: () => "clear user info"
+    };
+  }
+};
 
 // src/core/context-nextgen/AgentContextNextGen.ts
 init_StorageRegistry();
@@ -16120,7 +16691,8 @@ var StrategyRegistry = class {
 var DEFAULT_FEATURES = {
   workingMemory: true,
   inContextMemory: false,
-  persistentInstructions: false
+  persistentInstructions: false,
+  userInfo: false
 };
 var DEFAULT_CONFIG2 = {
   responseReserve: 4096,
@@ -16238,6 +16810,13 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
         ...piConfig
       }));
     }
+    if (features.userInfo) {
+      const uiConfig = configs.userInfo;
+      this.registerPlugin(new UserInfoPluginNextGen({
+        userId: this._userId,
+        ...uiConfig
+      }));
+    }
     this.validateStrategyDependencies(this._compactionStrategy);
   }
   /**
@@ -16791,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 = {
@@ -20249,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;
@@ -20301,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,
@@ -20814,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();
   }
@@ -21155,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
    */
@@ -21177,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 };
@@ -21197,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
@@ -21873,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)
@@ -22758,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) {
@@ -22787,6 +23405,874 @@ 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("");
+  }
+  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
+  };
+}
+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];
+      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 {
+    for (const { name, hook } of registeredHooks) {
+      try {
+        agent.unregisterHook(name, hook);
+      } catch {
+      }
+    }
+    if (ownsAgent) {
+      agent.destroy();
+    }
+  }
+}
+
 // src/core/index.ts
 init_constants();
 (class {
@@ -22803,7 +24289,7 @@ init_constants();
       throw new Error("Configuration file not found. Searched: " + this.DEFAULT_PATHS.join(", "));
     }
     try {
-      const content = await fs17.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);
@@ -22824,8 +24310,8 @@ init_constants();
       throw new Error("Configuration file not found. Searched: " + this.DEFAULT_PATHS.join(", "));
     }
     try {
-      const fs18 = __require("fs");
-      const content = fs18.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);
@@ -22843,7 +24329,7 @@ init_constants();
   static async findConfig() {
     for (const path6 of this.DEFAULT_PATHS) {
       try {
-        await fs17.promises.access(path2.resolve(path6));
+        await fs19.promises.access(path2.resolve(path6));
         return path2.resolve(path6);
       } catch {
       }
@@ -22854,10 +24340,10 @@ init_constants();
    * Find configuration file synchronously
    */
   static findConfigSync() {
-    const fs18 = __require("fs");
+    const fs20 = __require("fs");
     for (const path6 of this.DEFAULT_PATHS) {
       try {
-        fs18.accessSync(path2.resolve(path6));
+        fs20.accessSync(path2.resolve(path6));
         return path2.resolve(path6);
       } catch {
       }
@@ -28431,7 +29917,7 @@ var MCPRegistry = class {
   static async loadFromConfigFile(path6) {
     try {
       const configPath = path2.resolve(path6);
-      const content = await fs17.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");
@@ -29036,7 +30522,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 fs17__namespace.createReadStream(audio);
+      return fs19__namespace.createReadStream(audio);
     } else {
       throw new Error("Invalid audio input: must be Buffer or file path");
     }
@@ -29589,7 +31075,7 @@ var TextToSpeech = class _TextToSpeech {
    */
   async toFile(text, filePath, options) {
     const response = await this.synthesize(text, options);
-    await fs16__namespace.writeFile(filePath, response.audio);
+    await fs18__namespace.writeFile(filePath, response.audio);
   }
   // ======================== Introspection Methods ========================
   /**
@@ -29937,7 +31423,7 @@ var SpeechToText = class _SpeechToText {
    * @param options - Optional transcription parameters
    */
   async transcribeFile(filePath, options) {
-    const audio = await fs16__namespace.readFile(filePath);
+    const audio = await fs18__namespace.readFile(filePath);
     return this.transcribe(audio, options);
   }
   /**
@@ -30263,7 +31749,7 @@ var OpenAIImageProvider = class extends BaseMediaProvider {
     if (Buffer.isBuffer(image)) {
       return new File([new Uint8Array(image)], "image.png", { type: "image/png" });
     }
-    return fs17__namespace.createReadStream(image);
+    return fs19__namespace.createReadStream(image);
   }
   /**
    * Handle OpenAI API errors
@@ -30410,8 +31896,8 @@ var GoogleImageProvider = class extends BaseMediaProvider {
     if (Buffer.isBuffer(image)) {
       imageBytes = image.toString("base64");
     } else {
-      const fs18 = await import('fs');
-      const buffer = fs18.readFileSync(image);
+      const fs20 = await import('fs');
+      const buffer = fs20.readFileSync(image);
       imageBytes = buffer.toString("base64");
     }
     return {
@@ -30572,7 +32058,7 @@ var GrokImageProvider = class extends BaseMediaProvider {
     if (Buffer.isBuffer(image)) {
       return new File([new Uint8Array(image)], "image.png", { type: "image/png" });
     }
-    return fs17__namespace.createReadStream(image);
+    return fs19__namespace.createReadStream(image);
   }
   /**
    * Handle API errors
@@ -32022,8 +33508,8 @@ var OpenAISoraProvider = class extends BaseMediaProvider {
       return new File([new Uint8Array(image)], "input.png", { type: "image/png" });
     }
     if (!image.startsWith("http")) {
-      const fs18 = await import('fs');
-      const data = fs18.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);
@@ -32201,7 +33687,7 @@ var GoogleVeoProvider = class extends BaseMediaProvider {
           if (video.videoBytes) {
             buffer = Buffer.from(video.videoBytes, "base64");
           } else if (video.uri) {
-            const fs18 = await import('fs/promises');
+            const fs20 = await import('fs/promises');
             const os3 = await import('os');
             const path6 = await import('path');
             const tempDir = os3.tmpdir();
@@ -32212,11 +33698,11 @@ var GoogleVeoProvider = class extends BaseMediaProvider {
                 // Pass as GeneratedVideo
                 downloadPath: tempFile
               });
-              buffer = await fs18.readFile(tempFile);
-              await fs18.unlink(tempFile).catch(() => {
+              buffer = await fs20.readFile(tempFile);
+              await fs20.unlink(tempFile).catch(() => {
               });
             } catch (downloadError) {
-              await fs18.unlink(tempFile).catch(() => {
+              await fs20.unlink(tempFile).catch(() => {
               });
               throw new ProviderError(
                 "google",
@@ -32338,8 +33824,8 @@ var GoogleVeoProvider = class extends BaseMediaProvider {
     if (image.startsWith("http://") || image.startsWith("https://")) {
       return { imageUri: image };
     }
-    const fs18 = await import('fs/promises');
-    const data = await fs18.readFile(image);
+    const fs20 = await import('fs/promises');
+    const data = await fs20.readFile(image);
     return {
       imageBytes: data.toString("base64")
     };
@@ -32646,8 +34132,8 @@ var GrokImagineProvider = class extends BaseMediaProvider {
     if (image.startsWith("http") || image.startsWith("data:")) {
       return image;
     }
-    const fs18 = await import('fs');
-    const data = fs18.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}`;
@@ -34083,7 +35569,7 @@ var DocumentReader = class _DocumentReader {
   async resolveSource(source) {
     switch (source.type) {
       case "file": {
-        const buffer = await fs16.readFile(source.path);
+        const buffer = await fs18.readFile(source.path);
         const filename = source.path.split("/").pop() || source.path;
         return { buffer, filename };
       }
@@ -35316,245 +36802,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.
 
@@ -36350,7 +37597,7 @@ var InMemoryHistoryStorage = class {
     this.summaries = state.summaries ? [...state.summaries] : [];
   }
 };
-function getDefaultBaseDirectory2() {
+function getDefaultBaseDirectory3() {
   const platform2 = process.platform;
   if (platform2 === "win32") {
     const appData = process.env.APPDATA || process.env.LOCALAPPDATA;
@@ -36373,7 +37620,7 @@ var FileContextStorage = class {
   constructor(config) {
     this.agentId = config.agentId;
     const sanitizedAgentId = sanitizeId(config.agentId);
-    const baseDir = config.baseDirectory ?? getDefaultBaseDirectory2();
+    const baseDir = config.baseDirectory ?? getDefaultBaseDirectory3();
     this.prettyPrint = config.prettyPrint ?? true;
     this.sessionsDirectory = path2.join(baseDir, sanitizedAgentId, "sessions");
     this.indexPath = path2.join(this.sessionsDirectory, "_index.json");
@@ -36402,11 +37649,11 @@ var FileContextStorage = class {
     const data = this.prettyPrint ? JSON.stringify(storedSession, null, 2) : JSON.stringify(storedSession);
     const tempPath = `${filePath}.tmp`;
     try {
-      await fs17.promises.writeFile(tempPath, data, "utf-8");
-      await fs17.promises.rename(tempPath, filePath);
+      await fs19.promises.writeFile(tempPath, data, "utf-8");
+      await fs19.promises.rename(tempPath, filePath);
     } catch (error) {
       try {
-        await fs17.promises.unlink(tempPath);
+        await fs19.promises.unlink(tempPath);
       } catch {
       }
       throw error;
@@ -36427,7 +37674,7 @@ var FileContextStorage = class {
     const sanitizedSessionId = sanitizeId(sessionId);
     const filePath = this.getFilePath(sanitizedSessionId);
     try {
-      await fs17.promises.unlink(filePath);
+      await fs19.promises.unlink(filePath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
         throw error;
@@ -36442,7 +37689,7 @@ var FileContextStorage = class {
     const sanitizedSessionId = sanitizeId(sessionId);
     const filePath = this.getFilePath(sanitizedSessionId);
     try {
-      await fs17.promises.access(filePath);
+      await fs19.promises.access(filePath);
       return true;
     } catch {
       return false;
@@ -36507,7 +37754,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 fs17.promises.writeFile(filePath, data, "utf-8");
+    await fs19.promises.writeFile(filePath, data, "utf-8");
     await this.updateIndex(stored);
   }
   /**
@@ -36535,13 +37782,13 @@ var FileContextStorage = class {
    */
   async rebuildIndex() {
     await this.ensureDirectory();
-    const files = await fs17.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 fs17.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 {
@@ -36563,7 +37810,7 @@ var FileContextStorage = class {
   }
   async ensureDirectory() {
     try {
-      await fs17.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;
@@ -36573,7 +37820,7 @@ var FileContextStorage = class {
   async loadRaw(sanitizedSessionId) {
     const filePath = this.getFilePath(sanitizedSessionId);
     try {
-      const data = await fs17.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") {
@@ -36591,7 +37838,7 @@ var FileContextStorage = class {
       return this.index;
     }
     try {
-      const data = await fs17.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) {
@@ -36612,7 +37859,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 fs17.promises.writeFile(this.indexPath, data, "utf-8");
+    await fs19.promises.writeFile(this.indexPath, data, "utf-8");
   }
   async updateIndex(stored) {
     const index = await this.loadIndex();
@@ -36645,7 +37892,7 @@ var FileContextStorage = class {
 function createFileContextStorage(agentId, options) {
   return new FileContextStorage({ agentId, ...options });
 }
-function getDefaultBaseDirectory3() {
+function getDefaultBaseDirectory4() {
   const platform2 = process.platform;
   if (platform2 === "win32") {
     const appData = process.env.APPDATA || process.env.LOCALAPPDATA;
@@ -36664,7 +37911,7 @@ var FileAgentDefinitionStorage = class {
   prettyPrint;
   index = null;
   constructor(config = {}) {
-    this.baseDirectory = config.baseDirectory ?? getDefaultBaseDirectory3();
+    this.baseDirectory = config.baseDirectory ?? getDefaultBaseDirectory4();
     this.prettyPrint = config.prettyPrint ?? true;
     this.indexPath = path2.join(this.baseDirectory, "_agents_index.json");
   }
@@ -36686,11 +37933,11 @@ var FileAgentDefinitionStorage = class {
     const data = this.prettyPrint ? JSON.stringify(definition, null, 2) : JSON.stringify(definition);
     const tempPath = `${filePath}.tmp`;
     try {
-      await fs17.promises.writeFile(tempPath, data, "utf-8");
-      await fs17.promises.rename(tempPath, filePath);
+      await fs19.promises.writeFile(tempPath, data, "utf-8");
+      await fs19.promises.rename(tempPath, filePath);
     } catch (error) {
       try {
-        await fs17.promises.unlink(tempPath);
+        await fs19.promises.unlink(tempPath);
       } catch {
       }
       throw error;
@@ -36712,7 +37959,7 @@ var FileAgentDefinitionStorage = class {
     const agentDir = path2.join(this.baseDirectory, sanitizedId);
     const filePath = path2.join(agentDir, "definition.json");
     try {
-      await fs17.promises.unlink(filePath);
+      await fs19.promises.unlink(filePath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
         throw error;
@@ -36727,7 +37974,7 @@ var FileAgentDefinitionStorage = class {
     const sanitizedId = sanitizeAgentId2(agentId);
     const filePath = path2.join(this.baseDirectory, sanitizedId, "definition.json");
     try {
-      await fs17.promises.access(filePath);
+      await fs19.promises.access(filePath);
       return true;
     } catch {
       return false;
@@ -36789,13 +38036,13 @@ var FileAgentDefinitionStorage = class {
    */
   async rebuildIndex() {
     await this.ensureDirectory(this.baseDirectory);
-    const entries = await fs17.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 fs17.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 {
@@ -36813,7 +38060,7 @@ var FileAgentDefinitionStorage = class {
   // ==========================================================================
   async ensureDirectory(dir) {
     try {
-      await fs17.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;
@@ -36823,7 +38070,7 @@ var FileAgentDefinitionStorage = class {
   async loadRaw(sanitizedId) {
     const filePath = path2.join(this.baseDirectory, sanitizedId, "definition.json");
     try {
-      const data = await fs17.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") {
@@ -36841,7 +38088,7 @@ var FileAgentDefinitionStorage = class {
       return this.index;
     }
     try {
-      const data = await fs17.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) {
@@ -36861,7 +38108,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 fs17.promises.writeFile(this.indexPath, data, "utf-8");
+    await fs19.promises.writeFile(this.indexPath, data, "utf-8");
   }
   async updateIndex(definition) {
     const index = await this.loadIndex();
@@ -36919,10 +38166,10 @@ var FileMediaStorage = class {
   }
   async save(data, metadata) {
     const dir = metadata.userId ? path2__namespace.join(this.outputDir, metadata.userId) : this.outputDir;
-    await fs16__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 fs16__namespace.writeFile(filePath, data);
+    await fs18__namespace.writeFile(filePath, data);
     const format = metadata.format.toLowerCase();
     const mimeType = MIME_TYPES2[format] ?? "application/octet-stream";
     return {
@@ -36933,7 +38180,7 @@ var FileMediaStorage = class {
   }
   async read(location) {
     try {
-      return await fs16__namespace.readFile(location);
+      return await fs18__namespace.readFile(location);
     } catch (err) {
       if (err.code === "ENOENT") {
         return null;
@@ -36943,7 +38190,7 @@ var FileMediaStorage = class {
   }
   async delete(location) {
     try {
-      await fs16__namespace.unlink(location);
+      await fs18__namespace.unlink(location);
     } catch (err) {
       if (err.code === "ENOENT") {
         return;
@@ -36953,7 +38200,7 @@ var FileMediaStorage = class {
   }
   async exists(location) {
     try {
-      await fs16__namespace.access(location);
+      await fs18__namespace.access(location);
       return true;
     } catch {
       return false;
@@ -36962,11 +38209,11 @@ var FileMediaStorage = class {
   async list(options) {
     await this.ensureDir();
     let entries = [];
-    const files = await fs16__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 fs16__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";
@@ -37006,7 +38253,7 @@ var FileMediaStorage = class {
   }
   async ensureDir() {
     if (!this.initialized) {
-      await fs16__namespace.mkdir(this.outputDir, { recursive: true });
+      await fs18__namespace.mkdir(this.outputDir, { recursive: true });
       this.initialized = true;
     }
   }
@@ -37014,58 +38261,82 @@ var FileMediaStorage = class {
 function createFileMediaStorage(config) {
   return new FileMediaStorage(config);
 }
-function getDefaultBaseDirectory4() {
+function getDefaultBaseDirectory5() {
   const platform2 = process.platform;
   if (platform2 === "win32") {
     const appData = process.env.APPDATA || process.env.LOCALAPPDATA;
     if (appData) {
-      return path2.join(appData, "oneringai", "custom-tools");
+      return path2.join(appData, "oneringai", "users");
     }
   }
-  return path2.join(os2.homedir(), ".oneringai", "custom-tools");
+  return path2.join(os2.homedir(), ".oneringai", "users");
+}
+var DEFAULT_USER_ID2 = "default";
+function sanitizeUserId2(userId) {
+  if (!userId) {
+    return DEFAULT_USER_ID2;
+  }
+  return userId.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase() || DEFAULT_USER_ID2;
 }
 function sanitizeName(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase() || "default";
 }
 var FileCustomToolStorage = class {
   baseDirectory;
-  indexPath;
   prettyPrint;
-  index = null;
   constructor(config = {}) {
-    this.baseDirectory = config.baseDirectory ?? getDefaultBaseDirectory4();
+    this.baseDirectory = config.baseDirectory ?? getDefaultBaseDirectory5();
     this.prettyPrint = config.prettyPrint ?? true;
-    this.indexPath = path2.join(this.baseDirectory, "_index.json");
+  }
+  /**
+   * Get the directory path for a specific user's custom tools
+   */
+  getUserDirectory(userId) {
+    const sanitizedId = sanitizeUserId2(userId);
+    return path2.join(this.baseDirectory, sanitizedId, "custom-tools");
+  }
+  /**
+   * Get the index file path for a specific user
+   */
+  getUserIndexPath(userId) {
+    return path2.join(this.getUserDirectory(userId), "_index.json");
+  }
+  /**
+   * Get the tool file path for a specific user
+   */
+  getToolPath(userId, sanitizedName) {
+    return path2.join(this.getUserDirectory(userId), `${sanitizedName}.json`);
   }
   /**
    * Save a custom tool definition
    */
-  async save(definition) {
+  async save(userId, definition) {
+    const directory = this.getUserDirectory(userId);
     const sanitized = sanitizeName(definition.name);
-    const filePath = path2.join(this.baseDirectory, `${sanitized}.json`);
-    await this.ensureDirectory(this.baseDirectory);
+    const filePath = this.getToolPath(userId, sanitized);
+    await this.ensureDirectory(directory);
     const data = this.prettyPrint ? JSON.stringify(definition, null, 2) : JSON.stringify(definition);
     const tempPath = `${filePath}.tmp`;
     try {
-      await fs17.promises.writeFile(tempPath, data, "utf-8");
-      await fs17.promises.rename(tempPath, filePath);
+      await fs19.promises.writeFile(tempPath, data, "utf-8");
+      await fs19.promises.rename(tempPath, filePath);
     } catch (error) {
       try {
-        await fs17.promises.unlink(tempPath);
+        await fs19.promises.unlink(tempPath);
       } catch {
       }
       throw error;
     }
-    await this.updateIndex(definition);
+    await this.updateIndex(userId, definition);
   }
   /**
    * Load a custom tool definition by name
    */
-  async load(name) {
+  async load(userId, name) {
     const sanitized = sanitizeName(name);
-    const filePath = path2.join(this.baseDirectory, `${sanitized}.json`);
+    const filePath = this.getToolPath(userId, sanitized);
     try {
-      const data = await fs17.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") {
@@ -37080,26 +38351,26 @@ var FileCustomToolStorage = class {
   /**
    * Delete a custom tool definition
    */
-  async delete(name) {
+  async delete(userId, name) {
     const sanitized = sanitizeName(name);
-    const filePath = path2.join(this.baseDirectory, `${sanitized}.json`);
+    const filePath = this.getToolPath(userId, sanitized);
     try {
-      await fs17.promises.unlink(filePath);
+      await fs19.promises.unlink(filePath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
         throw error;
       }
     }
-    await this.removeFromIndex(name);
+    await this.removeFromIndex(userId, name);
   }
   /**
    * Check if a custom tool exists
    */
-  async exists(name) {
+  async exists(userId, name) {
     const sanitized = sanitizeName(name);
-    const filePath = path2.join(this.baseDirectory, `${sanitized}.json`);
+    const filePath = this.getToolPath(userId, sanitized);
     try {
-      await fs17.promises.access(filePath);
+      await fs19.promises.access(filePath);
       return true;
     } catch {
       return false;
@@ -37108,8 +38379,8 @@ var FileCustomToolStorage = class {
   /**
    * List custom tools (summaries only)
    */
-  async list(options) {
-    const index = await this.loadIndex();
+  async list(userId, options) {
+    const index = await this.loadIndex(userId);
     let entries = [...index.tools];
     if (options?.tags && options.tags.length > 0) {
       entries = entries.filter((e) => {
@@ -37150,62 +38421,59 @@ var FileCustomToolStorage = class {
   /**
    * Update metadata without loading full definition
    */
-  async updateMetadata(name, metadata) {
-    const definition = await this.load(name);
+  async updateMetadata(userId, name, metadata) {
+    const definition = await this.load(userId, name);
     if (!definition) {
       throw new Error(`Custom tool '${name}' not found`);
     }
     definition.metadata = { ...definition.metadata, ...metadata };
     definition.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await this.save(definition);
+    await this.save(userId, definition);
   }
   /**
-   * Get storage path
+   * Get storage path for a specific user
    */
-  getPath() {
-    return this.baseDirectory;
+  getPath(userId) {
+    return this.getUserDirectory(userId);
   }
   // ==========================================================================
   // Private Helpers
   // ==========================================================================
   async ensureDirectory(dir) {
     try {
-      await fs17.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;
       }
     }
   }
-  async loadIndex() {
-    if (this.index) {
-      return this.index;
-    }
+  async loadIndex(userId) {
+    const indexPath = this.getUserIndexPath(userId);
     try {
-      const data = await fs17.promises.readFile(this.indexPath, "utf-8");
-      this.index = JSON.parse(data);
-      return this.index;
+      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") {
-        this.index = {
+        return {
           version: 1,
           tools: [],
           lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
         };
-        return this.index;
       }
       throw error;
     }
   }
-  async saveIndex() {
-    if (!this.index) return;
-    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 fs17.promises.writeFile(this.indexPath, data, "utf-8");
+  async saveIndex(userId, index) {
+    const directory = this.getUserDirectory(userId);
+    const indexPath = this.getUserIndexPath(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(definition) {
-    const index = await this.loadIndex();
+  async updateIndex(userId, definition) {
+    const index = await this.loadIndex(userId);
     const entry = this.definitionToIndexEntry(definition);
     const existingIdx = index.tools.findIndex((e) => e.name === definition.name);
     if (existingIdx >= 0) {
@@ -37213,12 +38481,12 @@ var FileCustomToolStorage = class {
     } else {
       index.tools.push(entry);
     }
-    await this.saveIndex();
+    await this.saveIndex(userId, index);
   }
-  async removeFromIndex(name) {
-    const index = await this.loadIndex();
+  async removeFromIndex(userId, name) {
+    const index = await this.loadIndex(userId);
     index.tools = index.tools.filter((e) => e.name !== name);
-    await this.saveIndex();
+    await this.saveIndex(userId, index);
   }
   definitionToIndexEntry(definition) {
     return {
@@ -37235,6 +38503,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;
@@ -38335,8 +39831,8 @@ var FileStorage = class {
   }
   async ensureDirectory() {
     try {
-      await fs16__namespace.mkdir(this.directory, { recursive: true });
-      await fs16__namespace.chmod(this.directory, 448);
+      await fs18__namespace.mkdir(this.directory, { recursive: true });
+      await fs18__namespace.chmod(this.directory, 448);
     } catch (error) {
     }
   }
@@ -38352,13 +39848,13 @@ var FileStorage = class {
     const filePath = this.getFilePath(key);
     const plaintext = JSON.stringify(token);
     const encrypted = encrypt(plaintext, this.encryptionKey);
-    await fs16__namespace.writeFile(filePath, encrypted, "utf8");
-    await fs16__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 fs16__namespace.readFile(filePath, "utf8");
+      const encrypted = await fs18__namespace.readFile(filePath, "utf8");
       const decrypted = decrypt(encrypted, this.encryptionKey);
       return JSON.parse(decrypted);
     } catch (error) {
@@ -38367,7 +39863,7 @@ var FileStorage = class {
       }
       console.error("Failed to read/decrypt token file:", error);
       try {
-        await fs16__namespace.unlink(filePath);
+        await fs18__namespace.unlink(filePath);
       } catch {
       }
       return null;
@@ -38376,7 +39872,7 @@ var FileStorage = class {
   async deleteToken(key) {
     const filePath = this.getFilePath(key);
     try {
-      await fs16__namespace.unlink(filePath);
+      await fs18__namespace.unlink(filePath);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -38386,7 +39882,7 @@ var FileStorage = class {
   async hasToken(key) {
     const filePath = this.getFilePath(key);
     try {
-      await fs16__namespace.access(filePath);
+      await fs18__namespace.access(filePath);
       return true;
     } catch {
       return false;
@@ -38397,7 +39893,7 @@ var FileStorage = class {
    */
   async listTokens() {
     try {
-      const files = await fs16__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 [];
@@ -38408,10 +39904,10 @@ var FileStorage = class {
    */
   async clearAll() {
     try {
-      const files = await fs16__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) => fs16__namespace.unlink(path2__namespace.join(this.directory, f)).catch(() => {
+        tokenFiles.map((f) => fs18__namespace.unlink(path2__namespace.join(this.directory, f)).catch(() => {
         }))
       );
     } catch {
@@ -38859,14 +40355,14 @@ var FileConnectorStorage = class {
     await this.ensureDirectory();
     const filePath = this.getFilePath(name);
     const json = JSON.stringify(stored, null, 2);
-    await fs16__namespace.writeFile(filePath, json, "utf8");
-    await fs16__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 fs16__namespace.readFile(filePath, "utf8");
+      const json = await fs18__namespace.readFile(filePath, "utf8");
       return JSON.parse(json);
     } catch (error) {
       const err = error;
@@ -38879,7 +40375,7 @@ var FileConnectorStorage = class {
   async delete(name) {
     const filePath = this.getFilePath(name);
     try {
-      await fs16__namespace.unlink(filePath);
+      await fs18__namespace.unlink(filePath);
       await this.updateIndex(name, "remove");
       return true;
     } catch (error) {
@@ -38893,7 +40389,7 @@ var FileConnectorStorage = class {
   async has(name) {
     const filePath = this.getFilePath(name);
     try {
-      await fs16__namespace.access(filePath);
+      await fs18__namespace.access(filePath);
       return true;
     } catch {
       return false;
@@ -38919,13 +40415,13 @@ var FileConnectorStorage = class {
    */
   async clear() {
     try {
-      const files = await fs16__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) => fs16__namespace.unlink(path2__namespace.join(this.directory, f)).catch(() => {
+          (f) => fs18__namespace.unlink(path2__namespace.join(this.directory, f)).catch(() => {
           })
         )
       );
@@ -38952,8 +40448,8 @@ var FileConnectorStorage = class {
   async ensureDirectory() {
     if (this.initialized) return;
     try {
-      await fs16__namespace.mkdir(this.directory, { recursive: true });
-      await fs16__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;
@@ -38964,7 +40460,7 @@ var FileConnectorStorage = class {
    */
   async loadIndex() {
     try {
-      const json = await fs16__namespace.readFile(this.indexPath, "utf8");
+      const json = await fs18__namespace.readFile(this.indexPath, "utf8");
       return JSON.parse(json);
     } catch {
       return { connectors: {} };
@@ -38982,8 +40478,8 @@ var FileConnectorStorage = class {
       delete index.connectors[hash];
     }
     const json = JSON.stringify(index, null, 2);
-    await fs16__namespace.writeFile(this.indexPath, json, "utf8");
-    await fs16__namespace.chmod(this.indexPath, 384);
+    await fs18__namespace.writeFile(this.indexPath, json, "utf8");
+    await fs18__namespace.chmod(this.indexPath, 384);
   }
 };
 
@@ -41438,8 +42934,8 @@ function createMessageWithImages(text, imageUrls, role = "user" /* USER */) {
 var execAsync = util.promisify(child_process.exec);
 function cleanupTempFile(filePath) {
   try {
-    if (fs17__namespace.existsSync(filePath)) {
-      fs17__namespace.unlinkSync(filePath);
+    if (fs19__namespace.existsSync(filePath)) {
+      fs19__namespace.unlinkSync(filePath);
     }
   } catch {
   }
@@ -41490,7 +42986,7 @@ async function readClipboardImageMac() {
         end try
       `;
       const { stdout } = await execAsync(`osascript -e '${script}'`);
-      if (stdout.includes("success") || fs17__namespace.existsSync(tempFile)) {
+      if (stdout.includes("success") || fs19__namespace.existsSync(tempFile)) {
         return await convertFileToDataUri(tempFile);
       }
       return {
@@ -41507,14 +43003,14 @@ async function readClipboardImageLinux() {
   try {
     try {
       await execAsync(`xclip -selection clipboard -t image/png -o > "${tempFile}"`);
-      if (fs17__namespace.existsSync(tempFile) && fs17__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 (fs17__namespace.existsSync(tempFile) && fs17__namespace.statSync(tempFile).size > 0) {
+      if (fs19__namespace.existsSync(tempFile) && fs19__namespace.statSync(tempFile).size > 0) {
         return await convertFileToDataUri(tempFile);
       }
     } catch {
@@ -41541,7 +43037,7 @@ async function readClipboardImageWindows() {
       }
     `;
     await execAsync(`powershell -Command "${psScript}"`);
-    if (fs17__namespace.existsSync(tempFile) && fs17__namespace.statSync(tempFile).size > 0) {
+    if (fs19__namespace.existsSync(tempFile) && fs19__namespace.statSync(tempFile).size > 0) {
       return await convertFileToDataUri(tempFile);
     }
     return {
@@ -41554,7 +43050,7 @@ async function readClipboardImageWindows() {
 }
 async function convertFileToDataUri(filePath) {
   try {
-    const imageBuffer = fs17__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";
@@ -41613,186 +43109,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, {
@@ -41828,19 +43144,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,
@@ -41870,6 +43192,8 @@ __export(tools_exports, {
   executeInVM: () => executeInVM,
   executeJavaScript: () => executeJavaScript,
   expandTilde: () => expandTilde,
+  formatAttendees: () => formatAttendees,
+  formatRecipients: () => formatRecipients,
   getAllBuiltInTools: () => getAllBuiltInTools,
   getBackgroundOutput: () => getBackgroundOutput,
   getDesktopDriver: () => getDesktopDriver,
@@ -41880,19 +43204,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,
@@ -42103,7 +43432,7 @@ EXAMPLES:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      if (!fs17.existsSync(resolvedPath)) {
+      if (!fs19.existsSync(resolvedPath)) {
         return {
           success: false,
           error: `File not found: ${file_path}`,
@@ -42111,7 +43440,7 @@ EXAMPLES:
         };
       }
       try {
-        const stats = await fs16.stat(resolvedPath);
+        const stats = await fs18.stat(resolvedPath);
         if (!stats.isFile()) {
           return {
             success: false,
@@ -42153,7 +43482,7 @@ EXAMPLES:
           } catch {
           }
         }
-        const content = await fs16.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);
@@ -42258,13 +43587,13 @@ EXAMPLES:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      const fileExists = fs17.existsSync(resolvedPath);
+      const fileExists = fs19.existsSync(resolvedPath);
       try {
         const parentDir = path2.dirname(resolvedPath);
-        if (!fs17.existsSync(parentDir)) {
-          await fs16.mkdir(parentDir, { recursive: true });
+        if (!fs19.existsSync(parentDir)) {
+          await fs18.mkdir(parentDir, { recursive: true });
         }
-        await fs16.writeFile(resolvedPath, content, "utf-8");
+        await fs18.writeFile(resolvedPath, content, "utf-8");
         return {
           success: true,
           path: file_path,
@@ -42367,7 +43696,7 @@ EXAMPLES:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      if (!fs17.existsSync(resolvedPath)) {
+      if (!fs19.existsSync(resolvedPath)) {
         return {
           success: false,
           error: `File not found: ${file_path}`,
@@ -42375,7 +43704,7 @@ EXAMPLES:
         };
       }
       try {
-        const content = await fs16.readFile(resolvedPath, "utf-8");
+        const content = await fs18.readFile(resolvedPath, "utf-8");
         let occurrences = 0;
         let searchIndex = 0;
         while (true) {
@@ -42414,7 +43743,7 @@ EXAMPLES:
         } else {
           newContent = content.replace(old_string, new_string);
         }
-        await fs16.writeFile(resolvedPath, newContent, "utf-8");
+        await fs18.writeFile(resolvedPath, newContent, "utf-8");
         const diffPreview = generateDiffPreview(old_string, new_string);
         return {
           success: true,
@@ -42470,7 +43799,7 @@ async function findFiles(dir, pattern, baseDir, config, results = [], depth = 0)
     return results;
   }
   try {
-    const entries = await fs16.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);
@@ -42484,7 +43813,7 @@ async function findFiles(dir, pattern, baseDir, config, results = [], depth = 0)
       } else if (entry.isFile()) {
         if (matchGlobPattern(pattern, relativePath)) {
           try {
-            const stats = await fs16.stat(fullPath);
+            const stats = await fs18.stat(fullPath);
             results.push({
               path: relativePath,
               mtime: stats.mtimeMs
@@ -42566,7 +43895,7 @@ WHEN TO USE:
         };
       }
       const resolvedDir = validation.resolvedPath;
-      if (!fs17.existsSync(resolvedDir)) {
+      if (!fs19.existsSync(resolvedDir)) {
         return {
           success: false,
           error: `Directory not found: ${searchDir}`
@@ -42621,7 +43950,7 @@ async function findFilesToSearch(dir, baseDir, config, globPattern, fileType, fi
     return files;
   }
   try {
-    const entries = await fs16.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()) {
@@ -42654,7 +43983,7 @@ async function findFilesToSearch(dir, baseDir, config, globPattern, fileType, fi
 async function searchFile(filePath, regex, contextBefore, contextAfter) {
   const matches = [];
   try {
-    const content = await fs16.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] ?? "";
@@ -42795,7 +44124,7 @@ WHEN TO USE:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      if (!fs17.existsSync(resolvedPath)) {
+      if (!fs19.existsSync(resolvedPath)) {
         return {
           success: false,
           error: `Path not found: ${searchPath}`
@@ -42811,7 +44140,7 @@ WHEN TO USE:
         };
       }
       try {
-        const stats = await fs16.stat(resolvedPath);
+        const stats = await fs18.stat(resolvedPath);
         let filesToSearch;
         if (stats.isFile()) {
           filesToSearch = [resolvedPath];
@@ -42899,7 +44228,7 @@ async function listDir(dir, baseDir, config, recursive, filter, maxDepth = 3, cu
     return entries;
   }
   try {
-    const dirEntries = await fs16.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);
@@ -42917,7 +44246,7 @@ async function listDir(dir, baseDir, config, recursive, filter, maxDepth = 3, cu
       }
       if (filter === "directories" && !isDir) continue;
       try {
-        const stats = await fs16.stat(fullPath);
+        const stats = await fs18.stat(fullPath);
         const dirEntry = {
           name: entry.name,
           path: relativePath,
@@ -43013,14 +44342,14 @@ EXAMPLES:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      if (!fs17.existsSync(resolvedPath)) {
+      if (!fs19.existsSync(resolvedPath)) {
         return {
           success: false,
           error: `Directory not found: ${path6}`
         };
       }
       try {
-        const stats = await fs16.stat(resolvedPath);
+        const stats = await fs18.stat(resolvedPath);
         if (!stats.isDirectory()) {
           return {
             success: false,
@@ -45974,6 +47303,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,
@@ -46789,7 +48952,7 @@ var desktopTools = [
 
 // src/tools/custom-tools/resolveStorage.ts
 init_StorageRegistry();
-function buildStorageContext(toolContext) {
+function buildStorageContext2(toolContext) {
   const global2 = exports.StorageRegistry.getContext();
   if (global2) return global2;
   if (toolContext?.userId) return { userId: toolContext.userId };
@@ -46799,7 +48962,7 @@ function resolveCustomToolStorage(explicit, toolContext) {
   if (explicit) return explicit;
   const factory = exports.StorageRegistry.get("customTools");
   if (factory) {
-    return factory(buildStorageContext(toolContext));
+    return factory(buildStorageContext2(toolContext));
   }
   return new FileCustomToolStorage();
 }
@@ -46827,12 +48990,13 @@ function createCustomToolDelete(storage) {
     permission: { scope: "session", riskLevel: "medium" },
     execute: async (args, context) => {
       try {
+        const userId = context?.userId;
         const s = resolveCustomToolStorage(storage, context);
-        const exists = await s.exists(args.name);
+        const exists = await s.exists(userId, args.name);
         if (!exists) {
           return { success: false, name: args.name, error: `Custom tool '${args.name}' not found` };
         }
-        await s.delete(args.name);
+        await s.delete(userId, args.name);
         return { success: true, name: args.name };
       } catch (error) {
         return { success: false, name: args.name, error: error.message };
@@ -47073,8 +49237,9 @@ function createCustomToolList(storage) {
     },
     permission: { scope: "always", riskLevel: "low" },
     execute: async (args, context) => {
+      const userId = context?.userId;
       const s = resolveCustomToolStorage(storage, context);
-      const tools = await s.list({
+      const tools = await s.list(userId, {
         search: args.search,
         tags: args.tags,
         category: args.category,
@@ -47110,8 +49275,9 @@ function createCustomToolLoad(storage) {
     },
     permission: { scope: "always", riskLevel: "low" },
     execute: async (args, context) => {
+      const userId = context?.userId;
       const s = resolveCustomToolStorage(storage, context);
-      const tool = await s.load(args.name);
+      const tool = await s.load(userId, args.name);
       if (!tool) {
         return { success: false, error: `Custom tool '${args.name}' not found` };
       }
@@ -47183,9 +49349,10 @@ function createCustomToolSave(storage) {
     permission: { scope: "session", riskLevel: "medium" },
     execute: async (args, context) => {
       try {
+        const userId = context?.userId;
         const s = resolveCustomToolStorage(storage, context);
         const now = (/* @__PURE__ */ new Date()).toISOString();
-        const existing = await s.load(args.name);
+        const existing = await s.load(userId, args.name);
         const definition = {
           version: CUSTOM_TOOL_DEFINITION_VERSION,
           name: args.name,
@@ -47204,17 +49371,17 @@ function createCustomToolSave(storage) {
             requiresConnector: (args.connectorNames?.length ?? 0) > 0
           }
         };
-        await s.save(definition);
+        await s.save(userId, definition);
         return {
           success: true,
           name: args.name,
-          storagePath: s.getPath()
+          storagePath: s.getPath(userId)
         };
       } catch (error) {
         return {
           success: false,
           name: args.name,
-          storagePath: resolveCustomToolStorage(storage, context).getPath(),
+          storagePath: resolveCustomToolStorage(storage, context).getPath(context?.userId),
           error: error.message
         };
       }
@@ -48001,7 +50168,9 @@ exports.FileCustomToolStorage = FileCustomToolStorage;
 exports.FileMediaOutputHandler = FileMediaStorage;
 exports.FileMediaStorage = FileMediaStorage;
 exports.FilePersistentInstructionsStorage = FilePersistentInstructionsStorage;
+exports.FileRoutineDefinitionStorage = FileRoutineDefinitionStorage;
 exports.FileStorage = FileStorage;
+exports.FileUserInfoStorage = FileUserInfoStorage;
 exports.FormatDetector = FormatDetector;
 exports.HookManager = HookManager;
 exports.IMAGE_MODELS = IMAGE_MODELS;
@@ -48077,6 +50246,7 @@ exports.ToolPermissionManager = ToolPermissionManager;
 exports.ToolRegistry = ToolRegistry;
 exports.ToolTimeoutError = ToolTimeoutError;
 exports.TruncateCompactor = TruncateCompactor;
+exports.UserInfoPluginNextGen = UserInfoPluginNextGen;
 exports.VENDORS = VENDORS;
 exports.VENDOR_ICON_MAP = VENDOR_ICON_MAP;
 exports.VIDEO_MODELS = VIDEO_MODELS;
@@ -48126,13 +50296,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;
@@ -48140,6 +50315,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;
@@ -48147,8 +50323,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;
@@ -48181,12 +50360,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;
@@ -48213,6 +50395,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;
@@ -48229,6 +50412,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;
@@ -48257,6 +50441,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;
@@ -48272,6 +50457,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;
@@ -48282,6 +50469,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;