@agenticmail/core 0.9.24 → 0.9.25

package/dist/index.cjs

@@ -705,6 +705,746 @@ export default {
   }
 });
 
+// src/memory/text-search.ts
+function stem(word) {
+  if (word.length < 3) return word;
+  let stemmed = word;
+  for (const [pattern, replacement, minLen] of STEM_RULES) {
+    if (stemmed.length >= minLen && pattern.test(stemmed)) {
+      stemmed = stemmed.replace(pattern, replacement);
+      break;
+    }
+  }
+  if (stemmed.length > 2 && DOUBLE_CONSONANT.test(stemmed)) {
+    stemmed = stemmed.slice(0, -1);
+  }
+  return stemmed;
+}
+function tokenize(text) {
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 1 && !STOP_WORDS.has(t)).map(stem);
+}
+var BM25_K1, BM25_B, FIELD_WEIGHT_TITLE, FIELD_WEIGHT_TAGS, FIELD_WEIGHT_CONTENT, PREFIX_MATCH_PENALTY, STOP_WORDS, STEM_RULES, DOUBLE_CONSONANT, MemorySearchIndex;
+var init_text_search = __esm({
+  "src/memory/text-search.ts"() {
+    "use strict";
+    BM25_K1 = 1.2;
+    BM25_B = 0.75;
+    FIELD_WEIGHT_TITLE = 3;
+    FIELD_WEIGHT_TAGS = 2;
+    FIELD_WEIGHT_CONTENT = 1;
+    PREFIX_MATCH_PENALTY = 0.7;
+    STOP_WORDS = /* @__PURE__ */ new Set([
+      "a",
+      "about",
+      "above",
+      "after",
+      "again",
+      "against",
+      "all",
+      "am",
+      "an",
+      "and",
+      "any",
+      "are",
+      "as",
+      "at",
+      "be",
+      "because",
+      "been",
+      "before",
+      "being",
+      "below",
+      "between",
+      "both",
+      "but",
+      "by",
+      "can",
+      "could",
+      "did",
+      "do",
+      "does",
+      "doing",
+      "down",
+      "during",
+      "each",
+      "either",
+      "every",
+      "few",
+      "for",
+      "from",
+      "further",
+      "get",
+      "got",
+      "had",
+      "has",
+      "have",
+      "having",
+      "he",
+      "her",
+      "here",
+      "hers",
+      "herself",
+      "him",
+      "himself",
+      "his",
+      "how",
+      "i",
+      "if",
+      "in",
+      "into",
+      "is",
+      "it",
+      "its",
+      "itself",
+      "just",
+      "may",
+      "me",
+      "might",
+      "more",
+      "most",
+      "must",
+      "my",
+      "myself",
+      "neither",
+      "no",
+      "nor",
+      "not",
+      "now",
+      "of",
+      "off",
+      "on",
+      "once",
+      "only",
+      "or",
+      "other",
+      "ought",
+      "our",
+      "ours",
+      "ourselves",
+      "out",
+      "over",
+      "own",
+      "same",
+      "shall",
+      "she",
+      "should",
+      "so",
+      "some",
+      "such",
+      "than",
+      "that",
+      "the",
+      "their",
+      "theirs",
+      "them",
+      "themselves",
+      "then",
+      "there",
+      "these",
+      "they",
+      "this",
+      "those",
+      "through",
+      "to",
+      "too",
+      "under",
+      "until",
+      "up",
+      "us",
+      "very",
+      "was",
+      "we",
+      "were",
+      "what",
+      "when",
+      "where",
+      "which",
+      "while",
+      "who",
+      "whom",
+      "why",
+      "will",
+      "with",
+      "would",
+      "yet",
+      "you",
+      "your",
+      "yours",
+      "yourself",
+      "yourselves"
+    ]);
+    STEM_RULES = [
+      // Step 1: plurals and past participles
+      [/ies$/, "i", 3],
+      // policies → polici,eries → eri
+      [/sses$/, "ss", 4],
+      // addresses → address
+      [/([^s])s$/, "$1", 3],
+      // items → item, but not "ss"
+      [/eed$/, "ee", 4],
+      // agreed → agree
+      [/ed$/, "", 3],
+      // configured → configur, but min length 3
+      [/ing$/, "", 4],
+      // running → runn → run (handled below)
+      // Step 2: derivational suffixes
+      [/ational$/, "ate", 6],
+      // relational → relate
+      [/tion$/, "t", 5],
+      // adoption → adopt
+      [/ness$/, "", 5],
+      // awareness → aware
+      [/ment$/, "", 5],
+      // deployment → deploy
+      [/able$/, "", 5],
+      // configurable → configur
+      [/ible$/, "", 5],
+      // accessible → access
+      [/ful$/, "", 5],
+      // powerful → power
+      [/ous$/, "", 5],
+      // dangerous → danger
+      [/ive$/, "", 5],
+      // interactive → interact
+      [/ize$/, "", 4],
+      // normalize → normal
+      [/ise$/, "", 4],
+      // organise → organ
+      [/ally$/, "", 5],
+      // automatically → automat
+      [/ly$/, "", 4],
+      // quickly → quick
+      [/er$/, "", 4]
+      // handler → handl
+    ];
+    DOUBLE_CONSONANT = /([^aeiou])\1$/;
+    MemorySearchIndex = class {
+      /** Posting lists: stemmed term → Set of memory IDs containing it */
+      postings = /* @__PURE__ */ new Map();
+      /** Per-document metadata for BM25 scoring */
+      docs = /* @__PURE__ */ new Map();
+      /** Pre-computed IDF values. Stale flag triggers lazy recomputation. */
+      idf = /* @__PURE__ */ new Map();
+      idfStale = true;
+      /** 3-character prefix map for prefix matching: prefix → Set of full stems */
+      prefixMap = /* @__PURE__ */ new Map();
+      /** Total weighted document length (for computing average) */
+      totalWeightedLen = 0;
+      get docCount() {
+        return this.docs.size;
+      }
+      get avgDocLen() {
+        return this.docs.size > 0 ? this.totalWeightedLen / this.docs.size : 1;
+      }
+      /**
+       * Index a memory entry. Extracts stems from title, content, and tags
+       * with field-specific weighting and builds posting lists.
+       */
+      addDocument(id, entry) {
+        if (this.docs.has(id)) this.removeDocument(id);
+        const titleTokens = tokenize(entry.title);
+        const contentTokens = tokenize(entry.content);
+        const tagTokens = entry.tags.flatMap((t) => tokenize(t));
+        const weightedTf = /* @__PURE__ */ new Map();
+        for (const t of titleTokens) weightedTf.set(t, (weightedTf.get(t) || 0) + FIELD_WEIGHT_TITLE);
+        for (const t of tagTokens) weightedTf.set(t, (weightedTf.get(t) || 0) + FIELD_WEIGHT_TAGS);
+        for (const t of contentTokens) weightedTf.set(t, (weightedTf.get(t) || 0) + FIELD_WEIGHT_CONTENT);
+        const weightedLen = titleTokens.length * FIELD_WEIGHT_TITLE + tagTokens.length * FIELD_WEIGHT_TAGS + contentTokens.length * FIELD_WEIGHT_CONTENT;
+        const allStems = /* @__PURE__ */ new Set();
+        for (const t of weightedTf.keys()) allStems.add(t);
+        const stemSequence = [...titleTokens, ...contentTokens];
+        const docRecord = { weightedTf, weightedLen, allStems, stemSequence };
+        this.docs.set(id, docRecord);
+        this.totalWeightedLen += weightedLen;
+        for (const term of allStems) {
+          let posting = this.postings.get(term);
+          if (!posting) {
+            posting = /* @__PURE__ */ new Set();
+            this.postings.set(term, posting);
+          }
+          posting.add(id);
+          if (term.length >= 3) {
+            const prefix = term.slice(0, 3);
+            let prefixSet = this.prefixMap.get(prefix);
+            if (!prefixSet) {
+              prefixSet = /* @__PURE__ */ new Set();
+              this.prefixMap.set(prefix, prefixSet);
+            }
+            prefixSet.add(term);
+          }
+        }
+        this.idfStale = true;
+      }
+      /** Remove a document from the index. */
+      removeDocument(id) {
+        const doc = this.docs.get(id);
+        if (!doc) return;
+        this.totalWeightedLen -= doc.weightedLen;
+        this.docs.delete(id);
+        for (const term of doc.allStems) {
+          const posting = this.postings.get(term);
+          if (posting) {
+            posting.delete(id);
+            if (posting.size === 0) {
+              this.postings.delete(term);
+              if (term.length >= 3) {
+                const prefixSet = this.prefixMap.get(term.slice(0, 3));
+                if (prefixSet) {
+                  prefixSet.delete(term);
+                  if (prefixSet.size === 0) this.prefixMap.delete(term.slice(0, 3));
+                }
+              }
+            }
+          }
+        }
+        this.idfStale = true;
+      }
+      /** Recompute IDF values for all terms. Called lazily before search. */
+      refreshIdf() {
+        if (!this.idfStale) return;
+        const N = this.docs.size;
+        this.idf.clear();
+        for (const [term, posting] of this.postings) {
+          const df = posting.size;
+          this.idf.set(term, Math.log((N - df + 0.5) / (df + 0.5) + 1));
+        }
+        this.idfStale = false;
+      }
+      /**
+       * Expand query terms with prefix matches.
+       * "deploy" → ["deploy", "deployment", "deploying", ...] (if they exist in the index)
+       */
+      expandQueryTerms(queryStems) {
+        const expanded = /* @__PURE__ */ new Map();
+        for (const qs of queryStems) {
+          if (this.postings.has(qs)) {
+            expanded.set(qs, Math.max(expanded.get(qs) || 0, 1));
+          }
+          if (qs.length >= 3) {
+            const prefix = qs.slice(0, 3);
+            const candidates = this.prefixMap.get(prefix);
+            if (candidates) {
+              for (const candidate of candidates) {
+                if (candidate !== qs && candidate.startsWith(qs)) {
+                  expanded.set(candidate, Math.max(expanded.get(candidate) || 0, PREFIX_MATCH_PENALTY));
+                }
+              }
+            }
+          }
+        }
+        return expanded;
+      }
+      /**
+       * Compute bigram proximity boost: if two query terms appear adjacent
+       * in the document's stem sequence, boost the score.
+       */
+      bigramProximityBoost(docId, queryStems) {
+        if (queryStems.length < 2) return 0;
+        const doc = this.docs.get(docId);
+        if (!doc || doc.stemSequence.length < 2) return 0;
+        let boost = 0;
+        const seq = doc.stemSequence;
+        const querySet = new Set(queryStems);
+        for (let i = 0; i < seq.length - 1; i++) {
+          if (querySet.has(seq[i]) && querySet.has(seq[i + 1]) && seq[i] !== seq[i + 1]) {
+            boost += 0.5;
+          }
+        }
+        return Math.min(boost, 2);
+      }
+      /**
+       * Search the index for documents matching a query.
+       * Returns scored results sorted by BM25F relevance.
+       *
+       * @param query - Raw query string
+       * @param candidateIds - Optional: only score these document IDs (for agent-scoped search)
+       * @returns Array of { id, score } sorted by descending score
+       */
+      search(query, candidateIds) {
+        const queryStems = tokenize(query);
+        if (queryStems.length === 0) return [];
+        this.refreshIdf();
+        const expandedTerms = this.expandQueryTerms(queryStems);
+        if (expandedTerms.size === 0) return [];
+        const avgDl = this.avgDocLen;
+        const candidates = /* @__PURE__ */ new Set();
+        for (const term of expandedTerms.keys()) {
+          const posting = this.postings.get(term);
+          if (posting) {
+            for (const docId of posting) {
+              if (!candidateIds || candidateIds.has(docId)) candidates.add(docId);
+            }
+          }
+        }
+        const results = [];
+        for (const docId of candidates) {
+          const doc = this.docs.get(docId);
+          if (!doc) continue;
+          let score = 0;
+          for (const [term, weight] of expandedTerms) {
+            const tf = doc.weightedTf.get(term) || 0;
+            if (tf === 0) continue;
+            const termIdf = this.idf.get(term) || 0;
+            const numerator = tf * (BM25_K1 + 1);
+            const denominator = tf + BM25_K1 * (1 - BM25_B + BM25_B * (doc.weightedLen / avgDl));
+            score += termIdf * (numerator / denominator) * weight;
+          }
+          score += this.bigramProximityBoost(docId, queryStems);
+          if (score > 0) results.push({ id: docId, score });
+        }
+        results.sort((a, b) => b.score - a.score);
+        return results;
+      }
+      /** Check if a document exists in the index. */
+      has(id) {
+        return this.docs.has(id);
+      }
+    };
+  }
+});
+
+// src/skills/registry.ts
+function builtInDir() {
+  const here = (0, import_node_path5.dirname)((0, import_node_url.fileURLToPath)(import_meta2.url));
+  return (0, import_node_path5.join)(here, "built-in");
+}
+function userDir() {
+  const dir2 = (0, import_node_path5.join)((0, import_node_os4.homedir)(), ".agenticmail", "skills");
+  try {
+    if (!(0, import_node_fs4.existsSync)(dir2)) (0, import_node_fs4.mkdirSync)(dir2, { recursive: true });
+  } catch {
+  }
+  return dir2;
+}
+function skillToIndexDoc(s) {
+  const contentParts = [
+    s.description,
+    s.context?.when_to_use ?? "",
+    ...s.principles ?? [],
+    ...Object.values(s.phrases ?? {}),
+    ...(s.tactics ?? []).flatMap((t) => [t.name, t.when, t.script]),
+    ...s.success_signals ?? [],
+    ...s.failure_signals ?? []
+  ];
+  return {
+    title: s.name,
+    // Include category as a tag for free — a query of "negotiation"
+    // hits both literal `negotiation`-category skills AND skills
+    // that tagged themselves "negotiation".
+    tags: [...s.tags ?? [], s.category],
+    content: contentParts.filter(Boolean).join(" ")
+  };
+}
+function loadAllSkillsFromDisk() {
+  const all = /* @__PURE__ */ new Map();
+  const dirs = [builtInDir(), userDir()];
+  for (const dir2 of dirs) {
+    if (!(0, import_node_fs4.existsSync)(dir2)) continue;
+    let entries;
+    try {
+      entries = (0, import_node_fs4.readdirSync)(dir2);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".json")) continue;
+      const fullPath = (0, import_node_path5.join)(dir2, entry);
+      try {
+        const st = (0, import_node_fs4.statSync)(fullPath);
+        if (!st.isFile()) continue;
+        const raw = (0, import_node_fs4.readFileSync)(fullPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const errors = validateSkill(parsed);
+        if (errors.length > 0) {
+          console.warn(`[skills] ${entry} invalid, skipping: ${errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
+          continue;
+        }
+        all.set(parsed.id, parsed);
+      } catch (err) {
+        console.warn(`[skills] could not load ${fullPath}: ${err.message}`);
+      }
+    }
+  }
+  return all;
+}
+function ensureLoaded() {
+  const now = Date.now();
+  if (cache.byId && cache.index && now - cache.ts < CACHE_TTL_MS) {
+    return { byId: cache.byId, index: cache.index };
+  }
+  const fresh = loadAllSkillsFromDisk();
+  const index = new MemorySearchIndex();
+  for (const [id, skill] of fresh) {
+    try {
+      index.addDocument(id, skillToIndexDoc(skill));
+    } catch {
+    }
+  }
+  cache.byId = fresh;
+  cache.index = index;
+  cache.ts = now;
+  return { byId: fresh, index };
+}
+function invalidateSkillCache() {
+  cache.byId = null;
+  cache.index = null;
+  cache.ts = 0;
+}
+function validateSkill(s) {
+  const errs = [];
+  if (!s || typeof s !== "object" || Array.isArray(s)) {
+    return [{ path: "$", message: "skill must be a JSON object" }];
+  }
+  const sk = s;
+  const requireString = (key, minLen = 1) => {
+    const v = sk[key];
+    if (typeof v !== "string" || v.length < minLen) {
+      errs.push({ path: key, message: `must be a non-empty string` });
+    }
+  };
+  const requireArray = (key, minLen = 1) => {
+    const v = sk[key];
+    if (!Array.isArray(v) || v.length < minLen) {
+      errs.push({ path: key, message: `must be a non-empty array` });
+    }
+  };
+  requireString("id");
+  if (typeof sk.id === "string" && !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(sk.id)) {
+    errs.push({ path: "id", message: "must be lowercase-hyphenated slug (a-z, 0-9, -)" });
+  }
+  requireString("name");
+  requireString("version");
+  requireString("description");
+  requireString("category");
+  const validCategories = [
+    "negotiation",
+    "customer-service",
+    "reservations",
+    "medical-admin",
+    "legal-admin",
+    "finance-admin",
+    "real-estate",
+    "travel",
+    "subscription",
+    "home-services",
+    "social",
+    "civic",
+    "employment",
+    "debt-collection",
+    "other"
+  ];
+  if (typeof sk.category === "string" && !validCategories.includes(sk.category)) {
+    errs.push({ path: "category", message: `unknown category "${sk.category}"; must be one of: ${validCategories.join(", ")}` });
+  }
+  if (!Array.isArray(sk.tags)) errs.push({ path: "tags", message: "must be an array of strings" });
+  if (sk.disclaimer !== null && typeof sk.disclaimer !== "string") {
+    errs.push({ path: "disclaimer", message: "must be a string or null" });
+  }
+  if (!sk.context || typeof sk.context !== "object") {
+    errs.push({ path: "context", message: "must be an object" });
+  } else {
+    const ctx = sk.context;
+    if (typeof ctx.when_to_use !== "string") errs.push({ path: "context.when_to_use", message: "must be a string" });
+    if (!Array.isArray(ctx.preconditions)) errs.push({ path: "context.preconditions", message: "must be an array" });
+    if (typeof ctx.estimated_call_duration_minutes !== "number") errs.push({ path: "context.estimated_call_duration_minutes", message: "must be a number" });
+  }
+  requireArray("principles", 2);
+  if (!sk.phrases || typeof sk.phrases !== "object") errs.push({ path: "phrases", message: "must be an object of {key: phrase}" });
+  if (!Array.isArray(sk.tactics) || sk.tactics.length === 0) {
+    errs.push({ path: "tactics", message: "must be a non-empty array" });
+  } else {
+    sk.tactics.forEach((t, i) => {
+      if (!t || typeof t !== "object") {
+        errs.push({ path: `tactics[${i}]`, message: "must be an object" });
+        return;
+      }
+      const tactic = t;
+      if (typeof tactic.name !== "string") errs.push({ path: `tactics[${i}].name`, message: "must be a string" });
+      if (typeof tactic.when !== "string") errs.push({ path: `tactics[${i}].when`, message: "must be a string" });
+      if (typeof tactic.script !== "string" || tactic.script.length < 5) {
+        errs.push({ path: `tactics[${i}].script`, message: "must be a non-empty string (>= 5 chars)" });
+      }
+    });
+  }
+  requireArray("boundaries", 1);
+  if (!Array.isArray(sk.success_signals)) errs.push({ path: "success_signals", message: "must be an array" });
+  if (!Array.isArray(sk.failure_signals)) errs.push({ path: "failure_signals", message: "must be an array" });
+  if (!sk.exit_strategy || typeof sk.exit_strategy !== "object") {
+    errs.push({ path: "exit_strategy", message: "must be an object" });
+  } else {
+    const xs = sk.exit_strategy;
+    if (typeof xs.on_success !== "string") errs.push({ path: "exit_strategy.on_success", message: "must be a string" });
+    if (typeof xs.on_failure !== "string") errs.push({ path: "exit_strategy.on_failure", message: "must be a string" });
+  }
+  if (!Array.isArray(sk.required_user_info)) errs.push({ path: "required_user_info", message: "must be an array" });
+  if (typeof sk.contributed_by !== "string") errs.push({ path: "contributed_by", message: "must be a string" });
+  return errs;
+}
+function summarize(s) {
+  return {
+    id: s.id,
+    name: s.name,
+    category: s.category,
+    tags: s.tags,
+    description: s.description,
+    version: s.version,
+    disclaimer_required: !!s.disclaimer,
+    estimated_call_duration_minutes: s.context.estimated_call_duration_minutes
+  };
+}
+function listSkills(opts = {}) {
+  const all = Array.from(ensureLoaded().byId.values());
+  const filtered = all.filter((s) => {
+    if (opts.category && s.category !== opts.category) return false;
+    if (opts.tag && !s.tags.includes(opts.tag.toLowerCase())) return false;
+    return true;
+  });
+  return filtered.sort((a, b) => a.name.localeCompare(b.name)).map(summarize);
+}
+function searchSkills(query, limit = 20) {
+  const q = query.trim();
+  if (!q) return [];
+  const { byId, index } = ensureLoaded();
+  const ranked = index.search(q);
+  if (ranked.length === 0) {
+    const qLow = q.toLowerCase();
+    const fallback = [];
+    for (const s of byId.values()) {
+      if (s.id.toLowerCase().includes(qLow) || s.name.toLowerCase().includes(qLow) || s.tags.some((t) => t.toLowerCase().includes(qLow))) {
+        fallback.push(summarize(s));
+        if (fallback.length >= limit) break;
+      }
+    }
+    return fallback;
+  }
+  const out = [];
+  for (const { id } of ranked) {
+    const skill = byId.get(id);
+    if (!skill) continue;
+    out.push(summarize(skill));
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+function loadSkill(id) {
+  return ensureLoaded().byId.get(id) ?? null;
+}
+function saveUserSkill(skill) {
+  const errors = validateSkill(skill);
+  if (errors.length > 0) {
+    throw new Error(`skill validation failed: ${errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
+  }
+  const dir2 = userDir();
+  const path2 = (0, import_node_path5.join)(dir2, `${skill.id}.json`);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const out = {
+    ...skill,
+    created_at: skill.created_at ?? now,
+    updated_at: now
+  };
+  (0, import_node_fs4.writeFileSync)(path2, JSON.stringify(out, null, 2), "utf-8");
+  invalidateSkillCache();
+  return { path: path2 };
+}
+function skillFilename(id) {
+  return `${(0, import_node_path5.basename)(id)}.json`;
+}
+function userSkillsDir() {
+  return userDir();
+}
+var import_node_fs4, import_node_path5, import_node_url, import_node_os4, import_meta2, cache, CACHE_TTL_MS;
+var init_registry = __esm({
+  "src/skills/registry.ts"() {
+    "use strict";
+    import_node_fs4 = require("fs");
+    import_node_path5 = require("path");
+    import_node_url = require("url");
+    import_node_os4 = require("os");
+    init_text_search();
+    import_meta2 = {};
+    cache = { ts: 0, byId: null, index: null };
+    CACHE_TTL_MS = 5e3;
+  }
+});
+
+// src/skills/index.ts
+var skills_exports = {};
+__export(skills_exports, {
+  invalidateSkillCache: () => invalidateSkillCache,
+  listSkills: () => listSkills,
+  loadSkill: () => loadSkill,
+  renderSkillAsPrompt: () => renderSkillAsPrompt,
+  saveUserSkill: () => saveUserSkill,
+  searchSkills: () => searchSkills,
+  skillFilename: () => skillFilename,
+  userSkillsDir: () => userSkillsDir,
+  validateSkill: () => validateSkill
+});
+function renderSkillAsPrompt(skill) {
+  const lines = [];
+  lines.push(`=== SKILL LOADED: ${skill.name} (v${skill.version}) ===`);
+  lines.push(`Category: ${skill.category}    Tags: ${skill.tags.join(", ")}`);
+  lines.push("");
+  lines.push(skill.description);
+  lines.push("");
+  if (skill.disclaimer) {
+    lines.push("REQUIRED DISCLAIMER (recite at start of the substantive turn):");
+    lines.push(`  "${skill.disclaimer}"`);
+    lines.push("");
+  }
+  lines.push("WHEN TO USE THIS:");
+  lines.push(`  ${skill.context.when_to_use}`);
+  if (skill.context.preconditions.length > 0) {
+    lines.push("Preconditions:");
+    for (const p of skill.context.preconditions) lines.push(`  - ${p}`);
+  }
+  lines.push("");
+  lines.push("PRINCIPLES:");
+  for (const p of skill.principles) lines.push(`  - ${p}`);
+  lines.push("");
+  if (Object.keys(skill.phrases).length > 0) {
+    lines.push("PHRASES (paraphrase to match your voice; keep the structural move):");
+    for (const [k, v] of Object.entries(skill.phrases)) lines.push(`  [${k}] "${v}"`);
+    lines.push("");
+  }
+  if (skill.tactics.length > 0) {
+    lines.push("TACTICS (try in order; fall back to next on failure):");
+    skill.tactics.forEach((t, i) => {
+      lines.push(`  ${i + 1}. ${t.name}`);
+      lines.push(`     When: ${t.when}`);
+      lines.push(`     Script: "${t.script}"`);
+    });
+    lines.push("");
+  }
+  if (skill.boundaries.length > 0) {
+    lines.push("HARD BOUNDARIES \u2014 do not cross:");
+    for (const b of skill.boundaries) lines.push(`  - ${b}`);
+    lines.push("");
+  }
+  lines.push("SUCCESS SIGNALS:");
+  for (const s of skill.success_signals) lines.push(`  - ${s}`);
+  lines.push("");
+  lines.push("FAILURE SIGNALS \u2014 when these appear, escalate or exit:");
+  for (const s of skill.failure_signals) lines.push(`  - ${s}`);
+  lines.push("");
+  lines.push("EXIT:");
+  lines.push(`  On success: ${skill.exit_strategy.on_success}`);
+  lines.push(`  On failure: ${skill.exit_strategy.on_failure}`);
+  if (skill.exit_strategy.follow_ups && skill.exit_strategy.follow_ups.length > 0) {
+    lines.push("  Follow-ups (after the call):");
+    for (const f of skill.exit_strategy.follow_ups) lines.push(`    - ${f}`);
+  }
+  lines.push("");
+  lines.push("=== END SKILL ===");
+  return lines.join("\n");
+}
+var init_skills = __esm({
+  "src/skills/index.ts"() {
+    "use strict";
+    init_registry();
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -736,6 +1476,7 @@ __export(index_exports, {
   GET_DATETIME_TOOL: () => GET_DATETIME_TOOL,
   GatewayManager: () => GatewayManager,
   InboxWatcher: () => InboxWatcher,
+  LOAD_SKILL_TOOL: () => LOAD_SKILL_TOOL,
   MEMORY_CATEGORIES: () => MEMORY_CATEGORIES,
   MailReceiver: () => MailReceiver,
   MailSender: () => MailSender,
@@ -772,6 +1513,7 @@ __export(index_exports, {
   RelayBridge: () => RelayBridge,
   RelayGateway: () => RelayGateway,
   SEARCH_EMAIL_TOOL: () => SEARCH_EMAIL_TOOL,
+  SEARCH_SKILLS_TOOL: () => SEARCH_SKILLS_TOOL,
   SPAM_THRESHOLD: () => SPAM_THRESHOLD,
   ServiceManager: () => ServiceManager,
   SetupManager: () => SetupManager,
@@ -9669,12 +10411,46 @@ var SEARCH_EMAIL_TOOL = {
     additionalProperties: false
   }
 };
+var SEARCH_SKILLS_TOOL = {
+  type: "function",
+  name: "search_skills",
+  description: "Search your skill library for a playbook that fits the situation you just hit on this call (billing dispute, debt collector tactics, reservation deadlock, etc). Returns ranked summaries \u2014 pick the best match and pass its id to load_skill. Fast.",
+  parameters: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: 'Plain-language description of the situation, e.g. "rep insists on a commitment date", "the restaurant is fully booked", "I need to dispute a recurring charge after cancellation".'
+      }
+    },
+    required: ["query"],
+    additionalProperties: false
+  }
+};
+var LOAD_SKILL_TOOL = {
+  type: "function",
+  name: "load_skill",
+  description: 'Load a skill playbook by id into your context for the rest of this call. The playbook (principles, scripted phrases, ordered tactics, hard boundaries, exit strategy) grounds your next turns. Always call search_skills first to find the right id. Before calling, say "hold on one moment" \u2014 loading is briefer than `ask_operator` but takes a beat.',
+  parameters: {
+    type: "object",
+    properties: {
+      id: {
+        type: "string",
+        description: 'Skill id (lowercase-hyphenated), e.g. "negotiate-bill-reduction". Get it from search_skills.'
+      }
+    },
+    required: ["id"],
+    additionalProperties: false
+  }
+};
 var REALTIME_TOOL_DEFINITIONS = {
   ask_operator: ASK_OPERATOR_TOOL,
   web_search: WEB_SEARCH_TOOL,
   recall_memory: RECALL_MEMORY_TOOL,
   get_datetime: GET_DATETIME_TOOL,
-  search_email: SEARCH_EMAIL_TOOL
+  search_email: SEARCH_EMAIL_TOOL,
+  search_skills: SEARCH_SKILLS_TOOL,
+  load_skill: LOAD_SKILL_TOOL
 };
 function buildRealtimeToolGuidance(tools) {
   if (tools.length === 0) return "";
@@ -9693,6 +10469,16 @@ function buildRealtimeToolGuidance(tools) {
       'The lookup tools (web_search, recall_memory, get_datetime, search_email) return in seconds \u2014 a brief "one moment" is plenty; no long hold is needed for these.'
     );
   }
+  if (names.has("search_skills") && names.has("load_skill")) {
+    lines.push(
+      `Your SKILL LIBRARY contains playbooks for specific real-world phone situations \u2014 bill negotiation, debt-collector handling, restaurant booking, dispute filing, etc. Each playbook is a complete set of principles, scripted phrases, ordered tactics, boundaries, and exit strategy for that one situation. When you find yourself on the call without a clear next move \u2014 the rep brought up something you do not know how to handle, the conversation reached a stage that needs a specific tactic \u2014 load a skill instead of improvising:
+  1. Tell the caller you need a moment: "Hold on one moment \u2014 let me check something."
+  2. Call search_skills with a one-line description of the situation.
+  3. Call load_skill with the id of the best match.
+  4. Resume the call grounded in the playbook the load returned. Follow the playbook's tactic order, use its scripted phrases (paraphrased to match your voice), respect its hard boundaries, watch for its success / failure signals.
+A skill's rendered playbook is now part of your instructions for the rest of the call. You can load a second skill if a new situation comes up \u2014 but the model keeps a max of two loaded; a third load drops the oldest. Pick skills deliberately.`
+    );
+  }
   return lines.join("\n");
 }
 function toolErrorText(err) {
@@ -9878,6 +10664,7 @@ var REALTIME_AUDIO_SAMPLE_RATE = 24e3;
 var REALTIME_MAX_AUDIO_FRAME_BASE64 = 256 * 1024;
 var MAX_PENDING_AUDIO_FRAMES = 200;
 var REALTIME_TOOL_CALL_TIMEOUT_MS = 6 * 6e4;
+var MAX_LOADED_SKILLS = 2;
 var MAX_IN_FLIGHT_TOOL_CALLS = 8;
 var DEFAULT_PERSONA = "You are a helpful, professional voice assistant making a phone call on behalf of your operator. Speak naturally and concisely, the way a person would on a real call. Listen carefully, do not talk over the other party, and keep each turn short. Never invent facts; if you do not know something, say so. Do not reveal that you are an AI unless you are asked directly.";
 function buildRealtimeInstructions(opts) {
@@ -9969,6 +10756,26 @@ var RealtimeVoiceBridge = class {
   toolCallNames = /* @__PURE__ */ new Map();
   /** `call_id`s whose tool call is currently executing. */
   inFlightToolCalls = /* @__PURE__ */ new Set();
+  /**
+   * Mid-call skills loaded into the session so far, FIFO. Earliest at
+   * index 0; cap at {@link MAX_LOADED_SKILLS}. When a (cap+1)th skill
+   * is loaded the oldest one drops out — the model can't usefully
+   * hold five playbooks in working memory at once, so we keep the
+   * working set narrow on purpose.
+   */
+  loadedSkills = [];
+  /**
+   * The original `instructions` string from the session.update sent at
+   * open. We keep a private copy because every mid-call skill load
+   * issues a fresh `session.update` whose `instructions` is built as:
+   *
+   *     baseInstructions + "\n\n" + renderedSkill1 + "\n\n" + renderedSkill2 …
+   *
+   * Without this snapshot, successive loads would compound — the second
+   * load would see "base + skill1" as the base and append skill2 to
+   * THAT, eventually drifting unboundedly.
+   */
+  baseInstructions = "";
   constructor(opts) {
     const carrier = opts.carrier ?? opts.elks;
     if (!carrier) {
@@ -10005,6 +10812,10 @@ var RealtimeVoiceBridge = class {
   handleOpenAIOpen() {
     if (this.ended || this.openaiReady) return;
     this.openaiReady = true;
+    const sess = this.sessionConfig?.session;
+    if (sess && typeof sess.instructions === "string") {
+      this.baseInstructions = sess.instructions;
+    }
     this.safeSend(this.openai, this.sessionConfig);
     this.safeSend(this.openai, { type: "response.create" });
     for (const audio of this.pendingAudio.splice(0)) {
@@ -10015,6 +10826,74 @@ var RealtimeVoiceBridge = class {
   handleOpenAIClose() {
     this.end("openai-closed");
   }
+  /**
+   * Load a skill playbook into the live OpenAI Realtime session for
+   * the rest of the call.
+   *
+   * Mechanics:
+   *   1. Resolve the skill JSON via the skills registry (file on disk).
+   *   2. Append the rendered skill text to the agent's working
+   *      instructions and re-send a `session.update` carrying ONLY
+   *      the new `instructions` field. The OpenAI Realtime API
+   *      supports partial session.update — we don't have to re-send
+   *      audio config, tools, voice, etc.
+   *   3. Track which skills are loaded so we (a) FIFO-evict the
+   *      oldest when the cap is hit and (b) include every still-
+   *      loaded skill in the next composed instructions.
+   *   4. Emit a transcript marker so the mission record shows the
+   *      adaptation ("[skill loaded: Negotiate a Bill Reduction
+   *      v1.0.0]"). Useful for post-call review and for the build
+   *      farm's telemetry on which skills actually got reached for.
+   *
+   * Returns an object the {@link load_skill} tool handler can serialise
+   * back to the model: `ok: true` plus the skill name + version on
+   * success, `ok: false` plus a short reason on failure (unknown id,
+   * call ended, registry I/O error). Never throws — a buggy registry
+   * or a missing file must not crash the bridge mid-call.
+   *
+   * Phase 2 of the skill library (`docs/skill-library-plan.md`).
+   */
+  async loadSkillIntoSession(skillId) {
+    if (this.ended) return { ok: false, message: "Call has already ended; cannot load a skill now." };
+    if (!this.openaiReady) return { ok: false, message: "Session is not ready yet; try again in a moment." };
+    if (this.loadedSkills.some((s) => s.id === skillId)) {
+      const existing = this.loadedSkills.find((s) => s.id === skillId);
+      return { ok: true, message: `Skill "${skillId}" is already loaded.`, name: skillId, version: existing.version };
+    }
+    let loadSkill2;
+    let renderSkillAsPrompt2;
+    try {
+      ({ loadSkill: loadSkill2, renderSkillAsPrompt: renderSkillAsPrompt2 } = await Promise.resolve().then(() => (init_skills(), skills_exports)));
+    } catch (err) {
+      return { ok: false, message: `Skill registry unavailable: ${errorText(err)}` };
+    }
+    const skill = loadSkill2(skillId);
+    if (!skill) {
+      return { ok: false, message: `No skill found with id "${skillId}". Call search_skills first to find the right id.` };
+    }
+    const rendered = renderSkillAsPrompt2(skill);
+    while (this.loadedSkills.length >= MAX_LOADED_SKILLS) {
+      const dropped = this.loadedSkills.shift();
+      if (dropped) {
+        this.emitTranscript("system", `[skill unloaded for working-memory limit: ${dropped.id} v${dropped.version}]`);
+      }
+    }
+    this.loadedSkills.push({ id: skill.id, version: skill.version, renderedPrompt: rendered });
+    const composed = [
+      this.baseInstructions,
+      ...this.loadedSkills.map((s) => s.renderedPrompt)
+    ].filter((s) => s && s.length > 0).join("\n\n");
+    this.safeSend(this.openai, {
+      type: "session.update",
+      session: { instructions: composed }
+    });
+    this.emitTranscript("system", `[skill loaded: ${skill.name} v${skill.version}]`);
+    return { ok: true, message: `Loaded skill: ${skill.name} (v${skill.version})`, name: skill.name, version: skill.version };
+  }
+  /** The list of skills currently loaded into the session (FIFO-ordered). */
+  get loadedSkillIds() {
+    return this.loadedSkills.map((s) => s.id);
+  }
   /** Call when the OpenAI socket errors. */
   handleOpenAIError(err) {
     this.emitTranscript("system", `OpenAI Realtime error: ${errorText(err)}`);
@@ -10475,7 +11354,7 @@ try {
 }
 
 // src/util/safe-path.ts
-var import_node_path5 = require("path");
+var import_node_path6 = require("path");
 var PathTraversalError = class extends Error {
   constructor(baseDir, parts) {
     super(
@@ -10498,14 +11377,14 @@ function safeJoin(baseDir, ...partsAndOpts) {
   }
   if (!opts.allowAbsolute) {
     for (const part of parts) {
-      if ((0, import_node_path5.isAbsolute)(part)) {
+      if ((0, import_node_path6.isAbsolute)(part)) {
         throw new PathTraversalError(baseDir, parts);
       }
     }
   }
-  const resolvedBase = (0, import_node_path5.resolve)(baseDir);
-  const resolved = (0, import_node_path5.resolve)(resolvedBase, ...parts);
-  if (resolved !== resolvedBase && !resolved.startsWith(resolvedBase + import_node_path5.sep)) {
+  const resolvedBase = (0, import_node_path6.resolve)(baseDir);
+  const resolved = (0, import_node_path6.resolve)(resolvedBase, ...parts);
+  if (resolved !== resolvedBase && !resolved.startsWith(resolvedBase + import_node_path6.sep)) {
     throw new PathTraversalError(baseDir, parts);
   }
   return resolved;
@@ -10519,9 +11398,9 @@ function tryJoin(baseDir, ...parts) {
   }
 }
 function assertWithinBase(baseDir, candidate) {
-  const resolvedBase = (0, import_node_path5.resolve)(baseDir);
-  const resolvedCandidate = (0, import_node_path5.resolve)(candidate);
-  if (resolvedCandidate !== resolvedBase && !resolvedCandidate.startsWith(resolvedBase + import_node_path5.sep)) {
+  const resolvedBase = (0, import_node_path6.resolve)(baseDir);
+  const resolvedCandidate = (0, import_node_path6.resolve)(candidate);
+  if (resolvedCandidate !== resolvedBase && !resolvedCandidate.startsWith(resolvedBase + import_node_path6.sep)) {
     throw new PathTraversalError(baseDir, [candidate]);
   }
   return resolvedCandidate;
@@ -10574,19 +11453,19 @@ function redactObject(input, _depth = 0) {
 }
 
 // src/operator-prefs.ts
-var import_node_fs4 = require("fs");
-var import_node_os4 = require("os");
-var import_node_path6 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_os5 = require("os");
+var import_node_path7 = require("path");
 function dir() {
-  return (0, import_node_path6.join)((0, import_node_os4.homedir)(), ".agenticmail");
+  return (0, import_node_path7.join)((0, import_node_os5.homedir)(), ".agenticmail");
 }
 function path() {
-  return (0, import_node_path6.join)(dir(), "operator-prefs.json");
+  return (0, import_node_path7.join)(dir(), "operator-prefs.json");
 }
 function readFile() {
-  if (!(0, import_node_fs4.existsSync)(path())) return { version: 1 };
+  if (!(0, import_node_fs5.existsSync)(path())) return { version: 1 };
   try {
-    const raw = (0, import_node_fs4.readFileSync)(path(), "utf-8");
+    const raw = (0, import_node_fs5.readFileSync)(path(), "utf-8");
     if (!raw.trim()) return { version: 1 };
     const parsed = JSON.parse(raw);
     return { version: 1, operatorEmail: typeof parsed.operatorEmail === "string" ? parsed.operatorEmail : void 0 };
@@ -10597,10 +11476,10 @@ function readFile() {
 function writeFile(shape) {
   const d = dir();
   const p = path();
-  if (!(0, import_node_fs4.existsSync)(d)) (0, import_node_fs4.mkdirSync)(d, { recursive: true });
+  if (!(0, import_node_fs5.existsSync)(d)) (0, import_node_fs5.mkdirSync)(d, { recursive: true });
   const tmp = `${p}.agenticmail-tmp-${process.pid}`;
-  (0, import_node_fs4.writeFileSync)(tmp, JSON.stringify(shape, null, 2), "utf-8");
-  (0, import_node_fs4.renameSync)(tmp, p);
+  (0, import_node_fs5.writeFileSync)(tmp, JSON.stringify(shape, null, 2), "utf-8");
+  (0, import_node_fs5.renameSync)(tmp, p);
 }
 function getOperatorEmail() {
   const shape = readFile();
@@ -10629,21 +11508,21 @@ function operatorPrefsStoragePath() {
 }
 
 // src/host-sessions.ts
-var import_node_fs5 = require("fs");
-var import_node_path7 = require("path");
-var import_node_os5 = require("os");
+var import_node_fs6 = require("fs");
+var import_node_path8 = require("path");
+var import_node_os6 = require("os");
 function storageDir() {
-  return (0, import_node_path7.join)((0, import_node_os5.homedir)(), ".agenticmail");
+  return (0, import_node_path8.join)((0, import_node_os6.homedir)(), ".agenticmail");
 }
 function storagePath() {
-  return (0, import_node_path7.join)(storageDir(), "host-sessions.json");
+  return (0, import_node_path8.join)(storageDir(), "host-sessions.json");
 }
 var DEFAULT_SESSION_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 function readFile2() {
   const p = storagePath();
-  if (!(0, import_node_fs5.existsSync)(p)) return { version: 1, sessions: {} };
+  if (!(0, import_node_fs6.existsSync)(p)) return { version: 1, sessions: {} };
   try {
-    const raw = (0, import_node_fs5.readFileSync)(p, "utf-8");
+    const raw = (0, import_node_fs6.readFileSync)(p, "utf-8");
     if (!raw.trim()) return { version: 1, sessions: {} };
     const parsed = JSON.parse(raw);
     return {
@@ -10657,10 +11536,10 @@ function readFile2() {
 function writeFile2(shape) {
   const dir2 = storageDir();
   const p = storagePath();
-  if (!(0, import_node_fs5.existsSync)(dir2)) (0, import_node_fs5.mkdirSync)(dir2, { recursive: true });
+  if (!(0, import_node_fs6.existsSync)(dir2)) (0, import_node_fs6.mkdirSync)(dir2, { recursive: true });
   const tmp = `${p}.agenticmail-tmp-${process.pid}`;
-  (0, import_node_fs5.writeFileSync)(tmp, JSON.stringify(shape, null, 2), "utf-8");
-  (0, import_node_fs5.renameSync)(tmp, p);
+  (0, import_node_fs6.writeFileSync)(tmp, JSON.stringify(shape, null, 2), "utf-8");
+  (0, import_node_fs6.renameSync)(tmp, p);
 }
 function saveHostSession(host, session) {
   if (!session.sessionId) return;
@@ -10835,15 +11714,15 @@ function buildApiUrl(baseOrigin, pathAndQuery) {
 
 // src/setup/index.ts
 var import_node_crypto6 = require("crypto");
-var import_node_fs9 = require("fs");
-var import_node_path11 = require("path");
-var import_node_os9 = require("os");
+var import_node_fs10 = require("fs");
+var import_node_path12 = require("path");
+var import_node_os10 = require("os");
 
 // src/setup/deps.ts
 var import_node_child_process2 = require("child_process");
-var import_node_fs6 = require("fs");
-var import_node_path8 = require("path");
-var import_node_os6 = require("os");
+var import_node_fs7 = require("fs");
+var import_node_path9 = require("path");
+var import_node_os7 = require("os");
 var DependencyChecker = class {
   async checkAll() {
     return Promise.all([
@@ -10893,8 +11772,8 @@ var DependencyChecker = class {
     }
   }
   async checkCloudflared() {
-    const binPath = (0, import_node_path8.join)((0, import_node_os6.homedir)(), ".agenticmail", "bin", "cloudflared");
-    if ((0, import_node_fs6.existsSync)(binPath)) {
+    const binPath = (0, import_node_path9.join)((0, import_node_os7.homedir)(), ".agenticmail", "bin", "cloudflared");
+    if ((0, import_node_fs7.existsSync)(binPath)) {
       let version;
       try {
         const output = (0, import_node_child_process2.execFileSync)(binPath, ["--version"], { timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
@@ -10916,10 +11795,10 @@ var DependencyChecker = class {
 
 // src/setup/installer.ts
 var import_node_child_process3 = require("child_process");
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
 var import_promises2 = require("fs/promises");
-var import_node_path9 = require("path");
-var import_node_os7 = require("os");
+var import_node_path10 = require("path");
+var import_node_os8 = require("os");
 function runShellWithRollingOutput(cmd, opts = {}) {
   const maxLines = opts.maxLines ?? 20;
   const timeout = opts.timeout ?? 3e5;
@@ -11029,7 +11908,7 @@ var DependencyInstaller = class {
    */
   async installDocker() {
     if (this.isDockerReady()) return;
-    const os = (0, import_node_os7.platform)();
+    const os = (0, import_node_os8.platform)();
     if (os === "darwin") {
       await this.installDockerMac();
     } else if (os === "linux") {
@@ -11095,15 +11974,15 @@ var DependencyInstaller = class {
     try {
       const composeBin = (0, import_node_child_process3.execFileSync)("which", ["docker-compose"], { timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
       if (!composeBin) return;
-      const pluginDir = (0, import_node_path9.join)((0, import_node_os7.homedir)(), ".docker", "cli-plugins");
-      const pluginPath = (0, import_node_path9.join)(pluginDir, "docker-compose");
-      if ((0, import_node_fs7.existsSync)(pluginPath)) return;
+      const pluginDir = (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".docker", "cli-plugins");
+      const pluginPath = (0, import_node_path10.join)(pluginDir, "docker-compose");
+      if ((0, import_node_fs8.existsSync)(pluginPath)) return;
       try {
-        (0, import_node_fs7.mkdirSync)(pluginDir, { recursive: true });
+        (0, import_node_fs8.mkdirSync)(pluginDir, { recursive: true });
       } catch {
       }
       try {
-        (0, import_node_fs7.symlinkSync)(composeBin, pluginPath);
+        (0, import_node_fs8.symlinkSync)(composeBin, pluginPath);
       } catch {
       }
     } catch {
@@ -11162,9 +12041,9 @@ var DependencyInstaller = class {
       return;
     }
     this.onProgress("__progress__:5:Installing Docker Engine...");
-    const tmpDir = (0, import_node_path9.join)((0, import_node_os7.homedir)(), ".agenticmail", "tmp");
+    const tmpDir = (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".agenticmail", "tmp");
     await (0, import_promises2.mkdir)(tmpDir, { recursive: true });
-    const scriptPath = (0, import_node_path9.join)(tmpDir, "install-docker.sh");
+    const scriptPath = (0, import_node_path10.join)(tmpDir, "install-docker.sh");
     const dlResult = await runShellWithRollingOutput(
       `curl -fsSL https://get.docker.com -o "${scriptPath}" && sudo sh "${scriptPath}"`,
       { timeout: 3e5 }
@@ -11232,8 +12111,8 @@ var DependencyInstaller = class {
       }
       try {
         const programFiles = process.env["ProgramFiles"] || "C:\\Program Files";
-        const dockerExe = (0, import_node_path9.join)(programFiles, "Docker", "Docker", "Docker Desktop.exe");
-        if ((0, import_node_fs7.existsSync)(dockerExe)) {
+        const dockerExe = (0, import_node_path10.join)(programFiles, "Docker", "Docker", "Docker Desktop.exe");
+        if ((0, import_node_fs8.existsSync)(dockerExe)) {
           (0, import_node_child_process3.execSync)(`start "" "${dockerExe}"`, { timeout: 1e4, stdio: "ignore", shell: "cmd.exe" });
         }
       } catch {
@@ -11283,8 +12162,8 @@ var DependencyInstaller = class {
         this.onProgress("__progress__:70:Docker Desktop installed. Starting...");
         try {
           const programFiles = process.env["ProgramFiles"] || "C:\\Program Files";
-          const dockerExe = (0, import_node_path9.join)(programFiles, "Docker", "Docker", "Docker Desktop.exe");
-          if ((0, import_node_fs7.existsSync)(dockerExe)) {
+          const dockerExe = (0, import_node_path10.join)(programFiles, "Docker", "Docker", "Docker Desktop.exe");
+          if ((0, import_node_fs8.existsSync)(dockerExe)) {
             (0, import_node_child_process3.execSync)(`start "" "${dockerExe}"`, { timeout: 1e4, stdio: "ignore", shell: "cmd.exe" });
           }
         } catch {
@@ -11321,12 +12200,12 @@ var DependencyInstaller = class {
    * Start the Stalwart mail server Docker container.
    */
   async startStalwart(composePath) {
-    if (!(0, import_node_fs7.existsSync)(composePath)) {
+    if (!(0, import_node_fs8.existsSync)(composePath)) {
       throw new Error(`docker-compose.yml not found at: ${composePath}`);
     }
     if (!this.isDockerReady()) {
       this.onProgress("Starting Docker...");
-      const os = (0, import_node_os7.platform)();
+      const os = (0, import_node_os8.platform)();
       if (os === "darwin") {
         await this.startColima();
       } else if (os === "win32") {
@@ -11344,7 +12223,7 @@ var DependencyInstaller = class {
       }
     }
     this.onProgress("__progress__:10:Pulling mail server image...");
-    if ((0, import_node_os7.platform)() === "darwin") this.linkComposePlugin();
+    if ((0, import_node_os8.platform)() === "darwin") this.linkComposePlugin();
     let composeResult = await runSilent("docker", ["compose", "-f", composePath, "up", "-d"], { timeout: 12e4 });
     if (composeResult.exitCode !== 0 && hasCommand("docker-compose")) {
       composeResult = await runSilent("docker-compose", ["-f", composePath, "up", "-d"], { timeout: 12e4 });
@@ -11379,22 +12258,22 @@ var DependencyInstaller = class {
    * Returns the path to the installed binary.
    */
   async installCloudflared() {
-    const os = (0, import_node_os7.platform)();
-    const binDir = (0, import_node_path9.join)((0, import_node_os7.homedir)(), ".agenticmail", "bin");
+    const os = (0, import_node_os8.platform)();
+    const binDir = (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".agenticmail", "bin");
     const binName = os === "win32" ? "cloudflared.exe" : "cloudflared";
-    const binPath = (0, import_node_path9.join)(binDir, binName);
-    if ((0, import_node_fs7.existsSync)(binPath)) {
+    const binPath = (0, import_node_path10.join)(binDir, binName);
+    if ((0, import_node_fs8.existsSync)(binPath)) {
       return binPath;
     }
     try {
       const whichCmd = os === "win32" ? "where" : "which";
       const sysPath = (0, import_node_child_process3.execFileSync)(whichCmd, ["cloudflared"], { timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }).toString().trim().split("\n")[0];
-      if (sysPath && (0, import_node_fs7.existsSync)(sysPath)) return sysPath;
+      if (sysPath && (0, import_node_fs8.existsSync)(sysPath)) return sysPath;
     } catch {
     }
     this.onProgress("Downloading cloudflared...");
     await (0, import_promises2.mkdir)(binDir, { recursive: true });
-    const cpu = (0, import_node_os7.arch)();
+    const cpu = (0, import_node_os8.arch)();
     const archName = cpu === "arm64" ? "arm64" : "amd64";
     let downloadUrl;
     if (os === "darwin") {
@@ -11412,7 +12291,7 @@ var DependencyInstaller = class {
     }
     const buffer = Buffer.from(await response.arrayBuffer());
     if (os === "darwin") {
-      const tgzPath = (0, import_node_path9.join)(binDir, "cloudflared.tgz");
+      const tgzPath = (0, import_node_path10.join)(binDir, "cloudflared.tgz");
       await (0, import_promises2.writeFile)(tgzPath, buffer);
       try {
         (0, import_node_child_process3.execFileSync)("tar", ["-xzf", tgzPath, "-C", binDir, "cloudflared"], { timeout: 15e3, stdio: "ignore" });
@@ -11429,7 +12308,7 @@ var DependencyInstaller = class {
       if (os !== "win32") await (0, import_promises2.chmod)(tmpPath, 493);
       await (0, import_promises2.rename)(tmpPath, binPath);
     }
-    if (!(0, import_node_fs7.existsSync)(binPath)) {
+    if (!(0, import_node_fs8.existsSync)(binPath)) {
       throw new Error("cloudflared download succeeded but binary not found after extraction");
     }
     this.onProgress("cloudflared installed");
@@ -11447,23 +12326,23 @@ var DependencyInstaller = class {
 
 // src/setup/service.ts
 var import_node_child_process4 = require("child_process");
-var import_node_fs8 = require("fs");
-var import_node_path10 = require("path");
-var import_node_os8 = require("os");
+var import_node_fs9 = require("fs");
+var import_node_path11 = require("path");
+var import_node_os9 = require("os");
 var import_node_module2 = require("module");
-var import_meta2 = {};
+var import_meta3 = {};
 var PLIST_LABEL = "com.agenticmail.server";
 var SYSTEMD_UNIT = "agenticmail.service";
 var ServiceManager = class {
-  os = (0, import_node_os8.platform)();
+  os = (0, import_node_os9.platform)();
   /**
    * Get the path to the service file.
    */
   getServicePath() {
     if (this.os === "darwin") {
-      return (0, import_node_path10.join)((0, import_node_os8.homedir)(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+      return (0, import_node_path11.join)((0, import_node_os9.homedir)(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
     } else {
-      return (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".config", "systemd", "user", SYSTEMD_UNIT);
+      return (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".config", "systemd", "user", SYSTEMD_UNIT);
     }
   }
   /**
@@ -11495,42 +12374,42 @@ var ServiceManager = class {
    */
   getApiEntryPath() {
     try {
-      const req = (0, import_node_module2.createRequire)(import_meta2.url);
+      const req = (0, import_node_module2.createRequire)(import_meta3.url);
       const resolved = req.resolve("@agenticmail/api");
-      if ((0, import_node_fs8.existsSync)(resolved)) return resolved;
+      if ((0, import_node_fs9.existsSync)(resolved)) return resolved;
     } catch {
     }
     const parentPackages = [
-      (0, import_node_path10.join)("@agenticmail", "cli"),
+      (0, import_node_path11.join)("@agenticmail", "cli"),
       // current scoped package
       "agenticmail"
       // legacy unscoped package
     ];
     const baseDirs = [
       // user-local install
-      (0, import_node_path10.join)((0, import_node_os8.homedir)(), "node_modules")
+      (0, import_node_path11.join)((0, import_node_os9.homedir)(), "node_modules")
     ];
     try {
       const prefix = (0, import_node_child_process4.execSync)("npm prefix -g", { timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
-      baseDirs.push((0, import_node_path10.join)(prefix, "lib", "node_modules"));
-      baseDirs.push((0, import_node_path10.join)(prefix, "node_modules"));
+      baseDirs.push((0, import_node_path11.join)(prefix, "lib", "node_modules"));
+      baseDirs.push((0, import_node_path11.join)(prefix, "node_modules"));
     } catch {
     }
     baseDirs.push("/opt/homebrew/lib/node_modules");
     baseDirs.push("/usr/local/lib/node_modules");
     for (const base of baseDirs) {
-      const sibling = (0, import_node_path10.join)(base, "@agenticmail", "api", "dist", "index.js");
-      if ((0, import_node_fs8.existsSync)(sibling)) return sibling;
+      const sibling = (0, import_node_path11.join)(base, "@agenticmail", "api", "dist", "index.js");
+      if ((0, import_node_fs9.existsSync)(sibling)) return sibling;
       for (const parent of parentPackages) {
-        const nested = (0, import_node_path10.join)(base, parent, "node_modules", "@agenticmail", "api", "dist", "index.js");
-        if ((0, import_node_fs8.existsSync)(nested)) return nested;
+        const nested = (0, import_node_path11.join)(base, parent, "node_modules", "@agenticmail", "api", "dist", "index.js");
+        if ((0, import_node_fs9.existsSync)(nested)) return nested;
       }
     }
-    const dataDir = (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".agenticmail");
-    const entryCache = (0, import_node_path10.join)(dataDir, "api-entry.path");
-    if ((0, import_node_fs8.existsSync)(entryCache)) {
-      const cached = (0, import_node_fs8.readFileSync)(entryCache, "utf-8").trim();
-      if (cached && (0, import_node_fs8.existsSync)(cached)) return cached;
+    const dataDir = (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail");
+    const entryCache = (0, import_node_path11.join)(dataDir, "api-entry.path");
+    if ((0, import_node_fs9.existsSync)(entryCache)) {
+      const cached = (0, import_node_fs9.readFileSync)(entryCache, "utf-8").trim();
+      if (cached && (0, import_node_fs9.existsSync)(cached)) return cached;
     }
     throw new Error("Could not find @agenticmail/api entry point. Run `agenticmail start` first to populate the cache.");
   }
@@ -11538,9 +12417,9 @@ var ServiceManager = class {
    * Cache the API entry path so the service can find it later.
    */
   cacheApiEntryPath(entryPath) {
-    const dataDir = (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".agenticmail");
-    if (!(0, import_node_fs8.existsSync)(dataDir)) (0, import_node_fs8.mkdirSync)(dataDir, { recursive: true });
-    (0, import_node_fs8.writeFileSync)((0, import_node_path10.join)(dataDir, "api-entry.path"), entryPath);
+    const dataDir = (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail");
+    if (!(0, import_node_fs9.existsSync)(dataDir)) (0, import_node_fs9.mkdirSync)(dataDir, { recursive: true });
+    (0, import_node_fs9.writeFileSync)((0, import_node_path11.join)(dataDir, "api-entry.path"), entryPath);
   }
   /**
    * Get the current package version.
@@ -11551,38 +12430,38 @@ var ServiceManager = class {
    */
   getVersion() {
     try {
-      const req = (0, import_node_module2.createRequire)(import_meta2.url);
+      const req = (0, import_node_module2.createRequire)(import_meta3.url);
       const pkgJson = req.resolve("@agenticmail/cli/package.json");
-      if ((0, import_node_fs8.existsSync)(pkgJson)) {
-        const pkg = JSON.parse((0, import_node_fs8.readFileSync)(pkgJson, "utf-8"));
+      if ((0, import_node_fs9.existsSync)(pkgJson)) {
+        const pkg = JSON.parse((0, import_node_fs9.readFileSync)(pkgJson, "utf-8"));
         if (pkg.version) return pkg.version;
       }
     } catch {
     }
     try {
       const apiEntry = this.getApiEntryPath();
-      const apiPkg = (0, import_node_path10.join)(apiEntry, "..", "..", "package.json");
-      if ((0, import_node_fs8.existsSync)(apiPkg)) {
-        const pkg = JSON.parse((0, import_node_fs8.readFileSync)(apiPkg, "utf-8"));
+      const apiPkg = (0, import_node_path11.join)(apiEntry, "..", "..", "package.json");
+      if ((0, import_node_fs9.existsSync)(apiPkg)) {
+        const pkg = JSON.parse((0, import_node_fs9.readFileSync)(apiPkg, "utf-8"));
         if (pkg.version) return pkg.version;
       }
     } catch {
     }
     const candidates = [
-      (0, import_node_path10.join)((0, import_node_os8.homedir)(), "node_modules", "@agenticmail", "cli", "package.json"),
-      (0, import_node_path10.join)((0, import_node_os8.homedir)(), "node_modules", "agenticmail", "package.json"),
-      (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".agenticmail", "package-version.json")
+      (0, import_node_path11.join)((0, import_node_os9.homedir)(), "node_modules", "@agenticmail", "cli", "package.json"),
+      (0, import_node_path11.join)((0, import_node_os9.homedir)(), "node_modules", "agenticmail", "package.json"),
+      (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail", "package-version.json")
     ];
     try {
       const prefix = (0, import_node_child_process4.execSync)("npm prefix -g", { timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
-      candidates.push((0, import_node_path10.join)(prefix, "lib", "node_modules", "@agenticmail", "cli", "package.json"));
-      candidates.push((0, import_node_path10.join)(prefix, "lib", "node_modules", "agenticmail", "package.json"));
+      candidates.push((0, import_node_path11.join)(prefix, "lib", "node_modules", "@agenticmail", "cli", "package.json"));
+      candidates.push((0, import_node_path11.join)(prefix, "lib", "node_modules", "agenticmail", "package.json"));
     } catch {
     }
     for (const p of candidates) {
       try {
-        if ((0, import_node_fs8.existsSync)(p)) {
-          const pkg = JSON.parse((0, import_node_fs8.readFileSync)(p, "utf-8"));
+        if ((0, import_node_fs9.existsSync)(p)) {
+          const pkg = JSON.parse((0, import_node_fs9.readFileSync)(p, "utf-8"));
           if (pkg.version) return pkg.version;
         }
       } catch {
@@ -11595,9 +12474,9 @@ var ServiceManager = class {
    * This ensures AgenticMail doesn't fail on boot when Docker is still loading.
    */
   generateStartScript(nodePath, apiEntry) {
-    const scriptPath = (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".agenticmail", "bin", "start-server.sh");
-    const scriptDir = (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".agenticmail", "bin");
-    if (!(0, import_node_fs8.existsSync)(scriptDir)) (0, import_node_fs8.mkdirSync)(scriptDir, { recursive: true });
+    const scriptPath = (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail", "bin", "start-server.sh");
+    const scriptDir = (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail", "bin");
+    if (!(0, import_node_fs9.existsSync)(scriptDir)) (0, import_node_fs9.mkdirSync)(scriptDir, { recursive: true });
     const script = [
       "#!/bin/bash",
       "# AgenticMail auto-start script",
@@ -11648,7 +12527,7 @@ var ServiceManager = class {
       `log "Starting API server: ${nodePath} ${apiEntry}"`,
       `exec "${nodePath}" "${apiEntry}"`
     ].join("\n") + "\n";
-    (0, import_node_fs8.writeFileSync)(scriptPath, script, { mode: 493 });
+    (0, import_node_fs9.writeFileSync)(scriptPath, script, { mode: 493 });
     return scriptPath;
   }
   /**
@@ -11661,9 +12540,9 @@ var ServiceManager = class {
    * - Service version tracking in env vars
    */
   generatePlist(nodePath, apiEntry, configPath) {
-    const config = JSON.parse((0, import_node_fs8.readFileSync)(configPath, "utf-8"));
-    const logDir = (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".agenticmail", "logs");
-    if (!(0, import_node_fs8.existsSync)(logDir)) (0, import_node_fs8.mkdirSync)(logDir, { recursive: true });
+    const config = JSON.parse((0, import_node_fs9.readFileSync)(configPath, "utf-8"));
+    const logDir = (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail", "logs");
+    if (!(0, import_node_fs9.existsSync)(logDir)) (0, import_node_fs9.mkdirSync)(logDir, { recursive: true });
     const version = this.getVersion();
     const startScript = this.generateStartScript(nodePath, apiEntry);
     return `<?xml version="1.0" encoding="UTF-8"?>
@@ -11684,9 +12563,9 @@ var ServiceManager = class {
   <key>EnvironmentVariables</key>
   <dict>
     <key>HOME</key>
-    <string>${(0, import_node_os8.homedir)()}</string>
+    <string>${(0, import_node_os9.homedir)()}</string>
     <key>AGENTICMAIL_DATA_DIR</key>
-    <string>${config.dataDir || (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".agenticmail")}</string>
+    <string>${config.dataDir || (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail")}</string>
     <key>PATH</key>
     <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
     <key>AGENTICMAIL_SERVICE_VERSION</key>
@@ -11739,8 +12618,8 @@ var ServiceManager = class {
    * - Proper dependency ordering
    */
   generateSystemdUnit(nodePath, apiEntry, configPath) {
-    const config = JSON.parse((0, import_node_fs8.readFileSync)(configPath, "utf-8"));
-    const dataDir = config.dataDir || (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".agenticmail");
+    const config = JSON.parse((0, import_node_fs9.readFileSync)(configPath, "utf-8"));
+    const dataDir = config.dataDir || (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail");
     const version = this.getVersion();
     const startScript = this.generateStartScript(nodePath, apiEntry);
     return `[Unit]
@@ -11757,7 +12636,7 @@ Restart=always
 RestartSec=15
 TimeoutStartSec=660
 LimitNOFILE=8192
-Environment=HOME=${(0, import_node_os8.homedir)()}
+Environment=HOME=${(0, import_node_os9.homedir)()}
 Environment=AGENTICMAIL_DATA_DIR=${dataDir}
 Environment=PATH=/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin
 Environment=AGENTICMAIL_SERVICE_VERSION=${version}
@@ -11770,8 +12649,8 @@ WantedBy=default.target
    * Install the auto-start service.
    */
   install() {
-    const configPath = (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".agenticmail", "config.json");
-    if (!(0, import_node_fs8.existsSync)(configPath)) {
+    const configPath = (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail", "config.json");
+    if (!(0, import_node_fs9.existsSync)(configPath)) {
       return { installed: false, message: "Config not found. Run agenticmail setup first." };
     }
     const nodePath = this.getNodePath();
@@ -11783,17 +12662,17 @@ WantedBy=default.target
     }
     const servicePath = this.getServicePath();
     if (this.os === "darwin") {
-      const dir2 = (0, import_node_path10.join)((0, import_node_os8.homedir)(), "Library", "LaunchAgents");
-      if (!(0, import_node_fs8.existsSync)(dir2)) (0, import_node_fs8.mkdirSync)(dir2, { recursive: true });
-      if ((0, import_node_fs8.existsSync)(servicePath)) {
+      const dir2 = (0, import_node_path11.join)((0, import_node_os9.homedir)(), "Library", "LaunchAgents");
+      if (!(0, import_node_fs9.existsSync)(dir2)) (0, import_node_fs9.mkdirSync)(dir2, { recursive: true });
+      if ((0, import_node_fs9.existsSync)(servicePath)) {
         try {
           (0, import_node_child_process4.execFileSync)("launchctl", ["unload", servicePath], { timeout: 1e4, stdio: "ignore" });
         } catch {
         }
       }
       const plist = this.generatePlist(nodePath, apiEntry, configPath);
-      (0, import_node_fs8.writeFileSync)(servicePath, plist);
-      (0, import_node_fs8.chmodSync)(servicePath, 384);
+      (0, import_node_fs9.writeFileSync)(servicePath, plist);
+      (0, import_node_fs9.chmodSync)(servicePath, 384);
       try {
         (0, import_node_child_process4.execFileSync)("launchctl", ["load", servicePath], { timeout: 1e4, stdio: "ignore" });
       } catch (err) {
@@ -11801,11 +12680,11 @@ WantedBy=default.target
       }
       return { installed: true, message: `Service installed at ${servicePath}` };
     } else if (this.os === "linux") {
-      const dir2 = (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".config", "systemd", "user");
-      if (!(0, import_node_fs8.existsSync)(dir2)) (0, import_node_fs8.mkdirSync)(dir2, { recursive: true });
+      const dir2 = (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".config", "systemd", "user");
+      if (!(0, import_node_fs9.existsSync)(dir2)) (0, import_node_fs9.mkdirSync)(dir2, { recursive: true });
       const unit = this.generateSystemdUnit(nodePath, apiEntry, configPath);
-      (0, import_node_fs8.writeFileSync)(servicePath, unit);
-      (0, import_node_fs8.chmodSync)(servicePath, 384);
+      (0, import_node_fs9.writeFileSync)(servicePath, unit);
+      (0, import_node_fs9.chmodSync)(servicePath, 384);
       try {
         (0, import_node_child_process4.execFileSync)("systemctl", ["--user", "daemon-reload"], { timeout: 1e4, stdio: "ignore" });
         (0, import_node_child_process4.execFileSync)("systemctl", ["--user", "enable", SYSTEMD_UNIT], { timeout: 1e4, stdio: "ignore" });
@@ -11827,7 +12706,7 @@ WantedBy=default.target
    */
   uninstall() {
     const servicePath = this.getServicePath();
-    if (!(0, import_node_fs8.existsSync)(servicePath)) {
+    if (!(0, import_node_fs9.existsSync)(servicePath)) {
       return { removed: false, message: "Service is not installed." };
     }
     if (this.os === "darwin") {
@@ -11836,7 +12715,7 @@ WantedBy=default.target
       } catch {
       }
       try {
-        (0, import_node_fs8.unlinkSync)(servicePath);
+        (0, import_node_fs9.unlinkSync)(servicePath);
       } catch {
       }
       return { removed: true, message: "Service removed." };
@@ -11847,7 +12726,7 @@ WantedBy=default.target
       } catch {
       }
       try {
-        (0, import_node_fs8.unlinkSync)(servicePath);
+        (0, import_node_fs9.unlinkSync)(servicePath);
       } catch {
       }
       try {
@@ -11865,7 +12744,7 @@ WantedBy=default.target
   status() {
     const servicePath = this.getServicePath();
     const plat = this.os === "darwin" ? "launchd" : this.os === "linux" ? "systemd" : "unsupported";
-    const installed = (0, import_node_fs8.existsSync)(servicePath);
+    const installed = (0, import_node_fs9.existsSync)(servicePath);
     let running = false;
     if (installed) {
       if (this.os === "darwin") {
@@ -11920,34 +12799,34 @@ WantedBy=default.target
   needsRepair() {
     if (this.os !== "darwin" && this.os !== "linux") return null;
     const servicePath = this.getServicePath();
-    if (!(0, import_node_fs8.existsSync)(servicePath)) return null;
+    if (!(0, import_node_fs9.existsSync)(servicePath)) return null;
     let serviceContent = "";
     try {
-      serviceContent = (0, import_node_fs8.readFileSync)(servicePath, "utf-8");
+      serviceContent = (0, import_node_fs9.readFileSync)(servicePath, "utf-8");
     } catch {
       return { reason: "Service file unreadable" };
     }
-    const startScript = (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".agenticmail", "bin", "start-server.sh");
+    const startScript = (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail", "bin", "start-server.sh");
     if (serviceContent.includes(startScript)) {
-      if (!(0, import_node_fs8.existsSync)(startScript)) {
+      if (!(0, import_node_fs9.existsSync)(startScript)) {
         return { reason: "start-server.sh is missing" };
       }
       let scriptContent = "";
       try {
-        scriptContent = (0, import_node_fs8.readFileSync)(startScript, "utf-8");
+        scriptContent = (0, import_node_fs9.readFileSync)(startScript, "utf-8");
       } catch {
         return { reason: "start-server.sh unreadable" };
       }
       const apiPathMatch = scriptContent.match(/(\/[^"\s]+@agenticmail\/api\/dist\/index\.js)/);
       if (apiPathMatch) {
         const referenced = apiPathMatch[1];
-        if (!(0, import_node_fs8.existsSync)(referenced)) {
+        if (!(0, import_node_fs9.existsSync)(referenced)) {
           return { reason: `start-server.sh references missing path: ${referenced}` };
         }
       }
       if (/node_modules\/agenticmail\/(?!.*@agenticmail\/cli)/.test(scriptContent)) {
         const stale = /(\S*node_modules\/agenticmail\/\S*)/.exec(scriptContent)?.[1];
-        if (stale && !(0, import_node_fs8.existsSync)(stale)) {
+        if (stale && !(0, import_node_fs9.existsSync)(stale)) {
           return { reason: `start-server.sh references legacy unscoped path: ${stale}` };
         }
       }
@@ -11960,11 +12839,11 @@ WantedBy=default.target
         return { reason: `Service version drift (current CLI is v${currentVersion})` };
       }
     }
-    const entryCache = (0, import_node_path10.join)((0, import_node_os8.homedir)(), ".agenticmail", "api-entry.path");
-    if ((0, import_node_fs8.existsSync)(entryCache)) {
+    const entryCache = (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail", "api-entry.path");
+    if ((0, import_node_fs9.existsSync)(entryCache)) {
       try {
-        const cached = (0, import_node_fs8.readFileSync)(entryCache, "utf-8").trim();
-        if (cached && !(0, import_node_fs8.existsSync)(cached)) {
+        const cached = (0, import_node_fs9.readFileSync)(entryCache, "utf-8").trim();
+        if (cached && !(0, import_node_fs9.existsSync)(cached)) {
           return { reason: `Cached API entry path no longer exists: ${cached}` };
         }
       } catch {
@@ -12015,13 +12894,13 @@ var SetupManager = class {
    * falls back to monorepo location.
    */
   getComposePath() {
-    const standalonePath = (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail", "docker-compose.yml");
-    if ((0, import_node_fs9.existsSync)(standalonePath)) return standalonePath;
+    const standalonePath = (0, import_node_path12.join)((0, import_node_os10.homedir)(), ".agenticmail", "docker-compose.yml");
+    if ((0, import_node_fs10.existsSync)(standalonePath)) return standalonePath;
     const cwd = process.cwd();
-    const candidates = [cwd, (0, import_node_path11.join)(cwd, "..")];
+    const candidates = [cwd, (0, import_node_path12.join)(cwd, "..")];
     for (const dir2 of candidates) {
-      const p = (0, import_node_path11.join)(dir2, "docker-compose.yml");
-      if ((0, import_node_fs9.existsSync)(p)) return p;
+      const p = (0, import_node_path12.join)(dir2, "docker-compose.yml");
+      if ((0, import_node_fs10.existsSync)(p)) return p;
     }
     return standalonePath;
   }
@@ -12031,19 +12910,19 @@ var SetupManager = class {
    * Always regenerates Docker files to keep passwords in sync.
    */
   initConfig() {
-    const dataDir = (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail");
-    const configPath = (0, import_node_path11.join)(dataDir, "config.json");
-    const envPath = (0, import_node_path11.join)(dataDir, ".env");
-    if ((0, import_node_fs9.existsSync)(configPath)) {
+    const dataDir = (0, import_node_path12.join)((0, import_node_os10.homedir)(), ".agenticmail");
+    const configPath = (0, import_node_path12.join)(dataDir, "config.json");
+    const envPath = (0, import_node_path12.join)(dataDir, ".env");
+    if ((0, import_node_fs10.existsSync)(configPath)) {
       try {
-        const existing = JSON.parse((0, import_node_fs9.readFileSync)(configPath, "utf-8"));
+        const existing = JSON.parse((0, import_node_fs10.readFileSync)(configPath, "utf-8"));
         this.generateDockerFiles(existing);
         return { configPath, envPath, config: existing, isNew: false };
       } catch {
       }
     }
-    if (!(0, import_node_fs9.existsSync)(dataDir)) {
-      (0, import_node_fs9.mkdirSync)(dataDir, { recursive: true });
+    if (!(0, import_node_fs10.existsSync)(dataDir)) {
+      (0, import_node_fs10.mkdirSync)(dataDir, { recursive: true });
     }
     const masterKey = `mk_${(0, import_node_crypto6.randomBytes)(24).toString("hex")}`;
     const stalwartPassword = (0, import_node_crypto6.randomBytes)(16).toString("hex");
@@ -12059,8 +12938,8 @@ var SetupManager = class {
       api: { port: 3829, host: "127.0.0.1" },
       dataDir
     };
-    (0, import_node_fs9.writeFileSync)(configPath, JSON.stringify(config, null, 2));
-    (0, import_node_fs9.chmodSync)(configPath, 384);
+    (0, import_node_fs10.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+    (0, import_node_fs10.chmodSync)(configPath, 384);
     const envContent = `# Auto-generated by agenticmail setup
 STALWART_ADMIN_USER=admin
 STALWART_ADMIN_PASSWORD=${stalwartPassword}
@@ -12075,8 +12954,8 @@ SMTP_PORT=587
 IMAP_HOST=localhost
 IMAP_PORT=143
 `;
-    (0, import_node_fs9.writeFileSync)(envPath, envContent);
-    (0, import_node_fs9.chmodSync)(envPath, 384);
+    (0, import_node_fs10.writeFileSync)(envPath, envContent);
+    (0, import_node_fs10.chmodSync)(envPath, 384);
     this.generateDockerFiles(config);
     return { configPath, envPath, config, isNew: true };
   }
@@ -12085,13 +12964,13 @@ IMAP_PORT=143
    * with the correct admin password from config.
    */
   generateDockerFiles(config) {
-    const dataDir = config.dataDir || (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail");
-    if (!(0, import_node_fs9.existsSync)(dataDir)) {
-      (0, import_node_fs9.mkdirSync)(dataDir, { recursive: true });
+    const dataDir = config.dataDir || (0, import_node_path12.join)((0, import_node_os10.homedir)(), ".agenticmail");
+    if (!(0, import_node_fs10.existsSync)(dataDir)) {
+      (0, import_node_fs10.mkdirSync)(dataDir, { recursive: true });
     }
     const password = config.stalwart?.adminPassword || "changeme";
-    const composePath = (0, import_node_path11.join)(dataDir, "docker-compose.yml");
-    (0, import_node_fs9.writeFileSync)(composePath, `services:
+    const composePath = (0, import_node_path12.join)(dataDir, "docker-compose.yml");
+    (0, import_node_fs10.writeFileSync)(composePath, `services:
   stalwart:
     # Pinned to v0.15.5 \u2014 Stalwart 0.16+ moved its config to JSON
     # at /etc/stalwart/config.json (hardcoded into the container
@@ -12120,9 +12999,9 @@ IMAP_PORT=143
 volumes:
   stalwart-data:
 `);
-    (0, import_node_fs9.chmodSync)(composePath, 384);
-    const tomlPath = (0, import_node_path11.join)(dataDir, "stalwart.toml");
-    (0, import_node_fs9.writeFileSync)(tomlPath, `# Stalwart Mail Server \u2014 AgenticMail Configuration
+    (0, import_node_fs10.chmodSync)(composePath, 384);
+    const tomlPath = (0, import_node_path12.join)(dataDir, "stalwart.toml");
+    (0, import_node_fs10.writeFileSync)(tomlPath, `# Stalwart Mail Server \u2014 AgenticMail Configuration
 
 [server]
 hostname = "localhost"
@@ -12172,27 +13051,27 @@ enable = true
 user = "admin"
 secret = "${password}"
 `);
-    (0, import_node_fs9.chmodSync)(tomlPath, 384);
+    (0, import_node_fs10.chmodSync)(tomlPath, 384);
   }
   /**
    * Check if config has already been initialized.
    */
   isInitialized() {
-    const configPath = (0, import_node_path11.join)((0, import_node_os9.homedir)(), ".agenticmail", "config.json");
-    return (0, import_node_fs9.existsSync)(configPath);
+    const configPath = (0, import_node_path12.join)((0, import_node_os10.homedir)(), ".agenticmail", "config.json");
+    return (0, import_node_fs10.existsSync)(configPath);
   }
 };
 
 // src/media/manager.ts
 var import_node_child_process6 = require("child_process");
 var import_node_util = require("util");
-var import_node_fs11 = require("fs");
-var import_node_path12 = require("path");
+var import_node_fs12 = require("fs");
+var import_node_path13 = require("path");
 
 // src/media/binaries.ts
 var import_node_child_process5 = require("child_process");
-var import_node_fs10 = require("fs");
-var import_meta3 = {};
+var import_node_fs11 = require("fs");
+var import_meta4 = {};
 var BINARY_SPECS = {
   ffmpeg: {
     binary: "ffmpeg",
@@ -12265,7 +13144,7 @@ function probeCommand(command, spec) {
 }
 function detectEdgeTts(spec) {
   try {
-    const resolved = import_meta3.resolve?.("node-edge-tts");
+    const resolved = import_meta4.resolve?.("node-edge-tts");
     if (resolved) {
       return {
         binary: "edge-tts",
@@ -12332,7 +13211,7 @@ function requireWhisperModel(modelPath) {
       "A whisper.cpp model file is required (whisperModel option). Download one, e.g. ggml-base.en.bin, from https://huggingface.co/ggerganov/whisper.cpp and pass its absolute path."
     );
   }
-  if (!(0, import_node_fs10.existsSync)(modelPath)) {
+  if (!(0, import_node_fs11.existsSync)(modelPath)) {
     throw new Error(`whisper model file not found: ${modelPath}`);
   }
   return modelPath;
@@ -12384,7 +13263,7 @@ function validateInputPath(path2, label = "input") {
       `${label} file path may not start with "-" \u2014 pass an absolute path so it cannot be parsed as a command flag`
     );
   }
-  if (!(0, import_node_fs11.existsSync)(path2)) {
+  if (!(0, import_node_fs12.existsSync)(path2)) {
     throw new Error(`${label} file not found: ${path2}`);
   }
   return path2;
@@ -12406,32 +13285,32 @@ var MediaManager = class {
     if (options.outputDir) {
       this.outputDir = options.outputDir;
     } else if (options.dataDir) {
-      this.outputDir = (0, import_node_path12.join)(options.dataDir, "media");
+      this.outputDir = (0, import_node_path13.join)(options.dataDir, "media");
     } else {
       const tmp = process.env.TMPDIR || process.env.TEMP || "/tmp";
-      this.outputDir = (0, import_node_path12.join)(tmp, "agenticmail-media");
+      this.outputDir = (0, import_node_path13.join)(tmp, "agenticmail-media");
     }
   }
   /** Ensure the output directory exists; returns it. */
   ensureOutputDir() {
-    if (!(0, import_node_fs11.existsSync)(this.outputDir)) {
-      (0, import_node_fs11.mkdirSync)(this.outputDir, { recursive: true });
+    if (!(0, import_node_fs12.existsSync)(this.outputDir)) {
+      (0, import_node_fs12.mkdirSync)(this.outputDir, { recursive: true });
     }
     return this.outputDir;
   }
   /** Build an output path inside the managed output dir. */
   outPath(prefix, ext) {
-    return (0, import_node_path12.join)(this.ensureOutputDir(), `${prefix}-${Date.now()}-${Math.floor(Math.random() * 1e6)}.${ext}`);
+    return (0, import_node_path13.join)(this.ensureOutputDir(), `${prefix}-${Date.now()}-${Math.floor(Math.random() * 1e6)}.${ext}`);
   }
   /** Build a sub-directory inside the managed output dir. */
   outDir(prefix) {
-    const dir2 = (0, import_node_path12.join)(this.ensureOutputDir(), `${prefix}-${Date.now()}-${Math.floor(Math.random() * 1e6)}`);
-    (0, import_node_fs11.mkdirSync)(dir2, { recursive: true });
+    const dir2 = (0, import_node_path13.join)(this.ensureOutputDir(), `${prefix}-${Date.now()}-${Math.floor(Math.random() * 1e6)}`);
+    (0, import_node_fs12.mkdirSync)(dir2, { recursive: true });
     return dir2;
   }
   /** Stat a produced file into a {@link MediaFileResult} envelope. */
   fileResult(path2, extra = {}) {
-    const stat = (0, import_node_fs11.statSync)(path2);
+    const stat = (0, import_node_fs12.statSync)(path2);
     return { ok: true, filePath: path2, sizeBytes: stat.size, ...extra };
   }
   // ─── binary invocation helpers (execFile, arg arrays, no shell) ────
@@ -12545,7 +13424,7 @@ var MediaManager = class {
   /** Edit an image with ImageMagick. */
   async imageEdit(opts) {
     const input = validateInputPath(opts.input);
-    const ext = safeExtension(opts.format, (0, import_node_path12.extname)(input).slice(1) || "png");
+    const ext = safeExtension(opts.format, (0, import_node_path13.extname)(input).slice(1) || "png");
     const out = this.outPath("img", ext);
     switch (opts.action) {
       case "resize": {
@@ -12632,7 +13511,7 @@ var MediaManager = class {
     switch (opts.action) {
       case "trim": {
         const input = validateInputPath(opts.input);
-        const out = this.outPath("aud", safeExtension(null, (0, import_node_path12.extname)(input).slice(1) || "mp3"));
+        const out = this.outPath("aud", safeExtension(null, (0, import_node_path13.extname)(input).slice(1) || "mp3"));
         const a = ["-i", input];
         if (opts.start) a.push("-ss", String(opts.start));
         if (opts.end) a.push("-to", String(opts.end));
@@ -12653,8 +13532,8 @@ var MediaManager = class {
         if (files.length < 2) throw new Error("At least 2 files are required for merge");
         files.forEach((f, i) => validateInputPath(f, `files[${i}]`));
         const listFile = this.outPath("concat", "txt");
-        (0, import_node_fs11.writeFileSync)(listFile, files.map((f) => `file '${f.replace(/'/g, "'\\''")}'`).join("\n"));
-        const out = this.outPath("aud", safeExtension(null, (0, import_node_path12.extname)(files[0]).slice(1) || "mp3"));
+        (0, import_node_fs12.writeFileSync)(listFile, files.map((f) => `file '${f.replace(/'/g, "'\\''")}'`).join("\n"));
+        const out = this.outPath("aud", safeExtension(null, (0, import_node_path13.extname)(files[0]).slice(1) || "mp3"));
         try {
           await this.ffmpeg(["-f", "concat", "-safe", "0", "-i", listFile, "-c", "copy", "-y", out]);
         } finally {
@@ -12665,7 +13544,7 @@ var MediaManager = class {
       case "volume": {
         const input = validateInputPath(opts.input);
         if (!opts.volume) throw new Error('volume is required (e.g. "1.5" or "10dB")');
-        const out = this.outPath("aud", safeExtension(null, (0, import_node_path12.extname)(input).slice(1) || "mp3"));
+        const out = this.outPath("aud", safeExtension(null, (0, import_node_path13.extname)(input).slice(1) || "mp3"));
         await this.ffmpeg(["-i", input, "-af", `volume=${opts.volume}`, "-y", out]);
         return this.fileResult(out);
       }
@@ -12673,7 +13552,7 @@ var MediaManager = class {
         const input = validateInputPath(opts.input);
         const factor = clampNumber(opts.speedFactor, 0.5, 100, 0);
         if (!factor) throw new Error("speedFactor is required for speed");
-        const out = this.outPath("aud", safeExtension(null, (0, import_node_path12.extname)(input).slice(1) || "mp3"));
+        const out = this.outPath("aud", safeExtension(null, (0, import_node_path13.extname)(input).slice(1) || "mp3"));
         await this.ffmpeg(["-i", input, "-af", `atempo=${factor}`, "-y", out]);
         return this.fileResult(out);
       }
@@ -12685,7 +13564,7 @@ var MediaManager = class {
       }
       case "reverse": {
         const input = validateInputPath(opts.input);
-        const out = this.outPath("aud", safeExtension(null, (0, import_node_path12.extname)(input).slice(1) || "mp3"));
+        const out = this.outPath("aud", safeExtension(null, (0, import_node_path13.extname)(input).slice(1) || "mp3"));
         await this.ffmpeg(["-i", input, "-af", "areverse", "-y", out]);
         return this.fileResult(out);
       }
@@ -12694,7 +13573,7 @@ var MediaManager = class {
         const dur = clampNumber(opts.fadeDuration, 0.1, 3600, 3);
         const probe = await this.ffprobe(input);
         const totalDur = parseFloat(probe.format?.duration || "0");
-        const out = this.outPath("aud", safeExtension(null, (0, import_node_path12.extname)(input).slice(1) || "mp3"));
+        const out = this.outPath("aud", safeExtension(null, (0, import_node_path13.extname)(input).slice(1) || "mp3"));
         let af;
         if (opts.fadeType === "in") af = `afade=t=in:st=0:d=${dur}`;
         else if (opts.fadeType === "out") af = `afade=t=out:st=${Math.max(0, totalDur - dur)}:d=${dur}`;
@@ -12724,7 +13603,7 @@ var MediaManager = class {
     }));
     return {
       ok: true,
-      file: (0, import_node_path12.basename)(path2),
+      file: (0, import_node_path13.basename)(path2),
       format: info.format?.format_long_name,
       duration: info.format?.duration,
       sizeBytes: parseInt(info.format?.size || "0", 10),
@@ -12737,7 +13616,7 @@ var MediaManager = class {
   async videoEdit(opts) {
     if (opts.action === "concatenate") return this.videoConcatenate(opts);
     const input = validateInputPath(opts.input);
-    const srcExt = safeExtension(null, (0, import_node_path12.extname)(input).slice(1) || "mp4");
+    const srcExt = safeExtension(null, (0, import_node_path13.extname)(input).slice(1) || "mp4");
     switch (opts.action) {
       case "trim": {
         const out = this.outPath("vid", srcExt);
@@ -12759,7 +13638,7 @@ var MediaManager = class {
         const dir2 = this.outDir("frames");
         const interval = clampNumber(opts.interval, 0.01, 3600, 1);
         await this.ffmpeg(
-          ["-i", input, "-vf", `fps=1/${interval}`, (0, import_node_path12.join)(dir2, "frame-%04d.png"), "-y"],
+          ["-i", input, "-vf", `fps=1/${interval}`, (0, import_node_path13.join)(dir2, "frame-%04d.png"), "-y"],
           TIMEOUT_LONG
         );
         return { ok: true, filePath: dir2, sizeBytes: 0, outputDir: dir2 };
@@ -12860,7 +13739,7 @@ var MediaManager = class {
     }
   }
   async videoColorGrade(input, opts) {
-    const out = this.outPath("vid", safeExtension(null, (0, import_node_path12.extname)(input).slice(1) || "mp4"));
+    const out = this.outPath("vid", safeExtension(null, (0, import_node_path13.extname)(input).slice(1) || "mp4"));
     let vf;
     if (opts.lutPath) {
       const lut = validateInputPath(opts.lutPath, "lutPath");
@@ -12918,7 +13797,7 @@ var MediaManager = class {
   }
   async videoTextOverlay(input, opts) {
     if (!opts.text) throw new Error("text is required for text_overlay");
-    const out = this.outPath("vid", safeExtension(null, (0, import_node_path12.extname)(input).slice(1) || "mp4"));
+    const out = this.outPath("vid", safeExtension(null, (0, import_node_path13.extname)(input).slice(1) || "mp4"));
     const probeV = await this.ffprobe(input);
     const vStream = (probeV.streams || []).find((s) => s.codec_type === "video");
     const vw = vStream?.width || 1920;
@@ -13187,7 +14066,7 @@ var MediaManager = class {
     files.forEach((f, i) => validateInputPath(f, `files[${i}]`));
     const out = this.outPath("vid", "mp4");
     const listFile = this.outPath("concat", "txt");
-    (0, import_node_fs11.writeFileSync)(listFile, files.map((f) => `file '${f.replace(/'/g, "'\\''")}'`).join("\n"));
+    (0, import_node_fs12.writeFileSync)(listFile, files.map((f) => `file '${f.replace(/'/g, "'\\''")}'`).join("\n"));
     try {
       try {
         await this.ffmpeg(["-f", "concat", "-safe", "0", "-i", listFile, "-c", "copy", "-y", out], TIMEOUT_LONG);
@@ -13316,9 +14195,9 @@ var MediaManager = class {
       const bg = bgColors[i % bgColors.length];
       const sizeMult = chunk.wc <= 2 ? 1.4 : chunk.wc <= 3 ? 1.1 : 1;
       const fontSize = Math.round(baseFont * sizeMult);
-      const txtPng = (0, import_node_path12.join)(captionDir, `txt-${i}.png`);
-      const bgPng = (0, import_node_path12.join)(captionDir, `bg-${i}.png`);
-      const finalPng = (0, import_node_path12.join)(captionDir, `c-${String(i).padStart(4, "0")}.png`);
+      const txtPng = (0, import_node_path13.join)(captionDir, `txt-${i}.png`);
+      const bgPng = (0, import_node_path13.join)(captionDir, `bg-${i}.png`);
+      const finalPng = (0, import_node_path13.join)(captionDir, `c-${String(i).padStart(4, "0")}.png`);
       await this.magick([
         "-size",
         `${maxTextW}x`,
@@ -13442,12 +14321,12 @@ var MediaManager = class {
     for (let i = 0; i < frameCount; i++) {
       const t = i * interval;
       if (t >= totalDur && totalDur > 0) break;
-      const framePath = (0, import_node_path12.join)(frameDir, `frame-${String(i).padStart(3, "0")}.jpg`);
+      const framePath = (0, import_node_path13.join)(frameDir, `frame-${String(i).padStart(3, "0")}.jpg`);
       await this.ffmpeg(["-ss", String(t), "-i", input, "-frames:v", "1", "-q:v", "3", "-y", framePath], TIMEOUT_FAST);
       frames.push({ time: t, path: framePath });
     }
     const transcript = [];
-    if (opts.whisperModel && (0, import_node_fs11.existsSync)(opts.whisperModel) && detectBinary("whisper").available) {
+    if (opts.whisperModel && (0, import_node_fs12.existsSync)(opts.whisperModel) && detectBinary("whisper").available) {
       const whisper = requireBinary("whisper");
       const wavPath = this.outPath("understand-audio", "wav");
       await this.ffmpeg(["-i", input, "-ar", "16000", "-ac", "1", "-c:a", "pcm_s16le", "-y", wavPath], TIMEOUT_FAST);
@@ -13483,7 +14362,7 @@ var MediaManager = class {
     });
     return {
       ok: true,
-      video: (0, import_node_path12.basename)(input),
+      video: (0, import_node_path13.basename)(input),
       duration: totalDur,
       resolution: rotation ? `${vH}x${vW} (rotated ${rotation})` : `${vW}x${vH}`,
       totalFramesExtracted: frames.length,
@@ -13511,11 +14390,11 @@ var MediaManager = class {
     if (!opts.refText || typeof opts.refText !== "string") {
       throw new Error("refText is required for voice_clone (the transcript of the reference audio)");
     }
-    const pythonBin = opts.pythonBin && (0, import_node_path12.isAbsolute)(opts.pythonBin) ? validateInputPath(opts.pythonBin, "pythonBin") : requireBinary("python");
+    const pythonBin = opts.pythonBin && (0, import_node_path13.isAbsolute)(opts.pythonBin) ? validateInputPath(opts.pythonBin, "pythonBin") : requireBinary("python");
     const device = typeof opts.device === "string" && /^[a-z0-9]+$/i.test(opts.device) ? opts.device : "cpu";
     const outWav = this.outPath("voiceclone", "wav");
     const paramsFile = this.outPath("voiceclone-params", "json");
-    (0, import_node_fs11.writeFileSync)(paramsFile, JSON.stringify({
+    (0, import_node_fs12.writeFileSync)(paramsFile, JSON.stringify({
       ref_file: refAudio,
       ref_text: opts.refText,
       gen_text: opts.text,
@@ -13556,7 +14435,7 @@ var MediaManager = class {
           outOgg,
           "-y"
         ]);
-        if ((0, import_node_fs11.existsSync)(outOgg)) return this.fileResult(outOgg, { format: "ogg" });
+        if ((0, import_node_fs12.existsSync)(outOgg)) return this.fileResult(outOgg, { format: "ogg" });
       } catch {
       }
     }
@@ -13566,18 +14445,18 @@ var MediaManager = class {
   /** Parse a whisper-produced SRT (located by stem) into timed segments. */
   parseSrt(srtStem) {
     let srtFile = `${srtStem}.srt`;
-    if (!(0, import_node_fs11.existsSync)(srtFile)) {
-      const dir2 = (0, import_node_path12.dirname)(srtStem);
-      const stem2 = (0, import_node_path12.basename)(srtStem);
+    if (!(0, import_node_fs12.existsSync)(srtFile)) {
+      const dir2 = (0, import_node_path13.dirname)(srtStem);
+      const stem2 = (0, import_node_path13.basename)(srtStem);
       try {
-        const candidates = (0, import_node_fs11.readdirSync)(dir2).filter((f) => f.includes(stem2) && f.endsWith(".srt"));
-        if (candidates.length > 0) srtFile = (0, import_node_path12.join)(dir2, candidates[0]);
+        const candidates = (0, import_node_fs12.readdirSync)(dir2).filter((f) => f.includes(stem2) && f.endsWith(".srt"));
+        if (candidates.length > 0) srtFile = (0, import_node_path13.join)(dir2, candidates[0]);
       } catch {
       }
     }
-    if (!(0, import_node_fs11.existsSync)(srtFile)) return [];
+    if (!(0, import_node_fs12.existsSync)(srtFile)) return [];
     const out = [];
-    const content = (0, import_node_fs11.readFileSync)(srtFile, "utf8");
+    const content = (0, import_node_fs12.readFileSync)(srtFile, "utf8");
     for (const block of content.trim().split(/\n\n+/)) {
       const lines = block.trim().split("\n");
       if (lines.length < 3) continue;
@@ -13593,7 +14472,7 @@ var MediaManager = class {
   /** Unlink a file, swallowing any error (cleanup best-effort). */
   tryUnlink(path2) {
     try {
-      (0, import_node_fs11.unlinkSync)(path2);
+      (0, import_node_fs12.unlinkSync)(path2);
     } catch {
     }
   }
@@ -13601,10 +14480,10 @@ var MediaManager = class {
   tryUnlinkSrt(srtStem) {
     this.tryUnlink(`${srtStem}.srt`);
     try {
-      const dir2 = (0, import_node_path12.dirname)(srtStem);
-      const stem2 = (0, import_node_path12.basename)(srtStem);
-      for (const f of (0, import_node_fs11.readdirSync)(dir2)) {
-        if (f.includes(stem2) && f.endsWith(".srt")) this.tryUnlink((0, import_node_path12.join)(dir2, f));
+      const dir2 = (0, import_node_path13.dirname)(srtStem);
+      const stem2 = (0, import_node_path13.basename)(srtStem);
+      for (const f of (0, import_node_fs12.readdirSync)(dir2)) {
+        if (f.includes(stem2) && f.endsWith(".srt")) this.tryUnlink((0, import_node_path13.join)(dir2, f));
       }
     } catch {
     }
@@ -13612,7 +14491,7 @@ var MediaManager = class {
   /** Recursively remove a directory, swallowing errors. */
   tryRmDir(dir2) {
     try {
-      (0, import_node_fs11.rmSync)(dir2, { recursive: true, force: true });
+      (0, import_node_fs12.rmSync)(dir2, { recursive: true, force: true });
     } catch {
     }
   }
@@ -13652,10 +14531,10 @@ function threadIdFor(input) {
 }
 
 // src/threading/thread-cache.ts
-var import_node_fs12 = require("fs");
-var import_node_os10 = require("os");
-var import_node_path13 = require("path");
-var CACHE_DIR_DEFAULT = (0, import_node_path13.join)((0, import_node_os10.homedir)(), ".agenticmail", "thread-cache");
+var import_node_fs13 = require("fs");
+var import_node_os11 = require("os");
+var import_node_path14 = require("path");
+var CACHE_DIR_DEFAULT = (0, import_node_path14.join)((0, import_node_os11.homedir)(), ".agenticmail", "thread-cache");
 var DEFAULT_K_MESSAGES = 10;
 var DEFAULT_LRU_CAP = 5e3;
 var PREVIEW_MAX_CHARS = 240;
@@ -13668,22 +14547,22 @@ var ThreadCache = class {
     this.k = opts.k ?? DEFAULT_K_MESSAGES;
     this.lruCap = opts.lruCap ?? DEFAULT_LRU_CAP;
     try {
-      (0, import_node_fs12.mkdirSync)(this.dir, { recursive: true });
+      (0, import_node_fs13.mkdirSync)(this.dir, { recursive: true });
     } catch {
     }
   }
   pathFor(threadId) {
-    return (0, import_node_path13.join)(this.dir, `${threadId}.json`);
+    return (0, import_node_path14.join)(this.dir, `${threadId}.json`);
   }
   read(threadId) {
     const p = this.pathFor(threadId);
-    if (!(0, import_node_fs12.existsSync)(p)) return null;
+    if (!(0, import_node_fs13.existsSync)(p)) return null;
     try {
-      const raw = (0, import_node_fs12.readFileSync)(p, "utf-8");
+      const raw = (0, import_node_fs13.readFileSync)(p, "utf-8");
       return JSON.parse(raw);
     } catch {
       try {
-        (0, import_node_fs12.rmSync)(p, { force: true });
+        (0, import_node_fs13.rmSync)(p, { force: true });
       } catch {
       }
       return null;
@@ -13724,7 +14603,7 @@ var ThreadCache = class {
   /** Permanently remove a thread's cache (called on [FINAL] / [DONE] / [CLOSED] / [WRAP]). */
   delete(threadId) {
     try {
-      (0, import_node_fs12.rmSync)(this.pathFor(threadId), { force: true });
+      (0, import_node_fs13.rmSync)(this.pathFor(threadId), { force: true });
     } catch {
     }
   }
@@ -13744,8 +14623,8 @@ var ThreadCache = class {
   writeAtomic(threadId, entry) {
     const p = this.pathFor(threadId);
     const tmp = `${p}.tmp`;
-    (0, import_node_fs12.writeFileSync)(tmp, JSON.stringify(entry), "utf-8");
-    (0, import_node_fs12.renameSync)(tmp, p);
+    (0, import_node_fs13.writeFileSync)(tmp, JSON.stringify(entry), "utf-8");
+    (0, import_node_fs13.renameSync)(tmp, p);
   }
   /**
    * Best-effort LRU eviction. Runs at most every 256 writes (we
@@ -13757,15 +14636,15 @@ var ThreadCache = class {
     if (Math.random() > 1 / 256) return;
     let files;
     try {
-      files = (0, import_node_fs12.readdirSync)(this.dir).filter((f) => f.endsWith(".json"));
+      files = (0, import_node_fs13.readdirSync)(this.dir).filter((f) => f.endsWith(".json"));
     } catch {
       return;
     }
     if (files.length <= this.lruCap) return;
     const stats = files.map((f) => {
-      const p = (0, import_node_path13.join)(this.dir, f);
+      const p = (0, import_node_path14.join)(this.dir, f);
       try {
-        return { p, mtime: (0, import_node_fs12.statSync)(p).mtimeMs };
+        return { p, mtime: (0, import_node_fs13.statSync)(p).mtimeMs };
       } catch {
         return { p, mtime: 0 };
       }
@@ -13774,7 +14653,7 @@ var ThreadCache = class {
     const dropCount = Math.max(1, Math.floor(this.lruCap * 0.1));
     for (let i = 0; i < dropCount; i++) {
       try {
-        (0, import_node_fs12.rmSync)(stats[i].p, { force: true });
+        (0, import_node_fs13.rmSync)(stats[i].p, { force: true });
       } catch {
       }
     }
@@ -13793,30 +14672,30 @@ function dedupAndCap(messages, k) {
 }
 
 // src/threading/agent-memory.ts
-var import_node_fs13 = require("fs");
-var import_node_os11 = require("os");
-var import_node_path14 = require("path");
-var MEMORY_DIR_DEFAULT = (0, import_node_path14.join)((0, import_node_os11.homedir)(), ".agenticmail", "agent-memory");
+var import_node_fs14 = require("fs");
+var import_node_os12 = require("os");
+var import_node_path15 = require("path");
+var MEMORY_DIR_DEFAULT = (0, import_node_path15.join)((0, import_node_os12.homedir)(), ".agenticmail", "agent-memory");
 var AgentMemoryStore = class {
   dir;
   constructor(opts = {}) {
     this.dir = opts.memoryDir ?? MEMORY_DIR_DEFAULT;
     try {
-      (0, import_node_fs13.mkdirSync)(this.dir, { recursive: true });
+      (0, import_node_fs14.mkdirSync)(this.dir, { recursive: true });
     } catch {
     }
   }
   dirFor(agentId) {
-    return (0, import_node_path14.join)(this.dir, sanitizeId(agentId));
+    return (0, import_node_path15.join)(this.dir, sanitizeId(agentId));
   }
   pathFor(agentId, threadId) {
-    return (0, import_node_path14.join)(this.dirFor(agentId), `${sanitizeId(threadId)}.md`);
+    return (0, import_node_path15.join)(this.dirFor(agentId), `${sanitizeId(threadId)}.md`);
   }
   read(agentId, threadId) {
     const p = this.pathFor(agentId, threadId);
-    if (!(0, import_node_fs13.existsSync)(p)) return null;
+    if (!(0, import_node_fs14.existsSync)(p)) return null;
     try {
-      const raw = (0, import_node_fs13.readFileSync)(p, "utf-8");
+      const raw = (0, import_node_fs14.readFileSync)(p, "utf-8");
       const parsed = parse(raw);
       return { ...parsed, raw };
     } catch {
@@ -13826,18 +14705,18 @@ var AgentMemoryStore = class {
   write(agentId, threadId, fields) {
     const agentDir = this.dirFor(agentId);
     try {
-      (0, import_node_fs13.mkdirSync)(agentDir, { recursive: true });
+      (0, import_node_fs14.mkdirSync)(agentDir, { recursive: true });
     } catch {
     }
     const body = render({ ...fields, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
     const p = this.pathFor(agentId, threadId);
     const tmp = `${p}.tmp`;
-    (0, import_node_fs13.writeFileSync)(tmp, body, "utf-8");
-    (0, import_node_fs13.renameSync)(tmp, p);
+    (0, import_node_fs14.writeFileSync)(tmp, body, "utf-8");
+    (0, import_node_fs14.renameSync)(tmp, p);
   }
   delete(agentId, threadId) {
     try {
-      (0, import_node_fs13.rmSync)(this.pathFor(agentId, threadId), { force: true });
+      (0, import_node_fs14.rmSync)(this.pathFor(agentId, threadId), { force: true });
     } catch {
     }
   }
@@ -13880,415 +14759,22 @@ function parse(raw) {
   const out = {};
   const m = raw.match(/^---\n([\s\S]*?)\n---\n/);
   if (m) {
-    for (const line of m[1].split("\n")) {
-      const kv = line.match(/^(\w+):\s*(.*)$/);
-      if (!kv) continue;
-      if (kv[1] === "updated_at") out.updatedAt = kv[2].trim();
-      else if (kv[1] === "last_uid") {
-        const n = parseInt(kv[2], 10);
-        if (!isNaN(n)) out.lastUid = n;
-      }
-    }
-  }
-  return out;
-}
-
-// src/memory/manager.ts
-var import_node_crypto8 = require("crypto");
-
-// src/memory/text-search.ts
-var BM25_K1 = 1.2;
-var BM25_B = 0.75;
-var FIELD_WEIGHT_TITLE = 3;
-var FIELD_WEIGHT_TAGS = 2;
-var FIELD_WEIGHT_CONTENT = 1;
-var PREFIX_MATCH_PENALTY = 0.7;
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "a",
-  "about",
-  "above",
-  "after",
-  "again",
-  "against",
-  "all",
-  "am",
-  "an",
-  "and",
-  "any",
-  "are",
-  "as",
-  "at",
-  "be",
-  "because",
-  "been",
-  "before",
-  "being",
-  "below",
-  "between",
-  "both",
-  "but",
-  "by",
-  "can",
-  "could",
-  "did",
-  "do",
-  "does",
-  "doing",
-  "down",
-  "during",
-  "each",
-  "either",
-  "every",
-  "few",
-  "for",
-  "from",
-  "further",
-  "get",
-  "got",
-  "had",
-  "has",
-  "have",
-  "having",
-  "he",
-  "her",
-  "here",
-  "hers",
-  "herself",
-  "him",
-  "himself",
-  "his",
-  "how",
-  "i",
-  "if",
-  "in",
-  "into",
-  "is",
-  "it",
-  "its",
-  "itself",
-  "just",
-  "may",
-  "me",
-  "might",
-  "more",
-  "most",
-  "must",
-  "my",
-  "myself",
-  "neither",
-  "no",
-  "nor",
-  "not",
-  "now",
-  "of",
-  "off",
-  "on",
-  "once",
-  "only",
-  "or",
-  "other",
-  "ought",
-  "our",
-  "ours",
-  "ourselves",
-  "out",
-  "over",
-  "own",
-  "same",
-  "shall",
-  "she",
-  "should",
-  "so",
-  "some",
-  "such",
-  "than",
-  "that",
-  "the",
-  "their",
-  "theirs",
-  "them",
-  "themselves",
-  "then",
-  "there",
-  "these",
-  "they",
-  "this",
-  "those",
-  "through",
-  "to",
-  "too",
-  "under",
-  "until",
-  "up",
-  "us",
-  "very",
-  "was",
-  "we",
-  "were",
-  "what",
-  "when",
-  "where",
-  "which",
-  "while",
-  "who",
-  "whom",
-  "why",
-  "will",
-  "with",
-  "would",
-  "yet",
-  "you",
-  "your",
-  "yours",
-  "yourself",
-  "yourselves"
-]);
-var STEM_RULES = [
-  // Step 1: plurals and past participles
-  [/ies$/, "i", 3],
-  // policies → polici,eries → eri
-  [/sses$/, "ss", 4],
-  // addresses → address
-  [/([^s])s$/, "$1", 3],
-  // items → item, but not "ss"
-  [/eed$/, "ee", 4],
-  // agreed → agree
-  [/ed$/, "", 3],
-  // configured → configur, but min length 3
-  [/ing$/, "", 4],
-  // running → runn → run (handled below)
-  // Step 2: derivational suffixes
-  [/ational$/, "ate", 6],
-  // relational → relate
-  [/tion$/, "t", 5],
-  // adoption → adopt
-  [/ness$/, "", 5],
-  // awareness → aware
-  [/ment$/, "", 5],
-  // deployment → deploy
-  [/able$/, "", 5],
-  // configurable → configur
-  [/ible$/, "", 5],
-  // accessible → access
-  [/ful$/, "", 5],
-  // powerful → power
-  [/ous$/, "", 5],
-  // dangerous → danger
-  [/ive$/, "", 5],
-  // interactive → interact
-  [/ize$/, "", 4],
-  // normalize → normal
-  [/ise$/, "", 4],
-  // organise → organ
-  [/ally$/, "", 5],
-  // automatically → automat
-  [/ly$/, "", 4],
-  // quickly → quick
-  [/er$/, "", 4]
-  // handler → handl
-];
-var DOUBLE_CONSONANT = /([^aeiou])\1$/;
-function stem(word) {
-  if (word.length < 3) return word;
-  let stemmed = word;
-  for (const [pattern, replacement, minLen] of STEM_RULES) {
-    if (stemmed.length >= minLen && pattern.test(stemmed)) {
-      stemmed = stemmed.replace(pattern, replacement);
-      break;
-    }
-  }
-  if (stemmed.length > 2 && DOUBLE_CONSONANT.test(stemmed)) {
-    stemmed = stemmed.slice(0, -1);
-  }
-  return stemmed;
-}
-function tokenize(text) {
-  return text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 1 && !STOP_WORDS.has(t)).map(stem);
-}
-var MemorySearchIndex = class {
-  /** Posting lists: stemmed term → Set of memory IDs containing it */
-  postings = /* @__PURE__ */ new Map();
-  /** Per-document metadata for BM25 scoring */
-  docs = /* @__PURE__ */ new Map();
-  /** Pre-computed IDF values. Stale flag triggers lazy recomputation. */
-  idf = /* @__PURE__ */ new Map();
-  idfStale = true;
-  /** 3-character prefix map for prefix matching: prefix → Set of full stems */
-  prefixMap = /* @__PURE__ */ new Map();
-  /** Total weighted document length (for computing average) */
-  totalWeightedLen = 0;
-  get docCount() {
-    return this.docs.size;
-  }
-  get avgDocLen() {
-    return this.docs.size > 0 ? this.totalWeightedLen / this.docs.size : 1;
-  }
-  /**
-   * Index a memory entry. Extracts stems from title, content, and tags
-   * with field-specific weighting and builds posting lists.
-   */
-  addDocument(id, entry) {
-    if (this.docs.has(id)) this.removeDocument(id);
-    const titleTokens = tokenize(entry.title);
-    const contentTokens = tokenize(entry.content);
-    const tagTokens = entry.tags.flatMap((t) => tokenize(t));
-    const weightedTf = /* @__PURE__ */ new Map();
-    for (const t of titleTokens) weightedTf.set(t, (weightedTf.get(t) || 0) + FIELD_WEIGHT_TITLE);
-    for (const t of tagTokens) weightedTf.set(t, (weightedTf.get(t) || 0) + FIELD_WEIGHT_TAGS);
-    for (const t of contentTokens) weightedTf.set(t, (weightedTf.get(t) || 0) + FIELD_WEIGHT_CONTENT);
-    const weightedLen = titleTokens.length * FIELD_WEIGHT_TITLE + tagTokens.length * FIELD_WEIGHT_TAGS + contentTokens.length * FIELD_WEIGHT_CONTENT;
-    const allStems = /* @__PURE__ */ new Set();
-    for (const t of weightedTf.keys()) allStems.add(t);
-    const stemSequence = [...titleTokens, ...contentTokens];
-    const docRecord = { weightedTf, weightedLen, allStems, stemSequence };
-    this.docs.set(id, docRecord);
-    this.totalWeightedLen += weightedLen;
-    for (const term of allStems) {
-      let posting = this.postings.get(term);
-      if (!posting) {
-        posting = /* @__PURE__ */ new Set();
-        this.postings.set(term, posting);
-      }
-      posting.add(id);
-      if (term.length >= 3) {
-        const prefix = term.slice(0, 3);
-        let prefixSet = this.prefixMap.get(prefix);
-        if (!prefixSet) {
-          prefixSet = /* @__PURE__ */ new Set();
-          this.prefixMap.set(prefix, prefixSet);
-        }
-        prefixSet.add(term);
-      }
-    }
-    this.idfStale = true;
-  }
-  /** Remove a document from the index. */
-  removeDocument(id) {
-    const doc = this.docs.get(id);
-    if (!doc) return;
-    this.totalWeightedLen -= doc.weightedLen;
-    this.docs.delete(id);
-    for (const term of doc.allStems) {
-      const posting = this.postings.get(term);
-      if (posting) {
-        posting.delete(id);
-        if (posting.size === 0) {
-          this.postings.delete(term);
-          if (term.length >= 3) {
-            const prefixSet = this.prefixMap.get(term.slice(0, 3));
-            if (prefixSet) {
-              prefixSet.delete(term);
-              if (prefixSet.size === 0) this.prefixMap.delete(term.slice(0, 3));
-            }
-          }
-        }
-      }
-    }
-    this.idfStale = true;
-  }
-  /** Recompute IDF values for all terms. Called lazily before search. */
-  refreshIdf() {
-    if (!this.idfStale) return;
-    const N = this.docs.size;
-    this.idf.clear();
-    for (const [term, posting] of this.postings) {
-      const df = posting.size;
-      this.idf.set(term, Math.log((N - df + 0.5) / (df + 0.5) + 1));
-    }
-    this.idfStale = false;
-  }
-  /**
-   * Expand query terms with prefix matches.
-   * "deploy" → ["deploy", "deployment", "deploying", ...] (if they exist in the index)
-   */
-  expandQueryTerms(queryStems) {
-    const expanded = /* @__PURE__ */ new Map();
-    for (const qs of queryStems) {
-      if (this.postings.has(qs)) {
-        expanded.set(qs, Math.max(expanded.get(qs) || 0, 1));
-      }
-      if (qs.length >= 3) {
-        const prefix = qs.slice(0, 3);
-        const candidates = this.prefixMap.get(prefix);
-        if (candidates) {
-          for (const candidate of candidates) {
-            if (candidate !== qs && candidate.startsWith(qs)) {
-              expanded.set(candidate, Math.max(expanded.get(candidate) || 0, PREFIX_MATCH_PENALTY));
-            }
-          }
-        }
-      }
-    }
-    return expanded;
-  }
-  /**
-   * Compute bigram proximity boost: if two query terms appear adjacent
-   * in the document's stem sequence, boost the score.
-   */
-  bigramProximityBoost(docId, queryStems) {
-    if (queryStems.length < 2) return 0;
-    const doc = this.docs.get(docId);
-    if (!doc || doc.stemSequence.length < 2) return 0;
-    let boost = 0;
-    const seq = doc.stemSequence;
-    const querySet = new Set(queryStems);
-    for (let i = 0; i < seq.length - 1; i++) {
-      if (querySet.has(seq[i]) && querySet.has(seq[i + 1]) && seq[i] !== seq[i + 1]) {
-        boost += 0.5;
-      }
-    }
-    return Math.min(boost, 2);
-  }
-  /**
-   * Search the index for documents matching a query.
-   * Returns scored results sorted by BM25F relevance.
-   *
-   * @param query - Raw query string
-   * @param candidateIds - Optional: only score these document IDs (for agent-scoped search)
-   * @returns Array of { id, score } sorted by descending score
-   */
-  search(query, candidateIds) {
-    const queryStems = tokenize(query);
-    if (queryStems.length === 0) return [];
-    this.refreshIdf();
-    const expandedTerms = this.expandQueryTerms(queryStems);
-    if (expandedTerms.size === 0) return [];
-    const avgDl = this.avgDocLen;
-    const candidates = /* @__PURE__ */ new Set();
-    for (const term of expandedTerms.keys()) {
-      const posting = this.postings.get(term);
-      if (posting) {
-        for (const docId of posting) {
-          if (!candidateIds || candidateIds.has(docId)) candidates.add(docId);
-        }
+    for (const line of m[1].split("\n")) {
+      const kv = line.match(/^(\w+):\s*(.*)$/);
+      if (!kv) continue;
+      if (kv[1] === "updated_at") out.updatedAt = kv[2].trim();
+      else if (kv[1] === "last_uid") {
+        const n = parseInt(kv[2], 10);
+        if (!isNaN(n)) out.lastUid = n;
       }
     }
-    const results = [];
-    for (const docId of candidates) {
-      const doc = this.docs.get(docId);
-      if (!doc) continue;
-      let score = 0;
-      for (const [term, weight] of expandedTerms) {
-        const tf = doc.weightedTf.get(term) || 0;
-        if (tf === 0) continue;
-        const termIdf = this.idf.get(term) || 0;
-        const numerator = tf * (BM25_K1 + 1);
-        const denominator = tf + BM25_K1 * (1 - BM25_B + BM25_B * (doc.weightedLen / avgDl));
-        score += termIdf * (numerator / denominator) * weight;
-      }
-      score += this.bigramProximityBoost(docId, queryStems);
-      if (score > 0) results.push({ id: docId, score });
-    }
-    results.sort((a, b) => b.score - a.score);
-    return results;
-  }
-  /** Check if a document exists in the index. */
-  has(id) {
-    return this.docs.has(id);
   }
-};
+  return out;
+}
 
 // src/memory/manager.ts
+var import_node_crypto8 = require("crypto");
+init_text_search();
 function sj(v, fb = {}) {
   if (!v) return fb;
   try {
@@ -14772,284 +15258,11 @@ var AgentMemoryManager = class {
   }
 };
 
-// src/skills/registry.ts
-var import_node_fs14 = require("fs");
-var import_node_path15 = require("path");
-var import_node_url = require("url");
-var import_node_os12 = require("os");
-var import_meta4 = {};
-function builtInDir() {
-  const here = (0, import_node_path15.dirname)((0, import_node_url.fileURLToPath)(import_meta4.url));
-  return (0, import_node_path15.join)(here, "built-in");
-}
-function userDir() {
-  const dir2 = (0, import_node_path15.join)((0, import_node_os12.homedir)(), ".agenticmail", "skills");
-  try {
-    if (!(0, import_node_fs14.existsSync)(dir2)) (0, import_node_fs14.mkdirSync)(dir2, { recursive: true });
-  } catch {
-  }
-  return dir2;
-}
-var cache = { ts: 0, byId: null };
-var CACHE_TTL_MS = 5e3;
-function loadAllSkillsFromDisk() {
-  const all = /* @__PURE__ */ new Map();
-  const dirs = [builtInDir(), userDir()];
-  for (const dir2 of dirs) {
-    if (!(0, import_node_fs14.existsSync)(dir2)) continue;
-    let entries;
-    try {
-      entries = (0, import_node_fs14.readdirSync)(dir2);
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      if (!entry.endsWith(".json")) continue;
-      const fullPath = (0, import_node_path15.join)(dir2, entry);
-      try {
-        const st = (0, import_node_fs14.statSync)(fullPath);
-        if (!st.isFile()) continue;
-        const raw = (0, import_node_fs14.readFileSync)(fullPath, "utf-8");
-        const parsed = JSON.parse(raw);
-        const errors = validateSkill(parsed);
-        if (errors.length > 0) {
-          console.warn(`[skills] ${entry} invalid, skipping: ${errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
-          continue;
-        }
-        all.set(parsed.id, parsed);
-      } catch (err) {
-        console.warn(`[skills] could not load ${fullPath}: ${err.message}`);
-      }
-    }
-  }
-  return all;
-}
-function ensureLoaded() {
-  const now = Date.now();
-  if (cache.byId && now - cache.ts < CACHE_TTL_MS) return cache.byId;
-  const fresh = loadAllSkillsFromDisk();
-  cache.byId = fresh;
-  cache.ts = now;
-  return fresh;
-}
-function invalidateSkillCache() {
-  cache.byId = null;
-  cache.ts = 0;
-}
-function validateSkill(s) {
-  const errs = [];
-  if (!s || typeof s !== "object" || Array.isArray(s)) {
-    return [{ path: "$", message: "skill must be a JSON object" }];
-  }
-  const sk = s;
-  const requireString = (key, minLen = 1) => {
-    const v = sk[key];
-    if (typeof v !== "string" || v.length < minLen) {
-      errs.push({ path: key, message: `must be a non-empty string` });
-    }
-  };
-  const requireArray = (key, minLen = 1) => {
-    const v = sk[key];
-    if (!Array.isArray(v) || v.length < minLen) {
-      errs.push({ path: key, message: `must be a non-empty array` });
-    }
-  };
-  requireString("id");
-  if (typeof sk.id === "string" && !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(sk.id)) {
-    errs.push({ path: "id", message: "must be lowercase-hyphenated slug (a-z, 0-9, -)" });
-  }
-  requireString("name");
-  requireString("version");
-  requireString("description");
-  requireString("category");
-  const validCategories = [
-    "negotiation",
-    "customer-service",
-    "reservations",
-    "medical-admin",
-    "legal-admin",
-    "finance-admin",
-    "real-estate",
-    "travel",
-    "subscription",
-    "home-services",
-    "social",
-    "civic",
-    "employment",
-    "debt-collection",
-    "other"
-  ];
-  if (typeof sk.category === "string" && !validCategories.includes(sk.category)) {
-    errs.push({ path: "category", message: `unknown category "${sk.category}"; must be one of: ${validCategories.join(", ")}` });
-  }
-  if (!Array.isArray(sk.tags)) errs.push({ path: "tags", message: "must be an array of strings" });
-  if (sk.disclaimer !== null && typeof sk.disclaimer !== "string") {
-    errs.push({ path: "disclaimer", message: "must be a string or null" });
-  }
-  if (!sk.context || typeof sk.context !== "object") {
-    errs.push({ path: "context", message: "must be an object" });
-  } else {
-    const ctx = sk.context;
-    if (typeof ctx.when_to_use !== "string") errs.push({ path: "context.when_to_use", message: "must be a string" });
-    if (!Array.isArray(ctx.preconditions)) errs.push({ path: "context.preconditions", message: "must be an array" });
-    if (typeof ctx.estimated_call_duration_minutes !== "number") errs.push({ path: "context.estimated_call_duration_minutes", message: "must be a number" });
-  }
-  requireArray("principles", 2);
-  if (!sk.phrases || typeof sk.phrases !== "object") errs.push({ path: "phrases", message: "must be an object of {key: phrase}" });
-  if (!Array.isArray(sk.tactics) || sk.tactics.length === 0) {
-    errs.push({ path: "tactics", message: "must be a non-empty array" });
-  } else {
-    sk.tactics.forEach((t, i) => {
-      if (!t || typeof t !== "object") {
-        errs.push({ path: `tactics[${i}]`, message: "must be an object" });
-        return;
-      }
-      const tactic = t;
-      if (typeof tactic.name !== "string") errs.push({ path: `tactics[${i}].name`, message: "must be a string" });
-      if (typeof tactic.when !== "string") errs.push({ path: `tactics[${i}].when`, message: "must be a string" });
-      if (typeof tactic.script !== "string" || tactic.script.length < 5) {
-        errs.push({ path: `tactics[${i}].script`, message: "must be a non-empty string (>= 5 chars)" });
-      }
-    });
-  }
-  requireArray("boundaries", 1);
-  if (!Array.isArray(sk.success_signals)) errs.push({ path: "success_signals", message: "must be an array" });
-  if (!Array.isArray(sk.failure_signals)) errs.push({ path: "failure_signals", message: "must be an array" });
-  if (!sk.exit_strategy || typeof sk.exit_strategy !== "object") {
-    errs.push({ path: "exit_strategy", message: "must be an object" });
-  } else {
-    const xs = sk.exit_strategy;
-    if (typeof xs.on_success !== "string") errs.push({ path: "exit_strategy.on_success", message: "must be a string" });
-    if (typeof xs.on_failure !== "string") errs.push({ path: "exit_strategy.on_failure", message: "must be a string" });
-  }
-  if (!Array.isArray(sk.required_user_info)) errs.push({ path: "required_user_info", message: "must be an array" });
-  if (typeof sk.contributed_by !== "string") errs.push({ path: "contributed_by", message: "must be a string" });
-  return errs;
-}
-function summarize(s) {
-  return {
-    id: s.id,
-    name: s.name,
-    category: s.category,
-    tags: s.tags,
-    description: s.description,
-    version: s.version,
-    disclaimer_required: !!s.disclaimer,
-    estimated_call_duration_minutes: s.context.estimated_call_duration_minutes
-  };
-}
-function listSkills(opts = {}) {
-  const all = Array.from(ensureLoaded().values());
-  const filtered = all.filter((s) => {
-    if (opts.category && s.category !== opts.category) return false;
-    if (opts.tag && !s.tags.includes(opts.tag.toLowerCase())) return false;
-    return true;
-  });
-  return filtered.sort((a, b) => a.name.localeCompare(b.name)).map(summarize);
-}
-function searchSkills(query, limit = 20) {
-  const q = query.toLowerCase().trim();
-  if (!q) return listSkills();
-  const all = Array.from(ensureLoaded().values());
-  const scored = [];
-  for (const s of all) {
-    let score = 0;
-    if (s.id.toLowerCase().includes(q)) score += 10;
-    if (s.name.toLowerCase().includes(q)) score += 8;
-    if (s.tags.some((t) => t.toLowerCase().includes(q))) score += 5;
-    if (s.category.toLowerCase().includes(q)) score += 4;
-    if (s.description.toLowerCase().includes(q)) score += 3;
-    if (s.principles.some((p) => p.toLowerCase().includes(q))) score += 2;
-    if (Object.values(s.phrases).some((p) => p.toLowerCase().includes(q))) score += 2;
-    if (s.tactics.some((t) => t.script.toLowerCase().includes(q) || t.name.toLowerCase().includes(q))) score += 2;
-    if (score > 0) scored.push({ skill: s, score });
-  }
-  scored.sort((a, b) => b.score - a.score || a.skill.name.localeCompare(b.skill.name));
-  return scored.slice(0, limit).map((x) => summarize(x.skill));
-}
-function loadSkill(id) {
-  return ensureLoaded().get(id) ?? null;
-}
-function saveUserSkill(skill) {
-  const errors = validateSkill(skill);
-  if (errors.length > 0) {
-    throw new Error(`skill validation failed: ${errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
-  }
-  const dir2 = userDir();
-  const path2 = (0, import_node_path15.join)(dir2, `${skill.id}.json`);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const out = {
-    ...skill,
-    created_at: skill.created_at ?? now,
-    updated_at: now
-  };
-  (0, import_node_fs14.writeFileSync)(path2, JSON.stringify(out, null, 2), "utf-8");
-  invalidateSkillCache();
-  return { path: path2 };
-}
-function userSkillsDir() {
-  return userDir();
-}
+// src/memory/index.ts
+init_text_search();
 
-// src/skills/index.ts
-function renderSkillAsPrompt(skill) {
-  const lines = [];
-  lines.push(`=== SKILL LOADED: ${skill.name} (v${skill.version}) ===`);
-  lines.push(`Category: ${skill.category}    Tags: ${skill.tags.join(", ")}`);
-  lines.push("");
-  lines.push(skill.description);
-  lines.push("");
-  if (skill.disclaimer) {
-    lines.push("REQUIRED DISCLAIMER (recite at start of the substantive turn):");
-    lines.push(`  "${skill.disclaimer}"`);
-    lines.push("");
-  }
-  lines.push("WHEN TO USE THIS:");
-  lines.push(`  ${skill.context.when_to_use}`);
-  if (skill.context.preconditions.length > 0) {
-    lines.push("Preconditions:");
-    for (const p of skill.context.preconditions) lines.push(`  - ${p}`);
-  }
-  lines.push("");
-  lines.push("PRINCIPLES:");
-  for (const p of skill.principles) lines.push(`  - ${p}`);
-  lines.push("");
-  if (Object.keys(skill.phrases).length > 0) {
-    lines.push("PHRASES (paraphrase to match your voice; keep the structural move):");
-    for (const [k, v] of Object.entries(skill.phrases)) lines.push(`  [${k}] "${v}"`);
-    lines.push("");
-  }
-  if (skill.tactics.length > 0) {
-    lines.push("TACTICS (try in order; fall back to next on failure):");
-    skill.tactics.forEach((t, i) => {
-      lines.push(`  ${i + 1}. ${t.name}`);
-      lines.push(`     When: ${t.when}`);
-      lines.push(`     Script: "${t.script}"`);
-    });
-    lines.push("");
-  }
-  if (skill.boundaries.length > 0) {
-    lines.push("HARD BOUNDARIES \u2014 do not cross:");
-    for (const b of skill.boundaries) lines.push(`  - ${b}`);
-    lines.push("");
-  }
-  lines.push("SUCCESS SIGNALS:");
-  for (const s of skill.success_signals) lines.push(`  - ${s}`);
-  lines.push("");
-  lines.push("FAILURE SIGNALS \u2014 when these appear, escalate or exit:");
-  for (const s of skill.failure_signals) lines.push(`  - ${s}`);
-  lines.push("");
-  lines.push("EXIT:");
-  lines.push(`  On success: ${skill.exit_strategy.on_success}`);
-  lines.push(`  On failure: ${skill.exit_strategy.on_failure}`);
-  if (skill.exit_strategy.follow_ups && skill.exit_strategy.follow_ups.length > 0) {
-    lines.push("  Follow-ups (after the call):");
-    for (const f of skill.exit_strategy.follow_ups) lines.push(`    - ${f}`);
-  }
-  lines.push("");
-  lines.push("=== END SKILL ===");
-  return lines.join("\n");
-}
+// src/index.ts
+init_skills();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_ROLES,
@@ -15080,6 +15293,7 @@ function renderSkillAsPrompt(skill) {
   GET_DATETIME_TOOL,
   GatewayManager,
   InboxWatcher,
+  LOAD_SKILL_TOOL,
   MEMORY_CATEGORIES,
   MailReceiver,
   MailSender,
@@ -15116,6 +15330,7 @@ function renderSkillAsPrompt(skill) {
   RelayBridge,
   RelayGateway,
   SEARCH_EMAIL_TOOL,
+  SEARCH_SKILLS_TOOL,
   SPAM_THRESHOLD,
   ServiceManager,
   SetupManager,