@agenticmail/core 0.9.24 → 0.9.25

package/dist/chunk-J6JINNJ3.js

@@ -0,0 +1,724 @@
+// src/skills/registry.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
+import { join, dirname, basename } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+
+// 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);
+        }
+      }
+    }
+    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 = dirname(fileURLToPath(import.meta.url));
+  return join(here, "built-in");
+}
+function userDir() {
+  const dir = join(homedir(), ".agenticmail", "skills");
+  try {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  } catch {
+  }
+  return dir;
+}
+var cache = { ts: 0, byId: null, index: null };
+var CACHE_TTL_MS = 5e3;
+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 dir of dirs) {
+    if (!existsSync(dir)) continue;
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".json")) continue;
+      const fullPath = join(dir, entry);
+      try {
+        const st = statSync(fullPath);
+        if (!st.isFile()) continue;
+        const raw = 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 dir = userDir();
+  const path = join(dir, `${skill.id}.json`);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const out = {
+    ...skill,
+    created_at: skill.created_at ?? now,
+    updated_at: now
+  };
+  writeFileSync(path, JSON.stringify(out, null, 2), "utf-8");
+  invalidateSkillCache();
+  return { path };
+}
+function skillFilename(id) {
+  return `${basename(id)}.json`;
+}
+function userSkillsDir() {
+  return userDir();
+}
+
+// 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");
+}
+
+export {
+  stem,
+  tokenize,
+  MemorySearchIndex,
+  invalidateSkillCache,
+  validateSkill,
+  listSkills,
+  searchSkills,
+  loadSkill,
+  saveUserSkill,
+  skillFilename,
+  userSkillsDir,
+  renderSkillAsPrompt
+};