skill-tree 0.1.7 → 0.2.0

package/dist/index.mjs

@@ -8,11 +8,25 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename, getDirname, __dirname;
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
+  }
+});
+
 // src/storage/base.ts
 var BaseStorageAdapter, MemoryStorageAdapter;
 var init_base = __esm({
   "src/storage/base.ts"() {
     "use strict";
+    init_esm_shims();
     BaseStorageAdapter = class {
       constructor() {
         this.initialized = false;
@@ -41,9 +55,6 @@ var init_base = __esm({
           if (filter.author && skill.author !== filter.author) {
             return false;
           }
-          if (filter.minSuccessRate !== void 0 && skill.metrics.successRate < filter.minSuccessRate) {
-            return false;
-          }
           if (filter.createdAfter && skill.createdAt < filter.createdAfter) {
             return false;
           }
@@ -282,12 +293,13 @@ __export(sqlite_exports, {
   SQLiteStorageAdapter: () => SQLiteStorageAdapter
 });
 import Database from "better-sqlite3";
-import * as path7 from "path";
+import * as path8 from "path";
 import * as fs7 from "fs";
 var SCHEMA_VERSION, SQLiteStorageAdapter;
 var init_sqlite = __esm({
   "src/storage/sqlite.ts"() {
     "use strict";
+    init_esm_shims();
     init_base();
     SCHEMA_VERSION = 3;
     SQLiteStorageAdapter = class extends BaseStorageAdapter {
@@ -301,7 +313,7 @@ var init_sqlite = __esm({
         };
       }
       async initialize() {
-        const dir = path7.dirname(this.config.dbPath);
+        const dir = path8.dirname(this.config.dbPath);
         if (dir && !fs7.existsSync(dir)) {
           fs7.mkdirSync(dir, { recursive: true });
         }
@@ -336,12 +348,19 @@ var init_sqlite = __esm({
         status TEXT NOT NULL,
         parent_version TEXT,
         derived_from TEXT,
-        metrics TEXT NOT NULL,
         source TEXT,
         taxonomy TEXT,
         external_source TEXT
       )
     `);
+        try {
+          db.exec("ALTER TABLE skills DROP COLUMN metrics");
+        } catch {
+          const cols = db.prepare("PRAGMA table_info(skills)").all();
+          if (cols.some((c) => c.name === "metrics")) {
+            this.rebuildSkillsTableWithoutMetrics(db, cols);
+          }
+        }
         db.exec(`
       CREATE TABLE IF NOT EXISTS skill_versions (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -505,6 +524,75 @@ var init_sqlite = __esm({
           db.prepare("UPDATE schema_version SET version = ?").run(SCHEMA_VERSION);
         }
       }
+      /**
+       * Rebuild the `skills` table without the legacy `metrics` column.
+       *
+       * Used as the fallback path on SQLite < 3.35 where ALTER TABLE DROP
+       * COLUMN isn't supported. Uses the standard "table dance" pattern:
+       * CREATE NEW → INSERT FROM OLD → DROP OLD → RENAME, inside a single
+       * transaction so a partial state can't outlive a crash.
+       *
+       * The `existingCols` arg is the full PRAGMA table_info output for the
+       * legacy table — we use it to figure out which columns to copy. Some
+       * legacy installs may have a subset of the current schema's columns
+       * (e.g., taxonomy/external_source were added in v2, related in v3),
+       * so we only copy columns that exist on both sides.
+       */
+      rebuildSkillsTableWithoutMetrics(db, existingCols) {
+        const NEW_SCHEMA_COLUMNS = [
+          "id",
+          "version",
+          "name",
+          "description",
+          "instructions",
+          "related",
+          "author",
+          "tags",
+          "created_at",
+          "updated_at",
+          "status",
+          "parent_version",
+          "derived_from",
+          "source",
+          "taxonomy",
+          "external_source"
+        ];
+        const sourceNames = new Set(existingCols.map((c) => c.name));
+        const copyable = NEW_SCHEMA_COLUMNS.filter((c) => sourceNames.has(c));
+        const copyList = copyable.join(", ");
+        db.exec("BEGIN");
+        try {
+          db.exec(`
+        CREATE TABLE skills_new (
+          id TEXT PRIMARY KEY,
+          version TEXT NOT NULL,
+          name TEXT NOT NULL,
+          description TEXT,
+          instructions TEXT NOT NULL DEFAULT '',
+          related TEXT,
+          author TEXT NOT NULL,
+          tags TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          status TEXT NOT NULL,
+          parent_version TEXT,
+          derived_from TEXT,
+          source TEXT,
+          taxonomy TEXT,
+          external_source TEXT
+        )
+      `);
+          db.exec(
+            `INSERT INTO skills_new (${copyList}) SELECT ${copyList} FROM skills`
+          );
+          db.exec("DROP TABLE skills");
+          db.exec("ALTER TABLE skills_new RENAME TO skills");
+          db.exec("COMMIT");
+        } catch (err) {
+          db.exec("ROLLBACK");
+          throw err;
+        }
+      }
       getDb() {
         if (!this.db) {
           throw new Error("Database not initialized. Call initialize() first.");
@@ -517,10 +605,10 @@ var init_sqlite = __esm({
         const stmt = db.prepare(`
       INSERT OR REPLACE INTO skills (
         id, version, name, description, instructions, related, author, tags,
-        created_at, updated_at, status, parent_version, derived_from, metrics,
+        created_at, updated_at, status, parent_version, derived_from,
         source, taxonomy, external_source
       ) VALUES (
-        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
       )
     `);
         stmt.run(
@@ -537,7 +625,6 @@ var init_sqlite = __esm({
           skill.status,
           skill.parentVersion || null,
           skill.derivedFrom ? JSON.stringify(skill.derivedFrom) : null,
-          JSON.stringify(skill.metrics),
           skill.source ? JSON.stringify(skill.source) : null,
           skill.taxonomy ? JSON.stringify(skill.taxonomy) : null,
           skill.externalSource ? JSON.stringify({
@@ -632,10 +719,6 @@ var init_sqlite = __esm({
           sql += " AND author = ?";
           params.push(filter.author);
         }
-        if (filter?.minSuccessRate !== void 0) {
-          sql += " AND json_extract(metrics, '$.successRate') >= ?";
-          params.push(filter.minSuccessRate);
-        }
         if (filter?.createdAfter) {
           sql += " AND created_at >= ?";
           params.push(filter.createdAfter.toISOString());
@@ -831,15 +914,15 @@ var init_sqlite = __esm({
       /**
        * Get or create a taxonomy node
        */
-      async ensureTaxonomyNode(path13) {
+      async ensureTaxonomyNode(path14) {
         this.ensureInitialized();
         const db = this.getDb();
-        const pathStr = path13.join("/");
+        const pathStr = path14.join("/");
         const existing = db.prepare("SELECT id FROM taxonomy_nodes WHERE path = ?").get(pathStr);
         if (existing) return existing.id;
         const id = `node-${pathStr.replace(/\//g, "-").toLowerCase()}`;
-        const name = path13[path13.length - 1] || "Root";
-        const parentPath = path13.slice(0, -1);
+        const name = path14[path14.length - 1] || "Root";
+        const parentPath = path14.slice(0, -1);
         let parentId = null;
         if (parentPath.length > 0) {
           parentId = await this.ensureTaxonomyNode(parentPath);
@@ -1030,7 +1113,6 @@ var init_sqlite = __esm({
           status: row.status,
           parentVersion: row.parent_version || void 0,
           derivedFrom: row.derived_from ? JSON.parse(row.derived_from) : void 0,
-          metrics: JSON.parse(row.metrics),
           source: row.source ? JSON.parse(row.source) : void 0,
           taxonomy: row.taxonomy ? JSON.parse(row.taxonomy) : void 0,
           externalSource: externalSource ? {
@@ -1047,11 +1129,7 @@ var init_sqlite = __esm({
           source: skill.source ? {
             ...skill.source,
             importedAt: skill.source.importedAt.toISOString()
-          } : void 0,
-          metrics: {
-            ...skill.metrics,
-            lastUsed: skill.metrics.lastUsed?.toISOString()
-          }
+          } : void 0
         };
       }
       deserializeSkill(data) {
@@ -1062,11 +1140,7 @@ var init_sqlite = __esm({
           source: data.source ? {
             ...data.source,
             importedAt: new Date(data.source.importedAt)
-          } : void 0,
-          metrics: {
-            ...data.metrics,
-            lastUsed: data.metrics.lastUsed ? new Date(data.metrics.lastUsed) : void 0
-          }
+          } : void 0
         };
       }
       hashSkill(skill) {
@@ -1090,6 +1164,7 @@ var DEFAULT_AGENTS_CONFIG;
 var init_types = __esm({
   "src/agents/types.ts"() {
     "use strict";
+    init_esm_shims();
     DEFAULT_AGENTS_CONFIG = {
       format: "xml",
       includeIds: true,
@@ -1107,6 +1182,7 @@ var AgentsGenerator;
 var init_generator = __esm({
   "src/agents/generator.ts"() {
     "use strict";
+    init_esm_shims();
     init_types();
     AgentsGenerator = class {
       constructor(config) {
@@ -1275,9 +1351,6 @@ ${this.indentContent(skill.instructions, 4)}
         if (filter.tags && filter.tags.length > 0) {
           result = result.filter((s) => s.tags.some((t) => filter.tags.includes(t)));
         }
-        if (filter.minSuccessRate !== void 0) {
-          result = result.filter((s) => s.metrics.successRate >= filter.minSuccessRate);
-        }
         if (filter.limit) {
           result = result.slice(0, filter.limit);
         }
@@ -1324,6 +1397,7 @@ var AgentsParser;
 var init_parser = __esm({
   "src/agents/parser.ts"() {
     "use strict";
+    init_esm_shims();
     AgentsParser = class {
       /**
        * Parse AGENTS.md content
@@ -1377,11 +1451,6 @@ var init_parser = __esm({
           createdAt: defaults?.createdAt || now,
           updatedAt: now,
           status: "active",
-          metrics: defaults?.metrics || {
-            usageCount: 0,
-            successRate: 0,
-            feedbackScores: []
-          },
           source: {
             type: "imported",
             location: "AGENTS.md",
@@ -1564,7 +1633,7 @@ __export(sync_exports, {
   writeAgentsMd: () => writeAgentsMd
 });
 import * as fs9 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 function createAgentsSync() {
   return new AgentsSync();
 }
@@ -1574,7 +1643,7 @@ async function generateAgentsMd(storage, config) {
 }
 async function writeAgentsMd(storage, filePath, config) {
   const content = await generateAgentsMd(storage, config);
-  const dir = path9.dirname(filePath);
+  const dir = path10.dirname(filePath);
   if (dir && !fs9.existsSync(dir)) {
     fs9.mkdirSync(dir, { recursive: true });
   }
@@ -1592,6 +1661,7 @@ var AgentsSync;
 var init_sync = __esm({
   "src/agents/sync.ts"() {
     "use strict";
+    init_esm_shims();
     init_generator();
     init_parser();
     AgentsSync = class {
@@ -1697,7 +1767,7 @@ var init_sync = __esm({
           }
         }
         if (!options.dryRun) {
-          const dir = path9.dirname(agentsPath);
+          const dir = path10.dirname(agentsPath);
           if (!fs9.existsSync(dir)) {
             fs9.mkdirSync(dir, { recursive: true });
           }
@@ -1749,8 +1819,6 @@ var init_sync = __esm({
           // Keep existing ID
           createdAt: existing.createdAt,
           // Preserve creation date
-          metrics: existing.metrics,
-          // Preserve usage metrics
           source: incoming.source || existing.source,
           parentVersion: existing.version
           // Track update lineage
@@ -1760,7 +1828,14 @@ var init_sync = __esm({
   }
 });
 
+// src/index.ts
+init_esm_shims();
+
+// src/skill-bank.ts
+init_esm_shims();
+
 // src/types.ts
+init_esm_shims();
 function hasTaxonomySupport(storage) {
   return typeof storage.placeInTaxonomy === "function";
 }
@@ -1768,18 +1843,23 @@ function hasForkSupport(storage) {
   return typeof storage.recordFork === "function";
 }
 
+// src/sync/sync-manager.ts
+init_esm_shims();
+
 // src/sync/git-sync-adapter.ts
+init_esm_shims();
 import * as fs2 from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
 
 // src/sync/conflict-store.ts
+init_esm_shims();
 import * as fs from "fs";
-import * as path from "path";
+import * as path2 from "path";
 var ConflictStore = class {
   constructor(basePath) {
-    const skillbankDir = path.join(basePath, ".skillbank");
-    this.conflictsDir = path.join(skillbankDir, "conflicts");
-    this.stateFile = path.join(skillbankDir, "sync-state.json");
+    const skillbankDir = path2.join(basePath, ".skillbank");
+    this.conflictsDir = path2.join(skillbankDir, "conflicts");
+    this.stateFile = path2.join(skillbankDir, "sync-state.json");
   }
   /**
    * Initialize the store (create directories if needed)
@@ -1796,7 +1876,7 @@ var ConflictStore = class {
   async saveConflict(conflict) {
     await this.initialize();
     const filename = this.getConflictFilename(conflict.skillId);
-    const filepath = path.join(this.conflictsDir, filename);
+    const filepath = path2.join(this.conflictsDir, filename);
     const data = JSON.stringify(this.serializeConflict(conflict), null, 2);
     await fs.promises.writeFile(filepath, data, "utf-8");
   }
@@ -1805,7 +1885,7 @@ var ConflictStore = class {
    */
   async getConflict(skillId) {
     const filename = this.getConflictFilename(skillId);
-    const filepath = path.join(this.conflictsDir, filename);
+    const filepath = path2.join(this.conflictsDir, filename);
     try {
       const data = await fs.promises.readFile(filepath, "utf-8");
       return this.deserializeConflict(JSON.parse(data));
@@ -1826,7 +1906,7 @@ var ConflictStore = class {
       const conflicts = [];
       for (const file of files) {
         if (file.endsWith(".json")) {
-          const filepath = path.join(this.conflictsDir, file);
+          const filepath = path2.join(this.conflictsDir, file);
           try {
             const data = await fs.promises.readFile(filepath, "utf-8");
             conflicts.push(this.deserializeConflict(JSON.parse(data)));
@@ -1849,7 +1929,7 @@ var ConflictStore = class {
    */
   async removeConflict(skillId) {
     const filename = this.getConflictFilename(skillId);
-    const filepath = path.join(this.conflictsDir, filename);
+    const filepath = path2.join(this.conflictsDir, filename);
     try {
       await fs.promises.unlink(filepath);
       return true;
@@ -1988,10 +2068,6 @@ var ConflictStore = class {
       ...skill,
       createdAt: skill.createdAt instanceof Date ? skill.createdAt.toISOString() : skill.createdAt,
       updatedAt: skill.updatedAt instanceof Date ? skill.updatedAt.toISOString() : skill.updatedAt,
-      metrics: {
-        ...skill.metrics,
-        lastUsed: skill.metrics?.lastUsed instanceof Date ? skill.metrics.lastUsed.toISOString() : skill.metrics?.lastUsed
-      },
       source: skill.source ? {
         ...skill.source,
         importedAt: skill.source.importedAt instanceof Date ? skill.source.importedAt.toISOString() : skill.source.importedAt
@@ -2003,10 +2079,6 @@ var ConflictStore = class {
       ...data,
       createdAt: new Date(data.createdAt),
       updatedAt: new Date(data.updatedAt),
-      metrics: {
-        ...data.metrics,
-        lastUsed: data.metrics?.lastUsed ? new Date(data.metrics.lastUsed) : void 0
-      },
       source: data.source ? {
         ...data.source,
         importedAt: new Date(data.source.importedAt)
@@ -2077,7 +2149,7 @@ var GitSyncAdapter = class {
     for (const file of changedFiles) {
       const skillId = this.extractSkillIdFromPath(file);
       if (!skillId) continue;
-      const localPath = path2.join(this.repoPath, file);
+      const localPath = path3.join(this.repoPath, file);
       const existsLocally = fs2.existsSync(localPath);
       let existsRemotely = true;
       try {
@@ -2364,7 +2436,7 @@ var GitSyncAdapter = class {
     return this.config.remote.skillsPath || "skills/";
   }
   getSkillFilePath(skillId) {
-    return path2.join(this.getSkillsPath(), skillId, "SKILL.md");
+    return path3.join(this.getSkillsPath(), skillId, "SKILL.md");
   }
   extractSkillIdFromPath(filePath) {
     const skillsPath = this.getSkillsPath();
@@ -2378,7 +2450,7 @@ var GitSyncAdapter = class {
   }
   async pullSkill(skillId, branch, syncState, options) {
     const skillPath = this.getSkillFilePath(skillId);
-    const fullPath = path2.join(this.repoPath, skillPath);
+    const fullPath = path3.join(this.repoPath, skillPath);
     let remoteContent;
     try {
       remoteContent = await this.git.show([`origin/${branch}:${skillPath}`]);
@@ -2576,18 +2648,13 @@ ${remoteValue}`;
       tags: metadata.tags ? metadata.tags.split(",").map((t) => t.trim()) : [],
       createdAt: metadata.created ? new Date(metadata.created) : /* @__PURE__ */ new Date(),
       updatedAt: metadata.updated ? new Date(metadata.updated) : /* @__PURE__ */ new Date(),
-      status: isValidStatus(metadata.status) ? metadata.status : "active",
-      metrics: {
-        usageCount: 0,
-        successRate: 0,
-        feedbackScores: []
-      }
+      status: isValidStatus(metadata.status) ? metadata.status : "active"
     };
   }
   async writeSkill(skill) {
     const skillPath = this.getSkillFilePath(skill.id);
-    const fullPath = path2.join(this.repoPath, skillPath);
-    await fs2.promises.mkdir(path2.dirname(fullPath), { recursive: true });
+    const fullPath = path3.join(this.repoPath, skillPath);
+    await fs2.promises.mkdir(path3.dirname(fullPath), { recursive: true });
     const content = this.buildSkillContent(skill);
     await fs2.promises.writeFile(fullPath, content, "utf-8");
   }
@@ -2638,11 +2705,11 @@ ${body.join("\n")}
       agent: this.config.agent,
       skills: {}
     };
-    const skillsPath = path2.join(this.repoPath, this.getSkillsPath());
+    const skillsPath = path3.join(this.repoPath, this.getSkillsPath());
     if (fs2.existsSync(skillsPath)) {
       const dirs = await fs2.promises.readdir(skillsPath);
       for (const dir of dirs) {
-        const skillPath = path2.join(skillsPath, dir, "SKILL.md");
+        const skillPath = path3.join(skillsPath, dir, "SKILL.md");
         if (fs2.existsSync(skillPath)) {
           try {
             const content = await fs2.promises.readFile(skillPath, "utf-8");
@@ -2842,7 +2909,14 @@ function createSyncManager(options) {
   return new SyncManager(options);
 }
 
+// src/serving/graph-server.ts
+init_esm_shims();
+
+// src/serving/catalog-renderer.ts
+init_esm_shims();
+
 // src/serving/xml-utils.ts
+init_esm_shims();
 function escapeXml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
@@ -2910,11 +2984,11 @@ var CatalogRenderer = class _CatalogRenderer {
    * Render a specific category path for browse drill-down.
    * Shows subcategories at intermediate nodes, or skill summaries at leaf nodes.
    */
-  async renderCategory(path13) {
+  async renderCategory(path14) {
     if (hasCatalogSupport(this.storage)) {
-      return this.renderCategoryFromTaxonomy(this.storage, path13);
+      return this.renderCategoryFromTaxonomy(this.storage, path14);
     }
-    return this.renderCategoryFromTags(path13);
+    return this.renderCategoryFromTags(path14);
   }
   /**
    * Invalidate the overview cache (e.g., after skill changes).
@@ -2952,9 +3026,9 @@ var CatalogRenderer = class _CatalogRenderer {
     const categories = counted.sort((a, b) => b.count - a.count).slice(0, this.config.maxCategoriesPerLevel).map((c) => ({ name: c.node.name, count: c.count }));
     return this.renderOverviewXml(totalSkills, categories);
   }
-  async renderCategoryFromTaxonomy(storage, path13) {
-    const tree = await storage.getTaxonomyTree(path13);
-    const pathStr = path13.join("/");
+  async renderCategoryFromTaxonomy(storage, path14) {
+    const tree = await storage.getTaxonomyTree(path14);
+    const pathStr = path14.join("/");
     if (tree.length > 0 && tree.some((n) => n.children.length > 0)) {
       const root = tree[0];
       const rootCount = this.countNodeSkills(root);
@@ -2964,7 +3038,7 @@ var CatalogRenderer = class _CatalogRenderer {
       lines.push(`<catalog_browse path="${escapeXml(pathStr)}" count="${rootCount}">`);
       lines.push("  <subcategories>");
       for (const { node: child, count } of children) {
-        const childPath = [...path13, child.name].join("/");
+        const childPath = [...path14, child.name].join("/");
         lines.push(`    <category path="${escapeXml(childPath)}" count="${count}" />`);
       }
       lines.push("  </subcategories>");
@@ -2988,13 +3062,13 @@ var CatalogRenderer = class _CatalogRenderer {
     const categories = Array.from(tagCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, this.config.maxCategoriesPerLevel).map(([name, count]) => ({ name, count }));
     return this.renderOverviewXml(skills.length, categories);
   }
-  async renderCategoryFromTags(path13) {
-    if (path13.length === 0) {
+  async renderCategoryFromTags(path14) {
+    if (path14.length === 0) {
       return this.renderOverviewFromTags();
     }
-    const tag = path13[0];
+    const tag = path14[0];
     const matching = await this.storage.listSkills({ status: ["active"], tags: [tag] });
-    const pathStr = path13.join("/");
+    const pathStr = path14.join("/");
     return this.renderLeafSkills(matching, pathStr, matching.length);
   }
   // ===========================================================================
@@ -3049,6 +3123,7 @@ var CatalogRenderer = class _CatalogRenderer {
 };
 
 // src/serving/loadout-compiler.ts
+init_esm_shims();
 var DEFAULT_CONFIG2 = {
   defaultMaxSkills: 15,
   defaultStatus: ["active"],
@@ -3063,7 +3138,24 @@ var LoadoutCompiler = class {
     };
   }
   /**
-   * Main entry point - compile skills from criteria
+   * Main entry point - compile skills from criteria.
+   *
+   * Filter pipeline order:
+   *   1. status (initial query)
+   *   2. exclude (drop matching IDs)
+   *   3. tags / tagsAll
+   *   4. author
+   *   5. semantic (currently no-op)
+   *   6. relationships (rootSkills traversal)
+   *   7. **include** — presence guarantee: ensures every ID in the
+   *      include list is in the result regardless of the filters above,
+   *      fetching missing ones from storage as needed. `exclude` still
+   *      wins (excluded IDs are removed from the include list before
+   *      this step).
+   *   8. limits (maxSkills, maxTokens)
+   *
+   * For "restrict to exactly these skills" semantics, combine
+   * `include: [...]` with `maxSkills: include.length`.
    */
   async compile(criteria) {
     const status = criteria.status ?? this.config.defaultStatus;
@@ -3073,6 +3165,7 @@ var LoadoutCompiler = class {
     candidates = this.applyQualityFilters(candidates, criteria);
     candidates = await this.applySemanticFilters(candidates, criteria);
     candidates = await this.applyRelationshipFilters(candidates, criteria);
+    candidates = await this.ensureIncludedPresent(candidates, criteria);
     candidates = this.applyLimits(candidates, criteria);
     return candidates;
   }
@@ -3118,7 +3211,9 @@ var LoadoutCompiler = class {
   // Filter Methods
   // ===========================================================================
   /**
-   * Apply explicit include/exclude filters
+   * Apply explicit exclude filter. Include is handled separately at the
+   * compile level (see `ensureIncludedPresent`) so it can guarantee
+   * presence regardless of the other filters in this method or below.
    */
   applyExplicitFilters(skills, criteria) {
     let result = skills;
@@ -3126,15 +3221,6 @@ var LoadoutCompiler = class {
       const excludeSet = new Set(criteria.exclude);
       result = result.filter((s) => !excludeSet.has(s.id));
     }
-    if (criteria.include && criteria.include.length > 0) {
-      const includeSet = new Set(criteria.include);
-      const currentIds = new Set(result.map((s) => s.id));
-      const includedSkills = result.filter((s) => includeSet.has(s.id));
-      const otherSkills = result.filter((s) => !includeSet.has(s.id));
-      if (includedSkills.length > 0) {
-        result = [...includedSkills, ...otherSkills];
-      }
-    }
     return result;
   }
   /**
@@ -3158,11 +3244,6 @@ var LoadoutCompiler = class {
    */
   applyQualityFilters(skills, criteria) {
     let result = skills;
-    if (criteria.minSuccessRate !== void 0) {
-      result = result.filter(
-        (s) => s.metrics.successRate >= criteria.minSuccessRate
-      );
-    }
     if (criteria.author) {
       result = result.filter((s) => s.author === criteria.author);
     }
@@ -3220,27 +3301,48 @@ var LoadoutCompiler = class {
     }
     return skills.filter((s) => result.has(s.id));
   }
+  /**
+   * Ensure every ID in `criteria.include` is present in the result,
+   * regardless of which earlier filter would have dropped it. Missing
+   * skills are fetched directly from storage.
+   *
+   * `criteria.exclude` still wins: an ID listed in both `include` and
+   * `exclude` is treated as excluded (consistent with openteams' "deny
+   * wins" inheritance rule on permissions).
+   *
+   * Included skills are placed at the front of the result, preserving
+   * the order of `criteria.include`. Other skills retain their relative
+   * order behind them.
+   */
+  async ensureIncludedPresent(current, criteria) {
+    if (!criteria.include?.length) return current;
+    const excludeSet = new Set(criteria.exclude ?? []);
+    const effectiveInclude = criteria.include.filter(
+      (id) => !excludeSet.has(id)
+    );
+    if (effectiveInclude.length === 0) return current;
+    const currentById = new Map(current.map((s) => [s.id, s]));
+    const ordered = [];
+    for (const id of effectiveInclude) {
+      const existing = currentById.get(id);
+      if (existing) {
+        ordered.push(existing);
+        currentById.delete(id);
+        continue;
+      }
+      const fetched = await this.storage.getSkill(id);
+      if (fetched) {
+        ordered.push(fetched);
+      }
+    }
+    return [...ordered, ...currentById.values()];
+  }
   /**
    * Apply limits and sorting
    */
   applyLimits(skills, criteria) {
     let result = skills;
-    if (criteria.priorityOrder) {
-      result = [...result].sort((a, b) => {
-        switch (criteria.priorityOrder) {
-          case "usage":
-            return b.metrics.usageCount - a.metrics.usageCount;
-          case "successRate":
-            return b.metrics.successRate - a.metrics.successRate;
-          case "recent":
-            const aDate = a.metrics.lastUsed?.getTime() ?? 0;
-            const bDate = b.metrics.lastUsed?.getTime() ?? 0;
-            return bDate - aDate;
-          case "relevance":
-          default:
-            return 0;
-        }
-      });
+    if (criteria.priorityOrder === "relevance") {
     }
     const maxSkills = criteria.maxSkills ?? this.config.defaultMaxSkills;
     if (result.length > maxSkills) {
@@ -3277,6 +3379,7 @@ var LoadoutCompiler = class {
 };
 
 // src/serving/project-detector.ts
+init_esm_shims();
 import { existsSync as existsSync2, readFileSync } from "fs";
 import { join as join3 } from "path";
 var ProjectDetector = class _ProjectDetector {
@@ -3512,6 +3615,7 @@ var ProjectDetector = class _ProjectDetector {
 };
 
 // src/serving/view-renderer.ts
+init_esm_shims();
 var DEFAULT_CONFIG3 = {
   includeTokenEstimates: false,
   maxSummaryLength: 150
@@ -3707,6 +3811,7 @@ var ViewRenderer = class {
 };
 
 // src/serving/profiles/index.ts
+init_esm_shims();
 var codeReviewProfile = {
   tags: ["review", "quality", "security", "best-practices"],
   taskDescription: "review code for quality, security, and best practices",
@@ -3731,7 +3836,6 @@ var securityProfile = {
   tagsAll: ["security"],
   taskDescription: "security review, vulnerability detection, secure coding",
   maxSkills: 8,
-  minSuccessRate: 0.7,
   priorityOrder: "relevance"
 };
 var testingProfile = {
@@ -3985,16 +4089,6 @@ var SkillGraphServer = class {
     this.emit({ type: "skill:collapsed", skillId });
     return true;
   }
-  /**
-   * Record skill usage (for LRU tracking and auto-expansion)
-   */
-  recordUsage(skillId) {
-    if (!this.state.available.has(skillId)) return;
-    this.touchLru(skillId);
-    if (this.config.autoExpandOnUse && !this.state.expanded.has(skillId)) {
-      this.expandSkill(skillId);
-    }
-  }
   // ===========================================================================
   // AGENT API - Methods for agent-side modifications
   // ===========================================================================
@@ -4104,19 +4198,19 @@ var SkillGraphServer = class {
    * Returns rendered category view (subcategories or skill summaries at leaf).
    * Pass no path for the top-level overview.
    */
-  async agentBrowseCatalog(path13) {
+  async agentBrowseCatalog(path14) {
     if (!this.catalogRenderer) {
       return "<error>Catalog browsing is not enabled</error>";
     }
-    if (!path13 || path13.length === 0) {
+    if (!path14 || path14.length === 0) {
       const result2 = await this.catalogRenderer.renderOverview();
       if (result2) {
         this.emit({ type: "catalog:browsed", path: [] });
       }
       return result2;
     }
-    const result = await this.catalogRenderer.renderCategory(path13);
-    this.emit({ type: "catalog:browsed", path: path13 });
+    const result = await this.catalogRenderer.renderCategory(path14);
+    this.emit({ type: "catalog:browsed", path: path14 });
     return result;
   }
   /**
@@ -4283,6 +4377,7 @@ var SkillGraphServer = class {
 };
 
 // src/serving/interfaces.ts
+init_esm_shims();
 function createStorageView(storage) {
   return {
     getSkill: storage.getSkill.bind(storage),
@@ -4322,17 +4417,21 @@ function createServingEventBridge() {
   };
 }
 
+// src/federation/index.ts
+init_esm_shims();
+
 // src/federation/remote-store.ts
+init_esm_shims();
 import * as fs3 from "fs";
-import * as path3 from "path";
+import * as path4 from "path";
 var REMOTES_FILE = "remotes.json";
 var RemoteStore = class {
   constructor(options) {
     this.remotes = /* @__PURE__ */ new Map();
     this.initialized = false;
     this.basePath = options.basePath;
-    this.configDir = path3.join(this.basePath, ".skillbank");
-    this.configPath = path3.join(this.configDir, REMOTES_FILE);
+    this.configDir = path4.join(this.basePath, ".skillbank");
+    this.configPath = path4.join(this.configDir, REMOTES_FILE);
   }
   /**
    * Initialize the store, loading existing configuration
@@ -4404,7 +4503,7 @@ var RemoteStore = class {
       ...config,
       branch: config.branch || "main",
       skillsPath: config.skillsPath || "skills/",
-      localCache: config.localCache || path3.join(this.basePath, ".remotes", name)
+      localCache: config.localCache || path4.join(this.basePath, ".remotes", name)
     };
     this.remotes.set(name, normalizedConfig);
     await this.save();
@@ -4478,7 +4577,7 @@ var RemoteStore = class {
     if (!config) {
       throw new Error(`Remote not found: ${name}`);
     }
-    return config.localCache || path3.join(this.basePath, ".remotes", name);
+    return config.localCache || path4.join(this.basePath, ".remotes", name);
   }
   /**
    * Validate a remote name
@@ -4518,20 +4617,22 @@ var RemoteStore = class {
 };
 
 // src/federation/remote-manager.ts
+init_esm_shims();
 import * as fs5 from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
 
 // src/federation/skilltree-config.ts
+init_esm_shims();
 import * as fs4 from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 function resolveSkilltreeDir(repoRoot) {
   const envDir = process.env.SKILL_TREE_PROJECT_DIR;
-  if (envDir) return path4.join(repoRoot, envDir);
-  const swarmDir = path4.join(repoRoot, ".swarm", "skilltree");
+  if (envDir) return path5.join(repoRoot, envDir);
+  const swarmDir = path5.join(repoRoot, ".swarm", "skilltree");
   if (fs4.existsSync(swarmDir)) return swarmDir;
-  return path4.join(repoRoot, ".skilltree");
+  return path5.join(repoRoot, ".skilltree");
 }
 var DEFAULT_CONFIG5 = {
   version: 1,
@@ -4562,7 +4663,7 @@ function getSkilltreeDir(repoRoot) {
 function getSkillsDir(repoRoot, config) {
   const skilltreeDir = getSkilltreeDir(repoRoot);
   const paths = config?.paths || DEFAULT_CONFIG5.paths;
-  return path4.join(skilltreeDir, paths[0]);
+  return path5.join(skilltreeDir, paths[0]);
 }
 function parseSkilltreeConfig(content) {
   const parsed = JSON.parse(content);
@@ -4582,7 +4683,7 @@ function validateConfig(config) {
   };
 }
 async function loadSkilltreeConfig(repoRoot) {
-  const configPath = path4.join(getSkilltreeDir(repoRoot), "config.json");
+  const configPath = path5.join(getSkilltreeDir(repoRoot), "config.json");
   try {
     const content = await fs4.promises.readFile(configPath, "utf-8");
     return parseSkilltreeConfig(content);
@@ -4599,9 +4700,9 @@ async function initSkilltreeDir(repoRoot, config) {
   await fs4.promises.mkdir(skilltreeDir, { recursive: true });
   const skillsDir = getSkillsDir(repoRoot, fullConfig);
   await fs4.promises.mkdir(skillsDir, { recursive: true });
-  const cacheDir = path4.join(skilltreeDir, ".cache");
+  const cacheDir = path5.join(skilltreeDir, ".cache");
   await fs4.promises.mkdir(cacheDir, { recursive: true });
-  const gitignorePath = path4.join(skilltreeDir, ".gitignore");
+  const gitignorePath = path5.join(skilltreeDir, ".gitignore");
   try {
     const existing = await fs4.promises.readFile(gitignorePath, "utf-8");
     if (!existing.includes(".cache")) {
@@ -4615,7 +4716,7 @@ async function initSkilltreeDir(repoRoot, config) {
     await fs4.promises.writeFile(gitignorePath, ".cache/\n", "utf-8");
   }
   if (config && Object.keys(config).length > 0) {
-    const configPath = path4.join(skilltreeDir, "config.json");
+    const configPath = path5.join(skilltreeDir, "config.json");
     await fs4.promises.writeFile(
       configPath,
       JSON.stringify(fullConfig, null, 2),
@@ -4638,7 +4739,7 @@ function isSkillFile(filename, patterns = DEFAULT_CONFIG5.skillFilePatterns) {
   return false;
 }
 function shouldExclude(relativePath, excludePatterns) {
-  const parts = relativePath.split(path4.sep);
+  const parts = relativePath.split(path5.sep);
   for (const part of parts) {
     if (excludePatterns.includes(part)) {
       return true;
@@ -4658,14 +4759,14 @@ async function discoverSkills(repoRoot) {
   } else {
     const paths = config.paths || DEFAULT_CONFIG5.paths;
     for (const searchPath of paths) {
-      const fullPath = path4.join(skilltreeDir, searchPath);
+      const fullPath = path5.join(skilltreeDir, searchPath);
       await scanForSkills(skilltreeDir, fullPath, config, discovered);
     }
   }
   return discovered;
 }
 async function scanForSkills(skilltreeDir, dir, config, discovered) {
-  const relativePath = path4.relative(skilltreeDir, dir);
+  const relativePath = path5.relative(skilltreeDir, dir);
   if (relativePath && shouldExclude(relativePath, config.exclude || [])) {
     return;
   }
@@ -4673,7 +4774,7 @@ async function scanForSkills(skilltreeDir, dir, config, discovered) {
     const entries = await fs4.promises.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && isSkillFile(entry.name, config.skillFilePatterns)) {
-        const filePath = path4.join(dir, entry.name);
+        const filePath = path5.join(dir, entry.name);
         const id = deriveSkillId(skilltreeDir, filePath);
         if (!discovered.some((d) => d.id === id)) {
           discovered.push({
@@ -4688,7 +4789,7 @@ async function scanForSkills(skilltreeDir, dir, config, discovered) {
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         await scanForSkills(
           skilltreeDir,
-          path4.join(dir, entry.name),
+          path5.join(dir, entry.name),
           config,
           discovered
         );
@@ -4701,11 +4802,11 @@ async function scanForSkills(skilltreeDir, dir, config, discovered) {
   }
 }
 function deriveSkillId(skilltreeDir, filePath) {
-  const dir = path4.dirname(filePath);
-  const filename = path4.basename(filePath);
-  const dirName = path4.basename(dir);
-  const parentDir = path4.dirname(dir);
-  const parentDirName = path4.basename(parentDir);
+  const dir = path5.dirname(filePath);
+  const filename = path5.basename(filePath);
+  const dirName = path5.basename(dir);
+  const parentDir = path5.dirname(dir);
+  const parentDirName = path5.basename(parentDir);
   if (dir !== skilltreeDir) {
     const skillMatch = filename.match(/^(.+)\.skill\.md$/i);
     if (skillMatch) {
@@ -4722,7 +4823,7 @@ function deriveSkillId(skilltreeDir, filePath) {
       return dirName;
     }
   }
-  const relativePath = path4.relative(skilltreeDir, filePath);
+  const relativePath = path5.relative(skilltreeDir, filePath);
   const withoutExt = relativePath.replace(/\.(skill\.)?md$/i, "");
   return withoutExt.replace(/[\/\\]/g, "-");
 }
@@ -4739,7 +4840,7 @@ var RemoteManager = class {
     /** Cache of discovered skill locations per remote */
     this.discoveryCache = /* @__PURE__ */ new Map();
     this.basePath = options.basePath;
-    this.remotesDir = path5.join(this.basePath, ".remotes");
+    this.remotesDir = path6.join(this.basePath, ".remotes");
     this.remoteStore = options.remoteStore;
     this.gitTimeout = options.gitTimeout || 6e4;
   }
@@ -4910,10 +5011,10 @@ var RemoteManager = class {
       throw new Error(`Remote ${remoteName} is read-only`);
     }
     const skillsPath = await this.getWritePath(remoteName);
-    const skillDir = path5.join(skillsPath, skill.id);
+    const skillDir = path6.join(skillsPath, skill.id);
     await fs5.promises.mkdir(skillDir, { recursive: true });
     const content = this.serializeSkill(skill);
-    const skillPath = path5.join(skillDir, "SKILL.md");
+    const skillPath = path6.join(skillDir, "SKILL.md");
     await fs5.promises.writeFile(skillPath, content, "utf-8");
     this.discoveryCache.delete(remoteName);
     return skillPath;
@@ -5032,7 +5133,7 @@ ${err.stderr || err.message}`
    * Get the cache path for a remote
    */
   getCachePath(name) {
-    return path5.join(this.remotesDir, name);
+    return path6.join(this.remotesDir, name);
   }
   /**
    * Load and cache the .skilltree config for a remote
@@ -5112,12 +5213,7 @@ ${err.stderr || err.message}`
       tags: this.parseTags(metadata.tags),
       createdAt: metadata.created ? new Date(metadata.created) : /* @__PURE__ */ new Date(),
       updatedAt: metadata.updated ? new Date(metadata.updated) : /* @__PURE__ */ new Date(),
-      status: metadata.status || "active",
-      metrics: {
-        usageCount: parseInt(metadata.usageCount) || 0,
-        successRate: parseFloat(metadata.successRate) || 0,
-        feedbackScores: []
-      }
+      status: metadata.status || "active"
     };
   }
   /**
@@ -5186,9 +5282,6 @@ ${body.join("\n")}
       if (filter.author && skill.author !== filter.author) {
         return false;
       }
-      if (filter.minSuccessRate !== void 0 && skill.metrics.successRate < filter.minSuccessRate) {
-        return false;
-      }
       if (filter.createdAfter && skill.createdAt < filter.createdAfter) {
         return false;
       }
@@ -5200,7 +5293,11 @@ ${body.join("\n")}
   }
 };
 
+// src/federation/federation-manager.ts
+init_esm_shims();
+
 // src/versioning/semver.ts
+init_esm_shims();
 function parseVersion(version) {
   const match = version.match(
     /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9.-]+))?(?:\+([a-zA-Z0-9.-]+))?$/
@@ -5814,14 +5911,16 @@ function createFederationManager(options) {
 init_base();
 
 // src/storage/cached.ts
+init_esm_shims();
 init_base();
 import * as fs8 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 
 // src/storage/filesystem.ts
+init_esm_shims();
 init_base();
 import * as fs6 from "fs/promises";
-import * as path6 from "path";
+import * as path7 from "path";
 var FilesystemStorageAdapter = class extends BaseStorageAdapter {
   constructor(config) {
     super();
@@ -5832,7 +5931,7 @@ var FilesystemStorageAdapter = class extends BaseStorageAdapter {
     };
     this.skilltreeDir = getSkilltreeDir(this.config.basePath);
     this.skillsDir = getSkillsDir(this.config.basePath);
-    this.versionsDir = path6.join(this.skilltreeDir, ".versions");
+    this.versionsDir = path7.join(this.skilltreeDir, ".versions");
   }
   async initialize() {
     await initSkilltreeDir(this.config.basePath);
@@ -5849,14 +5948,14 @@ var FilesystemStorageAdapter = class extends BaseStorageAdapter {
   }
   async saveSkill(skill) {
     this.ensureInitialized();
-    const skillDir = path6.join(this.skillsDir, skill.id);
+    const skillDir = path7.join(this.skillsDir, skill.id);
     await fs6.mkdir(skillDir, { recursive: true });
     const skillContent = this.serializeSkill(skill);
     const skillFileName = this.config.openSkillsCompatible ? "SKILL.md" : "skill.md";
-    await fs6.writeFile(path6.join(skillDir, skillFileName), skillContent, "utf-8");
+    await fs6.writeFile(path7.join(skillDir, skillFileName), skillContent, "utf-8");
     const metadata = this.createMetadata(skill);
     await fs6.writeFile(
-      path6.join(skillDir, ".skilltree.json"),
+      path7.join(skillDir, ".skilltree.json"),
       JSON.stringify(metadata, null, 2),
       "utf-8"
     );
@@ -5914,7 +6013,7 @@ var FilesystemStorageAdapter = class extends BaseStorageAdapter {
     try {
       await fs6.rm(location.directory, { recursive: true });
       if (this.config.trackVersions) {
-        const versionDir = path6.join(this.versionsDir, id);
+        const versionDir = path7.join(this.versionsDir, id);
         await fs6.rm(versionDir, { recursive: true }).catch(() => {
         });
       }
@@ -5942,13 +6041,13 @@ var FilesystemStorageAdapter = class extends BaseStorageAdapter {
         }
       ];
     }
-    const versionDir = path6.join(this.versionsDir, skillId);
+    const versionDir = path7.join(this.versionsDir, skillId);
     const versions = [];
     try {
       const entries = await fs6.readdir(versionDir);
       for (const entry of entries) {
         if (!entry.endsWith(".json")) continue;
-        const versionPath = path6.join(versionDir, entry);
+        const versionPath = path7.join(versionDir, entry);
         const content = await fs6.readFile(versionPath, "utf-8");
         const versionData = JSON.parse(content);
         versionData.createdAt = new Date(versionData.createdAt);
@@ -6071,11 +6170,6 @@ ${skill.instructions}
       status,
       parentVersion: parentVersion || void 0,
       derivedFrom: derivedFrom.length > 0 ? derivedFrom : void 0,
-      metrics: {
-        usageCount: 0,
-        successRate: 0,
-        feedbackScores: []
-      },
       source: metadata?.source,
       upstream,
       namespace: metadata?.namespace
@@ -6125,9 +6219,9 @@ ${skill.instructions}
    * Save a version snapshot
    */
   async saveVersionSnapshot(skill) {
-    const versionDir = path6.join(this.versionsDir, skill.id);
+    const versionDir = path7.join(this.versionsDir, skill.id);
     await fs6.mkdir(versionDir, { recursive: true });
-    const versionFile = path6.join(versionDir, `${skill.version}.json`);
+    const versionFile = path7.join(versionDir, `${skill.version}.json`);
     const versionData = {
       skillId: skill.id,
       version: skill.version,
@@ -6143,7 +6237,7 @@ ${skill.instructions}
    * Get a specific version of a skill
    */
   async getVersionedSkill(id, version) {
-    const versionFile = path6.join(this.versionsDir, id, `${version}.json`);
+    const versionFile = path7.join(this.versionsDir, id, `${version}.json`);
     try {
       const content = await fs6.readFile(versionFile, "utf-8");
       const versionData = JSON.parse(content);
@@ -6162,7 +6256,7 @@ ${skill.instructions}
    * Delete a specific version
    */
   async deleteVersion(id, version) {
-    const versionFile = path6.join(this.versionsDir, id, `${version}.json`);
+    const versionFile = path7.join(this.versionsDir, id, `${version}.json`);
     try {
       await fs6.unlink(versionFile);
       return true;
@@ -6196,7 +6290,7 @@ ${skill.instructions}
    * Load metadata for a skill directory
    */
   async loadMetadata(skillDir) {
-    const metadataPath = path6.join(skillDir, ".skilltree.json");
+    const metadataPath = path7.join(skillDir, ".skilltree.json");
     try {
       const content = await fs6.readFile(metadataPath, "utf-8");
       return JSON.parse(content);
@@ -6208,7 +6302,7 @@ ${skill.instructions}
    * Save metadata for a skill directory
    */
   async saveMetadata(skillDir, metadata) {
-    const metadataPath = path6.join(skillDir, ".skilltree.json");
+    const metadataPath = path7.join(skillDir, ".skilltree.json");
     await fs6.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
   }
   // ==========================================================================
@@ -6274,9 +6368,9 @@ var CachedStorageAdapter = class extends BaseStorageAdapter {
     super();
     this.cache = null;
     this.basePath = config.basePath;
-    this.cacheDir = path8.join(config.basePath, ".skilltree", ".cache");
-    this.dbPath = path8.join(this.cacheDir, "index.db");
-    this.manifestPath = path8.join(this.cacheDir, "manifest.json");
+    this.cacheDir = path9.join(config.basePath, ".skilltree", ".cache");
+    this.dbPath = path9.join(this.cacheDir, "index.db");
+    this.manifestPath = path9.join(this.cacheDir, "manifest.json");
     this.source = new FilesystemStorageAdapter({
       basePath: config.basePath,
       openSkillsCompatible: config.openSkillsCompatible ?? true,
@@ -6478,7 +6572,11 @@ var CachedStorageAdapter = class extends BaseStorageAdapter {
   }
 };
 
+// src/versioning/index.ts
+init_esm_shims();
+
 // src/versioning/lineage.ts
+init_esm_shims();
 var LineageTracker = class {
   constructor(storage) {
     this.storage = storage;
@@ -6522,11 +6620,6 @@ var LineageTracker = class {
       createdAt: /* @__PURE__ */ new Date(),
       updatedAt: /* @__PURE__ */ new Date(),
       status: "draft",
-      metrics: {
-        usageCount: 0,
-        successRate: 0,
-        feedbackScores: []
-      },
       source: {
         type: "composed",
         importedAt: /* @__PURE__ */ new Date()
@@ -6727,11 +6820,12 @@ ${source}`;
 };
 
 // src/versioning/merge.ts
+init_esm_shims();
 var DEFAULT_MERGE_CONFIG = {
   textStrategy: "combine",
   tagStrategy: "union",
   includeFields: ["instructions", "tags"],
-  excludeFields: ["id", "version", "createdAt", "updatedAt", "metrics", "source"],
+  excludeFields: ["id", "version", "createdAt", "updatedAt", "source"],
   bumpType: "minor"
 };
 var SkillMerger = class {
@@ -7140,6 +7234,7 @@ function createSkillMerger(storage, config) {
 }
 
 // src/hooks/registry.ts
+init_esm_shims();
 import { randomUUID } from "crypto";
 var PRIORITY_ORDER = {
   high: 0,
@@ -7324,8 +7419,9 @@ var HookRegistry = class {
 var hookRegistry = new HookRegistry();
 
 // src/materialization/materializer.ts
+init_esm_shims();
 import * as fs10 from "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 var SKILLTREE_MARKER_START = "<!-- SKILLTREE_START -->";
 var SKILLTREE_MARKER_END = "<!-- SKILLTREE_END -->";
 var Materializer = class {
@@ -7343,7 +7439,7 @@ var Materializer = class {
     return this.config.mode ?? "symlink";
   }
   get skillsSourceDir() {
-    return path10.join(this.basePath, ".skilltree", "skills");
+    return path11.join(this.basePath, ".skilltree", "skills");
   }
   /**
    * Initial materialization: create all symlinks/copies + generate AGENTS.md
@@ -7386,11 +7482,11 @@ var Materializer = class {
    * Materialize a skill to all configured paths (symlink or copy)
    */
   async ensureMaterialized(skillId) {
-    const sourcePath = path10.join(this.skillsSourceDir, skillId);
+    const sourcePath = path11.join(this.skillsSourceDir, skillId);
     if (!fs10.existsSync(sourcePath)) return;
     for (const targetBase of this.config.symlinkPaths ?? []) {
       const targetDir = this.resolvePath(targetBase);
-      const targetPath = path10.join(targetDir, skillId);
+      const targetPath = path11.join(targetDir, skillId);
       if (this.mode === "copy") {
         this.copyDir(sourcePath, targetPath);
       } else {
@@ -7402,19 +7498,19 @@ var Materializer = class {
    * Remove a materialized skill from all configured paths
    */
   async removeMaterialized(skillId) {
-    const sourcePath = path10.resolve(path10.join(this.skillsSourceDir, skillId));
+    const sourcePath = path11.resolve(path11.join(this.skillsSourceDir, skillId));
     for (const targetBase of this.config.symlinkPaths ?? []) {
-      const targetPath = path10.join(this.resolvePath(targetBase), skillId);
+      const targetPath = path11.join(this.resolvePath(targetBase), skillId);
       if (!fs10.existsSync(targetPath)) continue;
       if (this.mode === "copy") {
-        const markerPath = path10.join(targetPath, ".skilltree-managed");
+        const markerPath = path11.join(targetPath, ".skilltree-managed");
         if (fs10.existsSync(markerPath)) {
           fs10.rmSync(targetPath, { recursive: true, force: true });
         }
       } else {
         try {
           const linkTarget = fs10.readlinkSync(targetPath);
-          if (path10.resolve(linkTarget) === sourcePath) {
+          if (path11.resolve(linkTarget) === sourcePath) {
             fs10.unlinkSync(targetPath);
           }
         } catch {
@@ -7429,7 +7525,7 @@ var Materializer = class {
     if (fs10.existsSync(targetPath)) {
       try {
         const existing = fs10.readlinkSync(targetPath);
-        if (path10.resolve(existing) === path10.resolve(sourcePath)) return;
+        if (path11.resolve(existing) === path11.resolve(sourcePath)) return;
         fs10.unlinkSync(targetPath);
       } catch {
         return;
@@ -7451,7 +7547,7 @@ var Materializer = class {
    */
   copyDir(sourcePath, targetPath) {
     if (fs10.existsSync(targetPath)) {
-      const markerPath = path10.join(targetPath, ".skilltree-managed");
+      const markerPath = path11.join(targetPath, ".skilltree-managed");
       if (fs10.existsSync(markerPath)) {
         fs10.rmSync(targetPath, { recursive: true, force: true });
       } else {
@@ -7460,7 +7556,7 @@ var Materializer = class {
     }
     fs10.cpSync(sourcePath, targetPath, { recursive: true });
     fs10.writeFileSync(
-      path10.join(targetPath, ".skilltree-managed"),
+      path11.join(targetPath, ".skilltree-managed"),
       JSON.stringify({ source: sourcePath, copiedAt: (/* @__PURE__ */ new Date()).toISOString() })
     );
   }
@@ -7529,7 +7625,7 @@ ${SKILLTREE_MARKER_END}`;
       fs10.writeFileSync(resolvedPath, existing + "\n\n" + markedContent + "\n");
       return;
     }
-    const dir = path10.dirname(resolvedPath);
+    const dir = path11.dirname(resolvedPath);
     if (!fs10.existsSync(dir)) {
       fs10.mkdirSync(dir, { recursive: true });
     }
@@ -7549,18 +7645,18 @@ ${SKILLTREE_MARKER_END}`;
       if (!fs10.existsSync(resolved)) continue;
       const entries = fs10.readdirSync(resolved);
       for (const entry of entries) {
-        const entryPath = path10.join(resolved, entry);
+        const entryPath = path11.join(resolved, entry);
         if (skillIds.has(entry)) continue;
         if (this.mode === "copy") {
-          const markerPath = path10.join(entryPath, ".skilltree-managed");
+          const markerPath = path11.join(entryPath, ".skilltree-managed");
           if (fs10.existsSync(markerPath)) {
             fs10.rmSync(entryPath, { recursive: true, force: true });
           }
         } else {
           try {
             const linkTarget = fs10.readlinkSync(entryPath);
-            const resolvedTarget = path10.resolve(linkTarget);
-            if (resolvedTarget.startsWith(this.skillsSourceDir + path10.sep) || resolvedTarget === this.skillsSourceDir) {
+            const resolvedTarget = path11.resolve(linkTarget);
+            if (resolvedTarget.startsWith(this.skillsSourceDir + path11.sep) || resolvedTarget === this.skillsSourceDir) {
               fs10.unlinkSync(entryPath);
             }
           } catch {
@@ -7647,10 +7743,10 @@ ${SKILLTREE_MARKER_END}`;
    */
   resolvePath(p) {
     if (p.startsWith("~")) {
-      return path10.join(process.env.HOME || process.env.USERPROFILE || "", p.slice(1));
+      return path11.join(process.env.HOME || process.env.USERPROFILE || "", p.slice(1));
     }
-    if (path10.isAbsolute(p)) return p;
-    return path10.resolve(this.basePath, p);
+    if (path11.isAbsolute(p)) return p;
+    return path11.resolve(this.basePath, p);
   }
 };
 
@@ -8066,41 +8162,16 @@ var SkillBank = class {
     }
   }
   /**
-   * Handle events from serving layer
+   * Handle events from serving layer.
+   *
+   * The `loadout:changed` event is currently the only one we react to.
+   * Earlier versions also handled `skill:used` / `skill:feedback` to mutate
+   * `Skill.metrics`, but skill-tree no longer tracks per-skill usage —
+   * cognitive-core owns that signal via `playbook.evolution.*`. See
+   * docs/SKILL_TREE_METRICS_DEPRECATION.md.
    */
   async handleServingEvent(event) {
     switch (event.type) {
-      case "skill:used":
-        const skill = await this.storage.getSkill(event.skillId);
-        if (skill) {
-          skill.metrics.usageCount++;
-          skill.metrics.lastUsed = /* @__PURE__ */ new Date();
-          if (event.success) {
-            const total = skill.metrics.usageCount;
-            const currentSuccesses = skill.metrics.successRate * (total - 1);
-            skill.metrics.successRate = (currentSuccesses + 1) / total;
-          } else {
-            const total = skill.metrics.usageCount;
-            const currentSuccesses = skill.metrics.successRate * (total - 1);
-            skill.metrics.successRate = currentSuccesses / total;
-          }
-          skill.updatedAt = /* @__PURE__ */ new Date();
-          await this.storage.saveSkill(skill);
-        }
-        break;
-      case "skill:feedback":
-        const feedbackSkill = await this.storage.getSkill(event.skillId);
-        if (feedbackSkill) {
-          feedbackSkill.metrics.feedbackScores.push(event.score);
-          if (feedbackSkill.metrics.feedbackScores.length > 50) {
-            feedbackSkill.metrics.feedbackScores = feedbackSkill.metrics.feedbackScores.slice(-50);
-          }
-          feedbackSkill.updatedAt = /* @__PURE__ */ new Date();
-          await this.storage.saveSkill(feedbackSkill);
-        }
-        break;
-      case "skill:requested":
-        break;
       case "loadout:changed":
         break;
     }
@@ -8122,26 +8193,17 @@ var SkillBank = class {
         deprecated: 0,
         experimental: 0
       },
-      byTag: {},
-      avgSuccessRate: 0,
-      totalUsage: 0
+      byTag: {}
     };
     if (this.namespaceConfig) {
       stats.byScope = { personal: 0, team: 0, global: 0 };
       stats.byVisibility = { private: 0, "team-only": 0, public: 0 };
     }
-    let successRateSum = 0;
-    let successRateCount = 0;
     for (const skill of skills) {
       stats.byStatus[skill.status]++;
       for (const tag of skill.tags) {
         stats.byTag[tag] = (stats.byTag[tag] || 0) + 1;
       }
-      stats.totalUsage += skill.metrics.usageCount;
-      if (skill.metrics.successRate > 0) {
-        successRateSum += skill.metrics.successRate;
-        successRateCount++;
-      }
       if (stats.byScope && stats.byVisibility) {
         const scope = skill.namespace?.scope || "personal";
         const visibility = skill.namespace?.visibility || "private";
@@ -8149,7 +8211,6 @@ var SkillBank = class {
         stats.byVisibility[visibility]++;
       }
     }
-    stats.avgSuccessRate = successRateCount > 0 ? successRateSum / successRateCount : 0;
     return stats;
   }
   /**
@@ -8215,10 +8276,12 @@ function createSkillBank(config) {
 }
 
 // src/storage/index.ts
+init_esm_shims();
 init_base();
 init_sqlite();
 
 // src/storage/migration.ts
+init_esm_shims();
 async function migrateStorage(source, target, options = {}) {
   const opts = {
     skills: options.skills ?? true,
@@ -8310,12 +8373,17 @@ async function migrateLineages(source, target, opts, result) {
 }
 
 // src/agents/index.ts
+init_esm_shims();
 init_types();
 init_generator();
 init_parser();
 init_sync();
 
+// src/hooks/index.ts
+init_esm_shims();
+
 // src/hooks/builtin.ts
+init_esm_shims();
 function createLoggingHook(logger = console.log) {
   return {
     name: "logging-hook",
@@ -8417,6 +8485,18 @@ function conditionalHook(filter, handler) {
   };
 }
 
+// src/serving/index.ts
+init_esm_shims();
+
+// src/materialization/index.ts
+init_esm_shims();
+
+// src/sync/index.ts
+init_esm_shims();
+
+// src/sync/hierarchical-sync-adapter.ts
+init_esm_shims();
+
 // src/sync/index.ts
 function createDefaultSyncConfig(remoteUrl, agentId, options) {
   return {
@@ -8446,10 +8526,15 @@ function createDefaultSyncConfig(remoteUrl, agentId, options) {
 }
 
 // src/services/indexer.ts
-import * as path12 from "path";
+init_esm_shims();
+import * as path13 from "path";
 import * as fs12 from "fs";
 
+// src/config/index.ts
+init_esm_shims();
+
 // src/config/types.ts
+init_esm_shims();
 var DEFAULT_CONFIG6 = {
   storage: {
     path: "~/.skill-tree"
@@ -8484,8 +8569,9 @@ var DEFAULT_CONFIG6 = {
 };
 
 // src/config/loader.ts
+init_esm_shims();
 import * as fs11 from "fs";
-import * as path11 from "path";
+import * as path12 from "path";
 import * as os from "os";
 var ENV_MAPPINGS = {
   GITHUB_TOKEN: "indexer.github_token",
@@ -8496,17 +8582,17 @@ var ENV_MAPPINGS = {
   SKILL_TREE_NO_COLOR: "cli.color"
 };
 function getConfigDir() {
-  return path11.join(os.homedir(), ".skill-tree");
+  return path12.join(os.homedir(), ".skill-tree");
 }
 function getConfigPath() {
-  return path11.join(getConfigDir(), "config.yaml");
+  return path12.join(getConfigDir(), "config.yaml");
 }
 function expandPath(filePath) {
   if (filePath.startsWith("~/")) {
-    return path11.join(os.homedir(), filePath.slice(2));
+    return path12.join(os.homedir(), filePath.slice(2));
   }
   if (filePath.startsWith("~")) {
-    return path11.join(os.homedir(), filePath.slice(1));
+    return path12.join(os.homedir(), filePath.slice(1));
   }
   return filePath;
 }
@@ -8535,8 +8621,8 @@ function substituteEnvVarsInObject(obj) {
   }
   return obj;
 }
-function setNestedProperty(obj, path13, value) {
-  const parts = path13.split(".");
+function setNestedProperty(obj, path14, value) {
+  const parts = path14.split(".");
   let current = obj;
   for (let i = 0; i < parts.length - 1; i++) {
     const part = parts[i];
@@ -8695,8 +8781,8 @@ var ConfigLoader = class {
   /**
    * Get a specific config value by path
    */
-  get(path13) {
-    const parts = path13.split(".");
+  get(path14) {
+    const parts = path14.split(".");
     let current = this.getConfig();
     for (const part of parts) {
       if (current === null || typeof current !== "object") {
@@ -8716,7 +8802,7 @@ var ConfigLoader = class {
    * Create default config file
    */
   createDefaultConfigFile() {
-    const configDir = path11.dirname(expandPath(this.configPath));
+    const configDir = path12.dirname(expandPath(this.configPath));
     if (!fs11.existsSync(configDir)) {
       fs11.mkdirSync(configDir, { recursive: true });
     }
@@ -8779,6 +8865,7 @@ function loadConfig(configPath) {
 }
 
 // src/import/converter.ts
+init_esm_shims();
 function convertIndexerSkill(indexerSkill) {
   const warnings = [];
   const instructions = indexerSkill.content || "";
@@ -8805,11 +8892,6 @@ function convertIndexerSkill(indexerSkill) {
     createdAt: new Date(indexerSkill.scrapedAt),
     updatedAt: new Date(indexerSkill.updatedAt),
     status,
-    metrics: {
-      usageCount: 0,
-      successRate: 0,
-      feedbackScores: []
-    },
     source: {
       type: "imported",
       location: indexerSkill.sourceUrl,
@@ -8869,8 +8951,8 @@ var IndexerService = class {
         const mod = this.serviceConfig.scraperModules;
         this.databaseModule = mod;
         if (mod.createDatabase) {
-          const dbPath = this.serviceConfig.databasePath || path12.join(process.cwd(), "scraper/data/skills.db");
-          const dbDir = path12.dirname(dbPath);
+          const dbPath = this.serviceConfig.databasePath || path13.join(process.cwd(), "scraper/data/skills.db");
+          const dbDir = path13.dirname(dbPath);
           if (!fs12.existsSync(dbDir)) fs12.mkdirSync(dbDir, { recursive: true });
           this.db = mod.createDatabase({ type: "sqlite", path: dbPath });
           if (this.db.connect) await this.db.connect();
@@ -8883,7 +8965,7 @@ var IndexerService = class {
               const scraperConfig = {
                 githubToken: config.githubToken || "",
                 cacheEnabled: true,
-                cacheDir: config.cacheDir || path12.join(process.cwd(), ".cache/scraper"),
+                cacheDir: config.cacheDir || path13.join(process.cwd(), ".cache/scraper"),
                 cacheTtlSeconds: config.cacheTtlSeconds || 3600,
                 requestDelayMs: 100,
                 maxRetries: 3
@@ -8936,15 +9018,15 @@ var IndexerService = class {
       }
       const possiblePaths = [
         // Relative to this file in dist
-        path12.resolve(__dirname, "../../scraper/dist"),
+        path13.resolve(__dirname, "../../scraper/dist"),
         // Relative to project root
-        path12.resolve(process.cwd(), "scraper/dist"),
+        path13.resolve(process.cwd(), "scraper/dist"),
         // Absolute paths from config
-        this.serviceConfig.cacheDir ? path12.resolve(this.serviceConfig.cacheDir, "../scraper/dist") : null
+        this.serviceConfig.cacheDir ? path13.resolve(this.serviceConfig.cacheDir, "../scraper/dist") : null
       ].filter(Boolean);
       let scraperBasePath = null;
       for (const basePath of possiblePaths) {
-        const scraperIndex = path12.join(basePath, "scraper/index.js");
+        const scraperIndex = path13.join(basePath, "scraper/index.js");
         if (fs12.existsSync(scraperIndex)) {
           scraperBasePath = basePath;
           break;
@@ -8955,9 +9037,9 @@ var IndexerService = class {
           "Scraper modules not found. Run `cd scraper && npm run build` first."
         );
       }
-      const scraperPath = path12.join(scraperBasePath, "scraper/index.js");
-      const indexerPath = path12.join(scraperBasePath, "indexer/index.js");
-      const databasePath = path12.join(scraperBasePath, "database/index.js");
+      const scraperPath = path13.join(scraperBasePath, "scraper/index.js");
+      const indexerPath = path13.join(scraperBasePath, "indexer/index.js");
+      const databasePath = path13.join(scraperBasePath, "database/index.js");
       this.scraperModule = await import(
         /* webpackIgnore: true */
         scraperPath
@@ -8971,7 +9053,7 @@ var IndexerService = class {
         databasePath
       );
       if (this.databaseModule.createDatabase) {
-        const dbPath = this.serviceConfig.databasePath || path12.join(process.cwd(), "scraper/data/skills.db");
+        const dbPath = this.serviceConfig.databasePath || path13.join(process.cwd(), "scraper/data/skills.db");
         this.db = this.databaseModule.createDatabase(dbPath);
       }
       this.initialized = true;
@@ -9608,7 +9690,7 @@ var IndexerService = class {
 };
 
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 export {
   AgentsGenerator,
   AgentsParser,
@@ -9677,4 +9759,3 @@ export {
   testingProfile,
   writeAgentsMd
 };
-//# sourceMappingURL=index.mjs.map