skill-tree 0.1.7 → 0.2.0

package/dist/cli/index.mjs

@@ -9,11 +9,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;
@@ -42,9 +56,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;
           }
@@ -283,12 +294,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 {
@@ -302,7 +314,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 });
         }
@@ -337,12 +349,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,
@@ -506,6 +525,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.");
@@ -518,10 +606,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(
@@ -538,7 +626,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({
@@ -633,10 +720,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());
@@ -832,15 +915,15 @@ var init_sqlite = __esm({
       /**
        * Get or create a taxonomy node
        */
-      async ensureTaxonomyNode(path18) {
+      async ensureTaxonomyNode(path19) {
         this.ensureInitialized();
         const db = this.getDb();
-        const pathStr = path18.join("/");
+        const pathStr = path19.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 = path18[path18.length - 1] || "Root";
-        const parentPath = path18.slice(0, -1);
+        const name = path19[path19.length - 1] || "Root";
+        const parentPath = path19.slice(0, -1);
         let parentId = null;
         if (parentPath.length > 0) {
           parentId = await this.ensureTaxonomyNode(parentPath);
@@ -1031,7 +1114,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 ? {
@@ -1048,11 +1130,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) {
@@ -1063,11 +1141,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) {
@@ -1091,6 +1165,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,
@@ -1105,6 +1180,7 @@ var AgentsGenerator;
 var init_generator = __esm({
   "src/agents/generator.ts"() {
     "use strict";
+    init_esm_shims();
     init_types();
     AgentsGenerator = class {
       constructor(config2) {
@@ -1273,9 +1349,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);
         }
@@ -1319,6 +1392,7 @@ var AgentsParser;
 var init_parser = __esm({
   "src/agents/parser.ts"() {
     "use strict";
+    init_esm_shims();
     AgentsParser = class {
       /**
        * Parse AGENTS.md content
@@ -1372,11 +1446,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",
@@ -1559,7 +1628,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();
 }
@@ -1569,7 +1638,7 @@ async function generateAgentsMd(storage, config2) {
 }
 async function writeAgentsMd(storage, filePath, config2) {
   const content = await generateAgentsMd(storage, config2);
-  const dir = path9.dirname(filePath);
+  const dir = path10.dirname(filePath);
   if (dir && !fs9.existsSync(dir)) {
     fs9.mkdirSync(dir, { recursive: true });
   }
@@ -1587,6 +1656,7 @@ var AgentsSync;
 var init_sync = __esm({
   "src/agents/sync.ts"() {
     "use strict";
+    init_esm_shims();
     init_generator();
     init_parser();
     AgentsSync = class {
@@ -1692,7 +1762,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 });
           }
@@ -1744,8 +1814,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
@@ -1756,9 +1824,17 @@ var init_sync = __esm({
 });
 
 // src/cli/index.ts
-import { Command as Command39 } from "commander";
+init_esm_shims();
+import { Command as Command38 } from "commander";
+
+// 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";
 }
@@ -1766,18 +1842,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)
@@ -1794,7 +1875,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");
   }
@@ -1803,7 +1884,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));
@@ -1824,7 +1905,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)));
@@ -1847,7 +1928,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;
@@ -1986,10 +2067,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
@@ -2001,10 +2078,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)
@@ -2072,7 +2145,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 {
@@ -2359,7 +2432,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();
@@ -2373,7 +2446,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}`]);
@@ -2571,18 +2644,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");
   }
@@ -2633,11 +2701,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");
@@ -2831,7 +2899,14 @@ var SyncManager = class {
   }
 };
 
+// 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;");
 }
@@ -2899,11 +2974,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(path18) {
+  async renderCategory(path19) {
     if (hasCatalogSupport(this.storage)) {
-      return this.renderCategoryFromTaxonomy(this.storage, path18);
+      return this.renderCategoryFromTaxonomy(this.storage, path19);
     }
-    return this.renderCategoryFromTags(path18);
+    return this.renderCategoryFromTags(path19);
   }
   /**
    * Invalidate the overview cache (e.g., after skill changes).
@@ -2941,9 +3016,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, path18) {
-    const tree = await storage.getTaxonomyTree(path18);
-    const pathStr = path18.join("/");
+  async renderCategoryFromTaxonomy(storage, path19) {
+    const tree = await storage.getTaxonomyTree(path19);
+    const pathStr = path19.join("/");
     if (tree.length > 0 && tree.some((n) => n.children.length > 0)) {
       const root = tree[0];
       const rootCount = this.countNodeSkills(root);
@@ -2953,7 +3028,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 = [...path18, child.name].join("/");
+        const childPath = [...path19, child.name].join("/");
         lines.push(`    <category path="${escapeXml(childPath)}" count="${count}" />`);
       }
       lines.push("  </subcategories>");
@@ -2977,13 +3052,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(path18) {
-    if (path18.length === 0) {
+  async renderCategoryFromTags(path19) {
+    if (path19.length === 0) {
       return this.renderOverviewFromTags();
     }
-    const tag = path18[0];
+    const tag = path19[0];
     const matching = await this.storage.listSkills({ status: ["active"], tags: [tag] });
-    const pathStr = path18.join("/");
+    const pathStr = path19.join("/");
     return this.renderLeafSkills(matching, pathStr, matching.length);
   }
   // ===========================================================================
@@ -3038,6 +3113,7 @@ var CatalogRenderer = class _CatalogRenderer {
 };
 
 // src/serving/loadout-compiler.ts
+init_esm_shims();
 var DEFAULT_CONFIG2 = {
   defaultMaxSkills: 15,
   defaultStatus: ["active"],
@@ -3052,7 +3128,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;
@@ -3062,6 +3155,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;
   }
@@ -3107,7 +3201,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;
@@ -3115,15 +3211,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;
   }
   /**
@@ -3147,11 +3234,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);
     }
@@ -3209,27 +3291,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) {
@@ -3266,6 +3369,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 {
@@ -3501,6 +3605,7 @@ var ProjectDetector = class _ProjectDetector {
 };
 
 // src/serving/view-renderer.ts
+init_esm_shims();
 var DEFAULT_CONFIG3 = {
   includeTokenEstimates: false,
   maxSummaryLength: 150
@@ -3696,6 +3801,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",
@@ -3720,7 +3826,6 @@ var securityProfile = {
   tagsAll: ["security"],
   taskDescription: "security review, vulnerability detection, secure coding",
   maxSkills: 8,
-  minSuccessRate: 0.7,
   priorityOrder: "relevance"
 };
 var testingProfile = {
@@ -3968,16 +4073,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
   // ===========================================================================
@@ -4087,19 +4182,19 @@ var SkillGraphServer = class {
    * Returns rendered category view (subcategories or skill summaries at leaf).
    * Pass no path for the top-level overview.
    */
-  async agentBrowseCatalog(path18) {
+  async agentBrowseCatalog(path19) {
     if (!this.catalogRenderer) {
       return "<error>Catalog browsing is not enabled</error>";
     }
-    if (!path18 || path18.length === 0) {
+    if (!path19 || path19.length === 0) {
       const result2 = await this.catalogRenderer.renderOverview();
       if (result2) {
         this.emit({ type: "catalog:browsed", path: [] });
       }
       return result2;
     }
-    const result = await this.catalogRenderer.renderCategory(path18);
-    this.emit({ type: "catalog:browsed", path: path18 });
+    const result = await this.catalogRenderer.renderCategory(path19);
+    this.emit({ type: "catalog:browsed", path: path19 });
     return result;
   }
   /**
@@ -4266,6 +4361,7 @@ var SkillGraphServer = class {
 };
 
 // src/serving/interfaces.ts
+init_esm_shims();
 function createStorageView(storage) {
   return {
     getSkill: storage.getSkill.bind(storage),
@@ -4305,17 +4401,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
@@ -4387,7 +4487,7 @@ var RemoteStore = class {
       ...config2,
       branch: config2.branch || "main",
       skillsPath: config2.skillsPath || "skills/",
-      localCache: config2.localCache || path3.join(this.basePath, ".remotes", name)
+      localCache: config2.localCache || path4.join(this.basePath, ".remotes", name)
     };
     this.remotes.set(name, normalizedConfig);
     await this.save();
@@ -4461,7 +4561,7 @@ var RemoteStore = class {
     if (!config2) {
       throw new Error(`Remote not found: ${name}`);
     }
-    return config2.localCache || path3.join(this.basePath, ".remotes", name);
+    return config2.localCache || path4.join(this.basePath, ".remotes", name);
   }
   /**
    * Validate a remote name
@@ -4501,20 +4601,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,
@@ -4545,7 +4647,7 @@ function getSkilltreeDir(repoRoot) {
 function getSkillsDir(repoRoot, config2) {
   const skilltreeDir = getSkilltreeDir(repoRoot);
   const paths = config2?.paths || DEFAULT_CONFIG5.paths;
-  return path4.join(skilltreeDir, paths[0]);
+  return path5.join(skilltreeDir, paths[0]);
 }
 function parseSkilltreeConfig(content) {
   const parsed = JSON.parse(content);
@@ -4565,7 +4667,7 @@ function validateConfig(config2) {
   };
 }
 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);
@@ -4582,9 +4684,9 @@ async function initSkilltreeDir(repoRoot, config2) {
   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")) {
@@ -4598,7 +4700,7 @@ async function initSkilltreeDir(repoRoot, config2) {
     await fs4.promises.writeFile(gitignorePath, ".cache/\n", "utf-8");
   }
   if (config2 && Object.keys(config2).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),
@@ -4621,7 +4723,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;
@@ -4641,14 +4743,14 @@ async function discoverSkills(repoRoot) {
   } else {
     const paths = config2.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, config2, discovered);
     }
   }
   return discovered;
 }
 async function scanForSkills(skilltreeDir, dir, config2, discovered) {
-  const relativePath = path4.relative(skilltreeDir, dir);
+  const relativePath = path5.relative(skilltreeDir, dir);
   if (relativePath && shouldExclude(relativePath, config2.exclude || [])) {
     return;
   }
@@ -4656,7 +4758,7 @@ async function scanForSkills(skilltreeDir, dir, config2, discovered) {
     const entries = await fs4.promises.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && isSkillFile(entry.name, config2.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({
@@ -4671,7 +4773,7 @@ async function scanForSkills(skilltreeDir, dir, config2, discovered) {
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         await scanForSkills(
           skilltreeDir,
-          path4.join(dir, entry.name),
+          path5.join(dir, entry.name),
           config2,
           discovered
         );
@@ -4684,11 +4786,11 @@ async function scanForSkills(skilltreeDir, dir, config2, 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) {
@@ -4705,7 +4807,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, "-");
 }
@@ -4722,7 +4824,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;
   }
@@ -4893,10 +4995,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;
@@ -5015,7 +5117,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
@@ -5095,12 +5197,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"
     };
   }
   /**
@@ -5169,9 +5266,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;
       }
@@ -5183,7 +5277,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.-]+))?$/
@@ -5733,14 +5831,16 @@ ${remote.instructions}` : remote.instructions,
 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(config2) {
     super();
@@ -5751,7 +5851,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);
@@ -5768,14 +5868,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"
     );
@@ -5833,7 +5933,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(() => {
         });
       }
@@ -5861,13 +5961,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);
@@ -5990,11 +6090,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
@@ -6044,9 +6139,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,
@@ -6062,7 +6157,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);
@@ -6081,7 +6176,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;
@@ -6115,7 +6210,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);
@@ -6127,7 +6222,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");
   }
   // ==========================================================================
@@ -6193,9 +6288,9 @@ var CachedStorageAdapter = class extends BaseStorageAdapter {
     super();
     this.cache = null;
     this.basePath = config2.basePath;
-    this.cacheDir = path8.join(config2.basePath, ".skilltree", ".cache");
-    this.dbPath = path8.join(this.cacheDir, "index.db");
-    this.manifestPath = path8.join(this.cacheDir, "manifest.json");
+    this.cacheDir = path9.join(config2.basePath, ".skilltree", ".cache");
+    this.dbPath = path9.join(this.cacheDir, "index.db");
+    this.manifestPath = path9.join(this.cacheDir, "manifest.json");
     this.source = new FilesystemStorageAdapter({
       basePath: config2.basePath,
       openSkillsCompatible: config2.openSkillsCompatible ?? true,
@@ -6397,7 +6492,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;
@@ -6441,11 +6540,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()
@@ -6645,7 +6739,11 @@ ${source}`;
   }
 };
 
+// src/versioning/merge.ts
+init_esm_shims();
+
 // src/hooks/registry.ts
+init_esm_shims();
 import { randomUUID } from "crypto";
 var PRIORITY_ORDER = {
   high: 0,
@@ -6830,8 +6928,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 {
@@ -6849,7 +6948,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
@@ -6892,11 +6991,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 {
@@ -6908,19 +7007,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 {
@@ -6935,7 +7034,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;
@@ -6957,7 +7056,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 {
@@ -6966,7 +7065,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() })
     );
   }
@@ -7035,7 +7134,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 });
     }
@@ -7055,18 +7154,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 {
@@ -7153,10 +7252,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);
   }
 };
 
@@ -7572,41 +7671,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;
     }
@@ -7628,26 +7702,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";
@@ -7655,7 +7720,6 @@ var SkillBank = class {
         stats.byVisibility[visibility]++;
       }
     }
-    stats.avgSuccessRate = successRateCount > 0 ? successRateSum / successRateCount : 0;
     return stats;
   }
   /**
@@ -7718,15 +7782,38 @@ var SkillBank = class {
 };
 
 // src/storage/index.ts
+init_esm_shims();
 init_base();
 init_sqlite();
 
+// src/storage/migration.ts
+init_esm_shims();
+
 // 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();
+
+// 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 {
@@ -7756,10 +7843,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"
@@ -7794,8 +7886,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",
@@ -7806,17 +7899,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;
 }
@@ -7845,8 +7938,8 @@ function substituteEnvVarsInObject(obj) {
   }
   return obj;
 }
-function setNestedProperty(obj, path18, value) {
-  const parts = path18.split(".");
+function setNestedProperty(obj, path19, value) {
+  const parts = path19.split(".");
   let current = obj;
   for (let i = 0; i < parts.length - 1; i++) {
     const part = parts[i];
@@ -8005,8 +8098,8 @@ var ConfigLoader = class {
   /**
    * Get a specific config value by path
    */
-  get(path18) {
-    const parts = path18.split(".");
+  get(path19) {
+    const parts = path19.split(".");
     let current = this.getConfig();
     for (const part of parts) {
       if (current === null || typeof current !== "object") {
@@ -8026,7 +8119,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 });
     }
@@ -8089,6 +8182,7 @@ function loadConfig(configPath) {
 }
 
 // src/import/converter.ts
+init_esm_shims();
 function convertIndexerSkill(indexerSkill) {
   const warnings = [];
   const instructions = indexerSkill.content || "";
@@ -8115,11 +8209,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,
@@ -8215,8 +8304,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();
@@ -8229,7 +8318,7 @@ var IndexerService = class {
               const scraperConfig = {
                 githubToken: config2.githubToken || "",
                 cacheEnabled: true,
-                cacheDir: config2.cacheDir || path12.join(process.cwd(), ".cache/scraper"),
+                cacheDir: config2.cacheDir || path13.join(process.cwd(), ".cache/scraper"),
                 cacheTtlSeconds: config2.cacheTtlSeconds || 3600,
                 requestDelayMs: 100,
                 maxRetries: 3
@@ -8282,15 +8371,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;
@@ -8301,9 +8390,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
@@ -8317,7 +8406,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;
@@ -8957,14 +9046,19 @@ function createIntegratedIndexer(skillBank, config2 = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 
 // src/cli/commands/list.ts
+init_esm_shims();
 import { Command } from "commander";
 
+// src/cli/utils/skillbank.ts
+init_esm_shims();
+
 // src/cli/utils/paths.ts
+init_esm_shims();
 import * as fs13 from "fs";
-import * as path13 from "path";
+import * as path14 from "path";
 import * as os2 from "os";
 var DEFAULT_PATHS = [
   ".claude/skills",
@@ -8978,7 +9072,7 @@ var DEFAULT_PATHS = [
 ];
 function expandHome(p) {
   if (p.startsWith("~/")) {
-    return path13.join(os2.homedir(), p.slice(2));
+    return path14.join(os2.homedir(), p.slice(2));
   }
   return p;
 }
@@ -8992,19 +9086,19 @@ function dirExists(p) {
 function resolveSkillPath(explicitPath) {
   if (explicitPath) {
     const resolved = expandHome(explicitPath);
-    return path13.resolve(resolved);
+    return path14.resolve(resolved);
   }
   const envPath = process.env.SKILL_TREE_PATH;
   if (envPath) {
-    return path13.resolve(expandHome(envPath));
+    return path14.resolve(expandHome(envPath));
   }
   for (const defaultPath of DEFAULT_PATHS) {
-    const resolved = path13.resolve(expandHome(defaultPath));
+    const resolved = path14.resolve(expandHome(defaultPath));
     if (dirExists(resolved)) {
       return resolved;
     }
   }
-  return path13.resolve(".claude/skills");
+  return path14.resolve(".claude/skills");
 }
 function ensureDir(dir) {
   if (!dirExists(dir)) {
@@ -9045,6 +9139,7 @@ function getSkillPath(options) {
 var getSkillBank = createSkillBankFromOptions;
 
 // src/cli/utils/output.ts
+init_esm_shims();
 import chalk from "chalk";
 function formatSkillLine(skill) {
   const status = formatStatus(skill.status);
@@ -9083,10 +9178,6 @@ function formatSkillDetail(skill) {
   if (skill.derivedFrom && skill.derivedFrom.length > 0) {
     lines.push(`${chalk.dim("Derived:")}   ${skill.derivedFrom.join(", ")}`);
   }
-  const { usageCount, successRate } = skill.metrics;
-  if (usageCount > 0) {
-    lines.push(`${chalk.dim("Usage:")}     ${usageCount} times, ${Math.round(successRate * 100)}% success`);
-  }
   lines.push("");
   lines.push(chalk.dim("Description"));
   lines.push(chalk.dim("\u2500".repeat(50)));
@@ -9166,11 +9257,6 @@ function formatStats(stats) {
     }
     lines.push("");
   }
-  if (stats.totalUsage > 0) {
-    lines.push(chalk.dim("Usage:"));
-    lines.push(`  Total uses:      ${stats.totalUsage}`);
-    lines.push(`  Avg success:     ${Math.round(stats.avgSuccessRate * 100)}%`);
-  }
   return lines.join("\n");
 }
 function printError(message) {
@@ -9235,6 +9321,7 @@ var listCommand = new Command("list").description("List all skills").option("-s,
 });
 
 // src/cli/commands/show.ts
+init_esm_shims();
 import { Command as Command2 } from "commander";
 var showCommand = new Command2("show").description("Show skill details").argument("<id>", "Skill ID").option("-v, --version <version>", "Show specific version").action(async (id, options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -9257,6 +9344,7 @@ var showCommand = new Command2("show").description("Show skill details").argumen
 });
 
 // src/cli/commands/search.ts
+init_esm_shims();
 import { Command as Command3 } from "commander";
 var searchCommand = new Command3("search").description("Search skills by text").argument("<query>", "Search query").action(async (query, options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -9289,6 +9377,7 @@ var searchCommand = new Command3("search").description("Search skills by text").
 });
 
 // src/cli/commands/stats.ts
+init_esm_shims();
 import { Command as Command4 } from "commander";
 var statsCommand = new Command4("stats").description("Show skill bank statistics").action(async (options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -9307,6 +9396,7 @@ var statsCommand = new Command4("stats").description("Show skill bank statistics
 });
 
 // src/cli/commands/versions.ts
+init_esm_shims();
 import { Command as Command5 } from "commander";
 var versionsCommand = new Command5("versions").description("Show version history for a skill").argument("<id>", "Skill ID").action(async (id, options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -9329,6 +9419,7 @@ var versionsCommand = new Command5("versions").description("Show version history
 });
 
 // src/cli/commands/diff.ts
+init_esm_shims();
 import { Command as Command6 } from "commander";
 var diffCommand = new Command6("diff").description("Compare two versions of a skill").argument("<id>", "Skill ID").argument("<version-a>", "First version").argument("<version-b>", "Second version").action(async (id, versionA, versionB, options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -9347,6 +9438,7 @@ var diffCommand = new Command6("diff").description("Compare two versions of a sk
 });
 
 // src/cli/commands/rollback.ts
+init_esm_shims();
 import { Command as Command7 } from "commander";
 var rollbackCommand = new Command7("rollback").description("Rollback a skill to a previous version").argument("<id>", "Skill ID").requiredOption("--to <version>", "Version to rollback to").action(async (id, options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -9365,6 +9457,7 @@ var rollbackCommand = new Command7("rollback").description("Rollback a skill to
 });
 
 // src/cli/commands/fork.ts
+init_esm_shims();
 import { Command as Command8 } from "commander";
 var forkCommand = new Command8("fork").description("Fork a skill to create a variant").argument("<id>", "Skill ID to fork from").requiredOption("--new-id <id>", "ID for the new forked skill").requiredOption("--reason <reason>", "Reason for forking").option("--name <name>", "Name for the forked skill").option("--from-version <version>", "Version to fork from (defaults to latest)").action(async (id, options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -9388,6 +9481,7 @@ var forkCommand = new Command8("fork").description("Fork a skill to create a var
 });
 
 // src/cli/commands/deprecate.ts
+init_esm_shims();
 import { Command as Command9 } from "commander";
 var deprecateCommand = new Command9("deprecate").description("Mark a skill as deprecated").argument("<id>", "Skill ID").action(async (id, options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -9406,6 +9500,7 @@ var deprecateCommand = new Command9("deprecate").description("Mark a skill as de
 });
 
 // src/cli/commands/activate.ts
+init_esm_shims();
 import { Command as Command10 } from "commander";
 var activateCommand = new Command10("activate").description("Mark a skill as active").argument("<id>", "Skill ID").action(async (id, options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -9431,6 +9526,7 @@ var activateCommand = new Command10("activate").description("Mark a skill as act
 });
 
 // src/cli/commands/delete.ts
+init_esm_shims();
 import { Command as Command11 } from "commander";
 var deleteCommand = new Command11("delete").description("Delete a skill").argument("<id>", "Skill ID").option("-f, --force", "Skip confirmation").option("-v, --version <version>", "Delete specific version only").action(async (id, options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -9463,6 +9559,7 @@ var deleteCommand = new Command11("delete").description("Delete a skill").argume
 });
 
 // src/cli/commands/export.ts
+init_esm_shims();
 import { Command as Command12 } from "commander";
 import * as fs14 from "fs";
 var exportCommand = new Command12("export").description("Export all skills to JSON").option("-o, --output <file>", "Output file path (defaults to stdout)").action(async (options, command) => {
@@ -9486,14 +9583,19 @@ var exportCommand = new Command12("export").description("Export all skills to JS
 });
 
 // src/cli/commands/import.ts
+init_esm_shims();
 import { Command as Command13 } from "commander";
 import * as fs15 from "fs";
 
+// src/import/index.ts
+init_esm_shims();
+
 // src/import/detect.ts
+init_esm_shims();
 function isSkillTreeSkill(obj) {
   if (typeof obj !== "object" || obj === null) return false;
   const skill = obj;
-  return typeof skill.id === "string" && typeof skill.name === "string" && typeof skill.version === "string" && typeof skill.instructions === "string" && typeof skill.metrics === "object";
+  return typeof skill.id === "string" && typeof skill.name === "string" && typeof skill.version === "string" && typeof skill.instructions === "string";
 }
 function isIndexerSkill(obj) {
   if (typeof obj !== "object" || obj === null) return false;
@@ -9584,9 +9686,6 @@ var importCommand = new Command13("import").description("Import skills from JSON
       for (const skill of skills) {
         skill.createdAt = new Date(skill.createdAt);
         skill.updatedAt = new Date(skill.updatedAt);
-        if (skill.metrics.lastUsed) {
-          skill.metrics.lastUsed = new Date(skill.metrics.lastUsed);
-        }
         if (skill.source?.importedAt) {
           skill.source.importedAt = new Date(skill.source.importedAt);
         }
@@ -9615,9 +9714,11 @@ var importCommand = new Command13("import").description("Import skills from JSON
 });
 
 // src/cli/commands/indexer/index.ts
+init_esm_shims();
 import { Command as Command20 } from "commander";
 
 // src/cli/commands/indexer/scrape.ts
+init_esm_shims();
 import { Command as Command14 } from "commander";
 import { spawn } from "child_process";
 var scrapeCommand = new Command14("scrape").description("Scrape skills from GitHub sources").argument("[url]", "Repository or awesome-list URL").option("-d, --discover", "Discover from default sources").option("-f, --force", "Force scrape even if no changes detected").option("--standalone", "Use standalone skillindexer CLI (fallback)").option("--import", "Auto-import scraped skills into skill-tree", true).action(async (url, options, command) => {
@@ -9742,6 +9843,7 @@ async function runSkillIndexer(args, quiet) {
 }
 
 // src/cli/commands/indexer/classify.ts
+init_esm_shims();
 import { Command as Command15 } from "commander";
 import { spawn as spawn2 } from "child_process";
 var classifyCommand = new Command15("classify").description("Classify unindexed skills using AI").option("-s, --skill <id>", "Classify specific skill by ID").option("--all", "Re-classify all skills (including already indexed)").option("--standalone", "Use standalone skillindexer CLI (fallback)").action(async (options, command) => {
@@ -9836,6 +9938,7 @@ async function runSkillIndexer2(args, quiet) {
 }
 
 // src/cli/commands/indexer/taxonomy.ts
+init_esm_shims();
 import { Command as Command16 } from "commander";
 import { spawn as spawn3 } from "child_process";
 var taxonomyCommand = new Command16("taxonomy").description("Browse the taxonomy tree").argument("[path]", 'Subtree path (e.g., "Development/Python")').option("-i, --interactive", "Interactive browsing mode").option("--standalone", "Use standalone skillindexer CLI (fallback)").action(async (pathArg, options, command) => {
@@ -9916,6 +10019,7 @@ async function runSkillIndexer3(args, quiet) {
 }
 
 // src/cli/commands/indexer/relationships.ts
+init_esm_shims();
 import { Command as Command17 } from "commander";
 import { spawn as spawn4 } from "child_process";
 var relationshipsCommand = new Command17("relationships").description("Detect relationships between indexed skills").option("-s, --skill <id>", "Detect relationships for specific skill").option("--use-ai", "Use AI for relationship reasoning (slower, more accurate)").option("--clear", "Clear existing relationships before detection").option("--standalone", "Use standalone skillindexer CLI (fallback)").action(async (options, command) => {
@@ -10002,6 +10106,7 @@ async function runSkillIndexer4(args, quiet) {
 }
 
 // src/cli/commands/indexer/stats.ts
+init_esm_shims();
 import { Command as Command18 } from "commander";
 import { spawn as spawn5 } from "child_process";
 var indexerStatsCommand = new Command18("stats").description("Show indexer database statistics").option("--standalone", "Use standalone skillindexer CLI (fallback)").action(async (options, command) => {
@@ -10081,13 +10186,15 @@ async function runSkillIndexer5(args, quiet) {
 }
 
 // src/cli/commands/indexer/sync.ts
+init_esm_shims();
 import { Command as Command19 } from "commander";
 import * as fs16 from "fs";
-import * as path14 from "path";
+import * as path15 from "path";
 import * as os3 from "os";
 import { spawn as spawn6 } from "child_process";
 
 // src/services/sync.ts
+init_esm_shims();
 var SyncService = class {
   constructor(skillBank, config2 = {}) {
     this.syncStates = /* @__PURE__ */ new Map();
@@ -10544,7 +10651,7 @@ async function runLegacyImport(options, globalOpts) {
     if (!globalOpts.quiet) {
       printInfo("Exporting skills from indexer...");
     }
-    exportPath = path14.join(os3.tmpdir(), `skill-tree-sync-${Date.now()}.json`);
+    exportPath = path15.join(os3.tmpdir(), `skill-tree-sync-${Date.now()}.json`);
     const args = ["export-skilltree", "-o", exportPath, "-f", "json"];
     if (options.indexedOnly) args.push("--indexed-only");
     await runSkillIndexer6(args, true);
@@ -10612,6 +10719,7 @@ async function runSkillIndexer6(args, quiet) {
 var indexerCommand = new Command20("index").description("Skill indexer - discover and classify skills from GitHub").addCommand(scrapeCommand).addCommand(classifyCommand).addCommand(taxonomyCommand).addCommand(relationshipsCommand).addCommand(indexerStatsCommand).addCommand(syncCommand);
 
 // src/cli/commands/config.ts
+init_esm_shims();
 import { Command as Command21 } from "commander";
 import * as fs17 from "fs";
 var configCommand = new Command21("config").description("View and manage configuration");
@@ -10762,11 +10870,12 @@ function printConfig(obj, indent) {
 }
 
 // src/cli/commands/sync.ts
+init_esm_shims();
 import { Command as Command22 } from "commander";
-import * as path15 from "path";
+import * as path16 from "path";
 import * as fs18 from "fs";
 function getSyncConfigPath(basePath) {
-  return path15.join(basePath, ".skillbank", "sync-config.json");
+  return path16.join(basePath, ".skillbank", "sync-config.json");
 }
 async function loadSyncConfig(basePath) {
   const configPath = getSyncConfigPath(basePath);
@@ -10779,7 +10888,7 @@ async function loadSyncConfig(basePath) {
 }
 async function saveSyncConfig(basePath, config2) {
   const configPath = getSyncConfigPath(basePath);
-  await fs18.promises.mkdir(path15.dirname(configPath), { recursive: true });
+  await fs18.promises.mkdir(path16.dirname(configPath), { recursive: true });
   await fs18.promises.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
 }
 async function createSyncAdapter(basePath, globalOpts) {
@@ -10810,7 +10919,7 @@ function initCommand() {
         agentName: options.name,
         environment: options.env
       });
-      const gitDir = path15.join(basePath, ".git");
+      const gitDir = path16.join(basePath, ".git");
       if (!fs18.existsSync(gitDir)) {
         printError(`Not a git repository: ${basePath}`);
         printInfo("Initialize a git repository first with: git init");
@@ -11086,8 +11195,9 @@ function resolveCommand() {
 }
 
 // src/cli/commands/read.ts
+init_esm_shims();
 import { Command as Command23 } from "commander";
-import * as path16 from "path";
+import * as path17 from "path";
 function serializeSkillMd(skill) {
   const lines = [];
   lines.push("---");
@@ -11133,7 +11243,7 @@ var readCommand = new Command23("read").description("Read skill(s) to stdout (fo
       } else {
         console.log(`Reading: ${skill.name}`);
       }
-      const skillDir = path16.join(basePath, ".skilltree", "skills", skill.id);
+      const skillDir = path17.join(basePath, ".skilltree", "skills", skill.id);
       console.log(`Base directory: ${skillDir}`);
       console.log("");
       console.log(serializeSkillMd(skill));
@@ -11150,6 +11260,7 @@ var readCommand = new Command23("read").description("Read skill(s) to stdout (fo
 });
 
 // src/cli/commands/materialize.ts
+init_esm_shims();
 import { Command as Command24 } from "commander";
 var materializeCommand = new Command24("materialize").description("Materialize skills to agent-discoverable paths").option("--paths <dirs>", "Comma-separated target directories (e.g. .claude/skills,.agent/skills)").option("--agents-md <path>", "Path to write AGENTS.md").option("--format <format>", "AGENTS.md format: xml, markdown, json", "xml").option("--mode <mode>", "Materialization mode: symlink or copy", "symlink").option("-w, --watch", "Watch for changes and re-materialize").action(async (options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -11210,17 +11321,23 @@ var materializeCommand = new Command24("materialize").description("Materialize s
 });
 
 // src/cli/commands/loadout/index.ts
-import { Command as Command38 } from "commander";
+init_esm_shims();
+import { Command as Command37 } from "commander";
 
 // src/cli/commands/loadout/list.ts
+init_esm_shims();
 import { Command as Command25 } from "commander";
 
+// src/cli/utils/loadout-server.ts
+init_esm_shims();
+
 // src/serving/state-persistence.ts
+init_esm_shims();
 import * as fs19 from "fs";
-import * as path17 from "path";
+import * as path18 from "path";
 var STATE_FILENAME = ".loadout-state.json";
 function loadState(skillPath) {
-  const filePath = path17.join(skillPath, STATE_FILENAME);
+  const filePath = path18.join(skillPath, STATE_FILENAME);
   try {
     const raw = fs19.readFileSync(filePath, "utf-8");
     const data = JSON.parse(raw);
@@ -11236,7 +11353,7 @@ function loadState(skillPath) {
   }
 }
 function saveState(skillPath, state) {
-  const filePath = path17.join(skillPath, STATE_FILENAME);
+  const filePath = path18.join(skillPath, STATE_FILENAME);
   const data = {
     available: Array.from(state.available.entries()),
     expanded: Array.from(state.expanded),
@@ -11247,7 +11364,7 @@ function saveState(skillPath, state) {
   fs19.writeFileSync(filePath, JSON.stringify(data, null, 2));
 }
 function clearState(skillPath) {
-  const filePath = path17.join(skillPath, STATE_FILENAME);
+  const filePath = path18.join(skillPath, STATE_FILENAME);
   try {
     fs19.unlinkSync(filePath);
     return true;
@@ -11323,6 +11440,7 @@ var listSubcommand = new Command25("list").description("List skills in the curre
 });
 
 // src/cli/commands/loadout/search.ts
+init_esm_shims();
 import { Command as Command26 } from "commander";
 var searchSubcommand = new Command26("search").description("Search for skills to add to the loadout").argument("<query>", "Search query").option("-l, --limit <n>", "Maximum results", "10").action(async (query, options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -11354,6 +11472,7 @@ var searchSubcommand = new Command26("search").description("Search for skills to
 });
 
 // src/cli/commands/loadout/add.ts
+init_esm_shims();
 import { Command as Command27 } from "commander";
 var addSubcommand = new Command27("add").description("Add skills to the loadout").argument("<ids...>", "Skill IDs to add").action(async (ids, _options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -11373,6 +11492,7 @@ var addSubcommand = new Command27("add").description("Add skills to the loadout"
 });
 
 // src/cli/commands/loadout/remove.ts
+init_esm_shims();
 import { Command as Command28 } from "commander";
 var removeSubcommand = new Command28("remove").description("Remove skills from the loadout").argument("<ids...>", "Skill IDs to remove").action(async (ids, _options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -11392,6 +11512,7 @@ var removeSubcommand = new Command28("remove").description("Remove skills from t
 });
 
 // src/cli/commands/loadout/profile.ts
+init_esm_shims();
 import { Command as Command29 } from "commander";
 var profileSubcommand = new Command29("profile").description("Switch to a named skill profile").argument("[name]", "Profile name (e.g. debugging, security, code-review)").option("--list", "List available profiles").action(async (name, options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -11424,6 +11545,7 @@ var profileSubcommand = new Command29("profile").description("Switch to a named
 });
 
 // src/cli/commands/loadout/set.ts
+init_esm_shims();
 import { Command as Command30 } from "commander";
 var setSubcommand = new Command30("set").description("Set loadout from criteria (tags, task description, etc.)").option("--tags <tags>", "Comma-separated tags to match").option("--task <description>", "Task description for semantic matching").option("--max-skills <n>", "Maximum number of skills").action(async (options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -11454,6 +11576,7 @@ var setSubcommand = new Command30("set").description("Set loadout from criteria
 });
 
 // src/cli/commands/loadout/expand.ts
+init_esm_shims();
 import { Command as Command31 } from "commander";
 var expandSubcommand = new Command31("expand").description("Expand a skill to see its full content").argument("<id>", "Skill ID to expand").action(async (id, _options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -11480,6 +11603,7 @@ var expandSubcommand = new Command31("expand").description("Expand a skill to se
 });
 
 // src/cli/commands/loadout/collapse.ts
+init_esm_shims();
 import { Command as Command32 } from "commander";
 var collapseSubcommand = new Command32("collapse").description("Collapse an expanded skill back to summary").argument("<id>", "Skill ID to collapse").action(async (id, _options, command) => {
   const globalOpts = command.optsWithGlobals();
@@ -11502,36 +11626,10 @@ var collapseSubcommand = new Command32("collapse").description("Collapse an expa
   }
 });
 
-// src/cli/commands/loadout/use.ts
-import { Command as Command33 } from "commander";
-var useSubcommand = new Command33("use").description("Mark a skill as being used (auto-expands and records usage)").argument("<id>", "Skill ID to use").action(async (id, _options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  try {
-    const { server, save } = await createLoadoutServer(globalOpts);
-    server.recordUsage(id);
-    const expanded = server.expandSkill(id);
-    if (!expanded) {
-      printError(`Skill "${id}" not found in loadout`);
-      process.exit(1);
-    }
-    save();
-    const skill = server.getState().available.get(id);
-    if (globalOpts.json) {
-      console.log(JSON.stringify(skill, null, 2));
-      return;
-    }
-    printSuccess(`Using "${id}"`);
-    console.log();
-    console.log(formatSkillDetail(skill));
-  } catch (error) {
-    printError(error.message);
-    process.exit(1);
-  }
-});
-
 // src/cli/commands/loadout/get.ts
-import { Command as Command34 } from "commander";
-var getSubcommand = new Command34("get").description("Get details about a skill in the loadout").argument("<id>", "Skill ID").action(async (id, _options, command) => {
+init_esm_shims();
+import { Command as Command33 } from "commander";
+var getSubcommand = new Command33("get").description("Get details about a skill in the loadout").argument("<id>", "Skill ID").action(async (id, _options, command) => {
   const globalOpts = command.optsWithGlobals();
   try {
     const { server } = await createLoadoutServer(globalOpts);
@@ -11553,8 +11651,9 @@ var getSubcommand = new Command34("get").description("Get details about a skill
 });
 
 // src/cli/commands/loadout/render.ts
-import { Command as Command35 } from "commander";
-var renderSubcommand = new Command35("render").description("Render the current loadout as a system prompt (XML or Markdown)").option("--format <format>", "Output format: xml or markdown", "xml").action(async (options, command) => {
+init_esm_shims();
+import { Command as Command34 } from "commander";
+var renderSubcommand = new Command34("render").description("Render the current loadout as a system prompt (XML or Markdown)").option("--format <format>", "Output format: xml or markdown", "xml").action(async (options, command) => {
   const globalOpts = command.optsWithGlobals();
   try {
     const { server } = await createLoadoutServer(globalOpts);
@@ -11572,8 +11671,9 @@ var renderSubcommand = new Command35("render").description("Render the current l
 });
 
 // src/cli/commands/loadout/clear.ts
-import { Command as Command36 } from "commander";
-var clearSubcommand = new Command36("clear").description("Clear the current loadout state").action(async (_options, command) => {
+init_esm_shims();
+import { Command as Command35 } from "commander";
+var clearSubcommand = new Command35("clear").description("Clear the current loadout state").action(async (_options, command) => {
   const globalOpts = command.optsWithGlobals();
   try {
     const skillPath = resolveSkillPath(globalOpts.path);
@@ -11594,15 +11694,16 @@ var clearSubcommand = new Command36("clear").description("Clear the current load
 });
 
 // src/cli/commands/loadout/browse.ts
-import { Command as Command37 } from "commander";
-var browseSubcommand = new Command37("browse").description("Browse the skill catalog by category").argument("[path]", "Category path to browse (e.g., Development/Python)").action(async (pathArg, _options, command) => {
+init_esm_shims();
+import { Command as Command36 } from "commander";
+var browseSubcommand = new Command36("browse").description("Browse the skill catalog by category").argument("[path]", "Category path to browse (e.g., Development/Python)").action(async (pathArg, _options, command) => {
   const globalOpts = command.optsWithGlobals();
   try {
     const { server } = await createLoadoutServer(globalOpts);
-    const path18 = pathArg ? pathArg.split("/").filter(Boolean) : void 0;
-    const output = await server.agentBrowseCatalog(path18);
+    const path19 = pathArg ? pathArg.split("/").filter(Boolean) : void 0;
+    const output = await server.agentBrowseCatalog(path19);
     if (globalOpts.json) {
-      console.log(JSON.stringify({ path: path18 ?? [], output }, null, 2));
+      console.log(JSON.stringify({ path: path19 ?? [], output }, null, 2));
       return;
     }
     if (!output) {
@@ -11617,10 +11718,10 @@ var browseSubcommand = new Command37("browse").description("Browse the skill cat
 });
 
 // src/cli/commands/loadout/index.ts
-var loadoutCommand = new Command38("loadout").description("Manage skill loadouts for agent sessions").addCommand(listSubcommand).addCommand(searchSubcommand).addCommand(addSubcommand).addCommand(removeSubcommand).addCommand(profileSubcommand).addCommand(setSubcommand).addCommand(expandSubcommand).addCommand(collapseSubcommand).addCommand(useSubcommand).addCommand(getSubcommand).addCommand(renderSubcommand).addCommand(clearSubcommand).addCommand(browseSubcommand);
+var loadoutCommand = new Command37("loadout").description("Manage skill loadouts for agent sessions").addCommand(listSubcommand).addCommand(searchSubcommand).addCommand(addSubcommand).addCommand(removeSubcommand).addCommand(profileSubcommand).addCommand(setSubcommand).addCommand(expandSubcommand).addCommand(collapseSubcommand).addCommand(getSubcommand).addCommand(renderSubcommand).addCommand(clearSubcommand).addCommand(browseSubcommand);
 
 // src/cli/index.ts
-var program = new Command39();
+var program = new Command38();
 var config = loadConfig();
 program.name("skill-tree").description("Management CLI for agent skills").version(VERSION).option("-p, --path <dir>", "Skills directory path", config.storage.path).option("-c, --config <file>", "Config file path", getConfigPath()).option("--json", "Output as JSON", config.cli.output_format === "json").option("-q, --quiet", "Suppress non-essential output", config.cli.quiet).option("--no-color", "Disable colored output", !config.cli.color);
 program.addCommand(listCommand);
@@ -11643,4 +11744,3 @@ program.addCommand(readCommand);
 program.addCommand(materializeCommand);
 program.addCommand(loadoutCommand);
 program.parse();
-//# sourceMappingURL=index.mjs.map