skill-tree 0.1.4 → 0.1.5

package/dist/cli/index.js

@@ -136,10 +136,8 @@ var init_base = __esm({
           const searchText = [
             skill.name,
             skill.description,
-            skill.problem,
-            skill.solution,
-            ...skill.tags,
-            skill.triggerConditions.map((t) => t.value).join(" ")
+            skill.instructions,
+            ...skill.tags
           ].join(" ").toLowerCase();
           return terms.every((term) => searchText.includes(term));
         });
@@ -264,9 +262,7 @@ var init_base = __esm({
       }
       hashSkill(skill) {
         const content = JSON.stringify({
-          problem: skill.problem,
-          solution: skill.solution,
-          triggerConditions: skill.triggerConditions
+          instructions: skill.instructions
         });
         let hash = 0;
         for (let i = 0; i < content.length; i++) {
@@ -315,7 +311,7 @@ var init_sqlite = __esm({
     path7 = __toESM(require("path"));
     fs7 = __toESM(require("fs"));
     init_base();
-    SCHEMA_VERSION = 2;
+    SCHEMA_VERSION = 3;
     SQLiteStorageAdapter = class extends BaseStorageAdapter {
       constructor(config2) {
         super();
@@ -353,12 +349,8 @@ var init_sqlite = __esm({
         version TEXT NOT NULL,
         name TEXT NOT NULL,
         description TEXT NOT NULL,
-        problem TEXT NOT NULL,
-        trigger_conditions TEXT NOT NULL,
-        solution TEXT NOT NULL,
-        verification TEXT NOT NULL,
-        examples TEXT NOT NULL,
-        notes TEXT,
+        instructions TEXT NOT NULL DEFAULT '',
+        related TEXT,
         author TEXT NOT NULL,
         tags TEXT NOT NULL,
         created_at TEXT NOT NULL,
@@ -413,10 +405,8 @@ var init_sqlite = __esm({
           skill_id,
           name,
           description,
-          problem,
-          solution,
-          tags,
-          trigger_values
+          instructions,
+          tags
         )
       `);
         }
@@ -491,6 +481,49 @@ var init_sqlite = __esm({
             } catch {
             }
           }
+          if (currentVersion < 3) {
+            try {
+              db.exec("ALTER TABLE skills ADD COLUMN instructions TEXT NOT NULL DEFAULT ''");
+            } catch {
+            }
+            try {
+              db.exec("ALTER TABLE skills ADD COLUMN related TEXT");
+            } catch {
+            }
+            try {
+              db.exec(`
+            UPDATE skills SET instructions =
+              COALESCE(problem, '') || CHAR(10) || CHAR(10) ||
+              COALESCE(solution, '') || CHAR(10) || CHAR(10) ||
+              COALESCE(verification, '')
+            WHERE instructions = ''
+          `);
+            } catch {
+            }
+            if (this.config.enableFTS) {
+              try {
+                db.exec("DROP TABLE IF EXISTS skills_fts");
+                db.exec(`
+              CREATE VIRTUAL TABLE skills_fts USING fts5(
+                skill_id, name, description, instructions, tags
+              )
+            `);
+                const rows = db.prepare("SELECT id, name, description, instructions, tags FROM skills").all();
+                const insertFts = db.prepare("INSERT INTO skills_fts (skill_id, name, description, instructions, tags) VALUES (?, ?, ?, ?, ?)");
+                for (const row2 of rows) {
+                  const tags = (() => {
+                    try {
+                      return JSON.parse(row2.tags).join(" ");
+                    } catch {
+                      return row2.tags;
+                    }
+                  })();
+                  insertFts.run(row2.id, row2.name, row2.description, row2.instructions, tags);
+                }
+              } catch {
+              }
+            }
+          }
           db.prepare("UPDATE schema_version SET version = ?").run(SCHEMA_VERSION);
         }
       }
@@ -505,11 +538,11 @@ var init_sqlite = __esm({
         const db = this.getDb();
         const stmt = db.prepare(`
       INSERT OR REPLACE INTO skills (
-        id, version, name, description, problem, trigger_conditions, solution,
-        verification, examples, notes, author, tags, created_at, updated_at,
-        status, parent_version, derived_from, metrics, source, taxonomy, external_source
+        id, version, name, description, instructions, related, author, tags,
+        created_at, updated_at, status, parent_version, derived_from, metrics,
+        source, taxonomy, external_source
       ) VALUES (
-        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
       )
     `);
         stmt.run(
@@ -517,12 +550,8 @@ var init_sqlite = __esm({
           skill.version,
           skill.name,
           skill.description,
-          skill.problem,
-          JSON.stringify(skill.triggerConditions),
-          skill.solution,
-          skill.verification,
-          JSON.stringify(skill.examples),
-          skill.notes || null,
+          skill.instructions,
+          skill.related ? JSON.stringify(skill.related) : null,
           skill.author,
           JSON.stringify(skill.tags),
           skill.createdAt.toISOString(),
@@ -550,12 +579,11 @@ var init_sqlite = __esm({
       updateFTSIndex(skill) {
         const db = this.getDb();
         db.prepare("DELETE FROM skills_fts WHERE skill_id = ?").run(skill.id);
-        const triggerValues = skill.triggerConditions.map((t) => t.value).join(" ");
         const tags = skill.tags.join(" ");
         db.prepare(`
-      INSERT INTO skills_fts (skill_id, name, description, problem, solution, tags, trigger_values)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `).run(skill.id, skill.name, skill.description, skill.problem, skill.solution, tags, triggerValues);
+      INSERT INTO skills_fts (skill_id, name, description, instructions, tags)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(skill.id, skill.name, skill.description, skill.instructions, tags);
       }
       async saveVersionSnapshot(skill) {
         const db = this.getDb();
@@ -825,15 +853,15 @@ var init_sqlite = __esm({
       /**
        * Get or create a taxonomy node
        */
-      async ensureTaxonomyNode(path15) {
+      async ensureTaxonomyNode(path18) {
         this.ensureInitialized();
         const db = this.getDb();
-        const pathStr = path15.join("/");
+        const pathStr = path18.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 = path15[path15.length - 1] || "Root";
-        const parentPath = path15.slice(0, -1);
+        const name = path18[path18.length - 1] || "Root";
+        const parentPath = path18.slice(0, -1);
         let parentId = null;
         if (parentPath.length > 0) {
           parentId = await this.ensureTaxonomyNode(parentPath);
@@ -1015,12 +1043,8 @@ var init_sqlite = __esm({
           version: row.version,
           name: row.name,
           description: row.description,
-          problem: row.problem,
-          triggerConditions: JSON.parse(row.trigger_conditions),
-          solution: row.solution,
-          verification: row.verification,
-          examples: JSON.parse(row.examples),
-          notes: row.notes || void 0,
+          instructions: row.instructions,
+          related: row.related ? JSON.parse(row.related) : void 0,
           author: row.author,
           tags: JSON.parse(row.tags),
           createdAt: new Date(row.created_at),
@@ -1069,9 +1093,7 @@ var init_sqlite = __esm({
       }
       hashSkill(skill) {
         const content = JSON.stringify({
-          problem: skill.problem,
-          solution: skill.solution,
-          triggerConditions: skill.triggerConditions
+          instructions: skill.instructions
         });
         let hash = 0;
         for (let i = 0; i < content.length; i++) {
@@ -1085,8 +1107,677 @@ var init_sqlite = __esm({
   }
 });
 
+// src/agents/types.ts
+var DEFAULT_AGENTS_CONFIG;
+var init_types = __esm({
+  "src/agents/types.ts"() {
+    "use strict";
+    DEFAULT_AGENTS_CONFIG = {
+      format: "xml",
+      includeIds: true,
+      includeVersions: true,
+      groupByTags: false
+    };
+  }
+});
+
+// src/agents/generator.ts
+var AgentsGenerator;
+var init_generator = __esm({
+  "src/agents/generator.ts"() {
+    "use strict";
+    init_types();
+    AgentsGenerator = class {
+      constructor(config2) {
+        this.config = { ...DEFAULT_AGENTS_CONFIG, ...config2 };
+      }
+      /**
+       * Generate AGENTS.md content from a skill bank
+       */
+      async generate(storage) {
+        let skills = await storage.listSkills({
+          status: this.config.filter?.status || ["active"]
+        });
+        skills = this.filterSkills(skills, this.config.filter);
+        skills.sort((a, b) => a.name.localeCompare(b.name));
+        const sections = [];
+        if (this.config.header) {
+          sections.push(this.config.header);
+        } else {
+          sections.push(this.generateDefaultHeader());
+        }
+        if (this.config.groupByTags) {
+          sections.push(this.generateGroupedSkills(skills));
+        } else {
+          sections.push(this.generateSkillsList(skills));
+        }
+        if (this.config.footer) {
+          sections.push(this.config.footer);
+        }
+        return sections.join("\n\n");
+      }
+      /**
+       * Generate content for a single skill
+       */
+      generateSkill(skill) {
+        switch (this.config.format) {
+          case "xml":
+            return this.generateXmlSkill(skill);
+          case "markdown":
+            return this.generateMarkdownSkill(skill);
+          case "json":
+            return this.generateJsonSkill(skill);
+          default:
+            return this.generateXmlSkill(skill);
+        }
+      }
+      /**
+       * Generate skills list
+       */
+      generateSkillsList(skills) {
+        return skills.map((skill) => this.generateSkill(skill)).join("\n\n");
+      }
+      /**
+       * Generate skills grouped by tags
+       */
+      generateGroupedSkills(skills) {
+        const tagGroups = /* @__PURE__ */ new Map();
+        const untagged = [];
+        for (const skill of skills) {
+          if (skill.tags.length === 0) {
+            untagged.push(skill);
+          } else {
+            const primaryTag = skill.tags[0];
+            if (!tagGroups.has(primaryTag)) {
+              tagGroups.set(primaryTag, []);
+            }
+            tagGroups.get(primaryTag).push(skill);
+          }
+        }
+        const sections = [];
+        const sortedTags = Array.from(tagGroups.keys()).sort();
+        for (const tag of sortedTags) {
+          const tagSkills = tagGroups.get(tag);
+          sections.push(`## ${this.formatTagName(tag)}
+
+${this.generateSkillsList(tagSkills)}`);
+        }
+        if (untagged.length > 0) {
+          sections.push(`## Other
+
+${this.generateSkillsList(untagged)}`);
+        }
+        return sections.join("\n\n");
+      }
+      /**
+       * Generate XML format skill (Claude Code native format)
+       */
+      generateXmlSkill(skill) {
+        const lines = [];
+        const attrs = [];
+        if (this.config.includeIds) {
+          attrs.push(`id="${this.escapeXml(skill.id)}"`);
+        }
+        if (this.config.includeVersions) {
+          attrs.push(`version="${this.escapeXml(skill.version)}"`);
+        }
+        const attrStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+        lines.push(`<skill${attrStr}>`);
+        lines.push(`  <name>${this.escapeXml(skill.name)}</name>`);
+        if (skill.description) {
+          lines.push(`  <description>${this.escapeXml(skill.description)}</description>`);
+        }
+        if (skill.instructions) {
+          lines.push(`  <content>
+${this.indentContent(skill.instructions, 4)}
+  </content>`);
+        }
+        if (skill.tags.length > 0) {
+          lines.push(`  <tags>${skill.tags.map((t) => this.escapeXml(t)).join(", ")}</tags>`);
+        }
+        lines.push("</skill>");
+        return lines.join("\n");
+      }
+      /**
+       * Generate Markdown format skill
+       */
+      generateMarkdownSkill(skill) {
+        const lines = [];
+        const idSuffix = this.config.includeIds ? ` {#${skill.id}}` : "";
+        const versionSuffix = this.config.includeVersions ? ` (v${skill.version})` : "";
+        lines.push(`### ${skill.name}${versionSuffix}${idSuffix}`);
+        lines.push("");
+        if (skill.description) {
+          lines.push(`*${skill.description}*`);
+          lines.push("");
+        }
+        if (skill.instructions) {
+          lines.push(skill.instructions);
+          lines.push("");
+        }
+        if (skill.tags.length > 0) {
+          lines.push(`Tags: ${skill.tags.map((t) => `\`${t}\``).join(", ")}`);
+        }
+        return lines.join("\n");
+      }
+      /**
+       * Generate JSON format skill
+       */
+      generateJsonSkill(skill) {
+        const obj = {
+          name: skill.name,
+          description: skill.description
+        };
+        if (this.config.includeIds) {
+          obj.id = skill.id;
+        }
+        if (this.config.includeVersions) {
+          obj.version = skill.version;
+        }
+        if (skill.instructions) {
+          obj.instructions = skill.instructions;
+        }
+        if (skill.tags.length > 0) {
+          obj.tags = skill.tags;
+        }
+        return "```json\n" + JSON.stringify(obj, null, 2) + "\n```";
+      }
+      /**
+       * Filter skills based on selector
+       */
+      filterSkills(skills, filter) {
+        if (!filter) return skills;
+        let result = skills;
+        if (filter.ids && filter.ids.length > 0) {
+          result = result.filter((s) => filter.ids.includes(s.id));
+        }
+        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);
+        }
+        return result;
+      }
+      /**
+       * Generate default header
+       */
+      generateDefaultHeader() {
+        return `# Agent Skills
+
+This file contains skills for the AI agent. Each skill describes a pattern for solving a specific type of problem.
+
+---`;
+      }
+      /**
+       * Format tag name for section header
+       */
+      formatTagName(tag) {
+        return tag.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+      }
+      /**
+       * Escape XML special characters
+       */
+      escapeXml(str) {
+        return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+      }
+      /**
+       * Indent content
+       */
+      indentContent(content, spaces) {
+        const indent = " ".repeat(spaces);
+        return content.split("\n").map((line) => indent + line).join("\n");
+      }
+    };
+  }
+});
+
+// src/agents/parser.ts
+var AgentsParser;
+var init_parser = __esm({
+  "src/agents/parser.ts"() {
+    "use strict";
+    AgentsParser = class {
+      /**
+       * Parse AGENTS.md content
+       */
+      parse(content) {
+        const warnings = [];
+        const skills = [];
+        const xmlSkills = this.parseXmlSkills(content);
+        if (xmlSkills.length > 0) {
+          skills.push(...xmlSkills);
+        }
+        const mdSkills = this.parseMarkdownSkills(content, xmlSkills);
+        if (mdSkills.length > 0) {
+          const existingNames = new Set(skills.map((s) => s.name.toLowerCase()));
+          for (const skill of mdSkills) {
+            if (!existingNames.has(skill.name.toLowerCase())) {
+              skills.push(skill);
+            }
+          }
+        }
+        const header = this.extractHeader(content, skills);
+        const footer = this.extractFooter(content, skills);
+        if (skills.length === 0) {
+          warnings.push("No skills found in AGENTS.md");
+        }
+        return { header, skills, footer, warnings };
+      }
+      /**
+       * Convert parsed skill to Skill type
+       */
+      toSkill(parsed, defaults) {
+        const now = /* @__PURE__ */ new Date();
+        const id = parsed.id || this.generateId(parsed.name);
+        let instructions = parsed.instructions || "";
+        if (!instructions) {
+          const instructionParts = [];
+          if (parsed.problem) instructionParts.push(parsed.problem);
+          if (parsed.solution) instructionParts.push(parsed.solution);
+          if (parsed.verification) instructionParts.push(parsed.verification);
+          if (parsed.notes) instructionParts.push(parsed.notes);
+          instructions = instructionParts.length > 0 ? instructionParts.join("\n\n") : "";
+        }
+        return {
+          id,
+          name: parsed.name,
+          version: parsed.version || "1.0.0",
+          description: parsed.description || "",
+          instructions,
+          author: defaults?.author || "imported",
+          tags: parsed.tags || [],
+          createdAt: defaults?.createdAt || now,
+          updatedAt: now,
+          status: "active",
+          metrics: defaults?.metrics || {
+            usageCount: 0,
+            successRate: 0,
+            feedbackScores: []
+          },
+          source: {
+            type: "imported",
+            location: "AGENTS.md",
+            importedAt: now
+          },
+          ...defaults
+        };
+      }
+      /**
+       * Parse XML format skills
+       */
+      parseXmlSkills(content) {
+        const skills = [];
+        const skillRegex = /<skill([^>]*)>([\s\S]*?)<\/skill>/gi;
+        let match;
+        while ((match = skillRegex.exec(content)) !== null) {
+          const attrs = match[1];
+          const body = match[2];
+          const skill = {
+            rawContent: match[0],
+            name: this.extractXmlTag(body, "name") || "Unnamed Skill",
+            description: this.extractXmlTag(body, "description") || ""
+          };
+          const idMatch = /id="([^"]+)"/.exec(attrs);
+          if (idMatch) {
+            skill.id = idMatch[1];
+          }
+          const versionMatch = /version="([^"]+)"/.exec(attrs);
+          if (versionMatch) {
+            skill.version = versionMatch[1];
+          }
+          const contentTag = this.extractXmlTag(body, "content");
+          if (contentTag) {
+            skill.instructions = contentTag;
+          } else {
+            skill.problem = this.extractXmlTag(body, "problem");
+            skill.solution = this.extractXmlTag(body, "solution");
+            skill.verification = this.extractXmlTag(body, "verification");
+            skill.notes = this.extractXmlTag(body, "notes");
+          }
+          const tagsStr = this.extractXmlTag(body, "tags");
+          if (tagsStr) {
+            skill.tags = tagsStr.split(",").map((t) => t.trim()).filter((t) => t);
+          }
+          skills.push(skill);
+        }
+        return skills;
+      }
+      /**
+       * Parse Markdown format skills
+       */
+      parseMarkdownSkills(content, existingSkills) {
+        const skills = [];
+        const sections = content.split(/(?=^###\s)/m);
+        for (const section of sections) {
+          const headerMatch = /^###\s+(.+?)(?:\s+\(v([\d.]+)\))?(?:\s+\{#([^}]+)\})?\s*$/m.exec(section);
+          if (!headerMatch) continue;
+          const name = headerMatch[1].trim();
+          const version = headerMatch[2];
+          const id = headerMatch[3];
+          if (existingSkills.some((s) => s.name.toLowerCase() === name.toLowerCase())) {
+            continue;
+          }
+          const skill = {
+            rawContent: section,
+            name,
+            description: ""
+          };
+          if (version) skill.version = version;
+          if (id) skill.id = id;
+          const descMatch = /^\*([^*]+)\*$/m.exec(section);
+          if (descMatch) {
+            skill.description = descMatch[1];
+          }
+          const bodyStart = section.indexOf("\n", section.indexOf(headerMatch[0]) + headerMatch[0].length);
+          if (bodyStart >= 0) {
+            let bodyContent = section.slice(bodyStart).trim();
+            bodyContent = bodyContent.replace(/^\*[^*]+\*\s*\n?/, "").trim();
+            bodyContent = bodyContent.replace(/\nTags:\s*.+$/m, "").trim();
+            if (bodyContent) {
+              skill.instructions = bodyContent;
+            }
+          }
+          if (!skill.instructions) {
+            skill.problem = this.extractMarkdownSection(section, "Problem");
+            skill.solution = this.extractMarkdownSection(section, "Solution");
+            skill.verification = this.extractMarkdownSection(section, "Verification");
+            skill.notes = this.extractMarkdownSection(section, "Notes");
+          }
+          const tagsMatch = /Tags:\s*(.+)$/m.exec(section);
+          if (tagsMatch) {
+            skill.tags = tagsMatch[1].split(",").map((t) => t.replace(/`/g, "").trim()).filter((t) => t);
+          }
+          skills.push(skill);
+        }
+        return skills;
+      }
+      /**
+       * Extract content from XML tag
+       */
+      extractXmlTag(body, tagName) {
+        const regex = new RegExp(`<${tagName}>([\\s\\S]*?)<\\/${tagName}>`, "i");
+        const match = regex.exec(body);
+        if (match) {
+          return this.unescapeXml(match[1].trim());
+        }
+        return void 0;
+      }
+      /**
+       * Extract CDATA content
+       */
+      extractCData(body, tagName) {
+        const regex = new RegExp(`<${tagName}><!\\[CDATA\\[([\\s\\S]*?)\\]\\]><\\/${tagName}>`, "i");
+        const match = regex.exec(body);
+        if (match) {
+          return match[1];
+        }
+        return void 0;
+      }
+      /**
+       * Unescape XML entities
+       */
+      unescapeXml(str) {
+        return str.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+      }
+      /**
+       * Extract a markdown section by header
+       */
+      extractMarkdownSection(content, header) {
+        const regex = new RegExp(`\\*\\*${header}:\\*\\*\\s*([\\s\\S]*?)(?=\\*\\*|Tags:|$)`, "i");
+        const match = regex.exec(content);
+        if (match) {
+          return match[1].trim();
+        }
+        return void 0;
+      }
+      /**
+       * Generate ID from skill name
+       */
+      generateId(name) {
+        return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+      }
+      /**
+       * Extract header content
+       */
+      extractHeader(content, skills) {
+        if (skills.length === 0) return content.trim() || void 0;
+        const firstSkill = skills[0];
+        const idx = content.indexOf(firstSkill.rawContent);
+        if (idx > 0) {
+          return content.slice(0, idx).trim() || void 0;
+        }
+        return void 0;
+      }
+      /**
+       * Extract footer content
+       */
+      extractFooter(content, skills) {
+        if (skills.length === 0) return void 0;
+        const lastSkill = skills[skills.length - 1];
+        const idx = content.indexOf(lastSkill.rawContent);
+        if (idx >= 0) {
+          const afterIdx = idx + lastSkill.rawContent.length;
+          const footer = content.slice(afterIdx).trim();
+          return footer || void 0;
+        }
+        return void 0;
+      }
+    };
+  }
+});
+
+// src/agents/sync.ts
+var sync_exports = {};
+__export(sync_exports, {
+  AgentsSync: () => AgentsSync,
+  createAgentsSync: () => createAgentsSync,
+  generateAgentsMd: () => generateAgentsMd,
+  importFromAgentsMd: () => importFromAgentsMd,
+  writeAgentsMd: () => writeAgentsMd
+});
+function createAgentsSync() {
+  return new AgentsSync();
+}
+async function generateAgentsMd(storage, config2) {
+  const generator = new AgentsGenerator(config2);
+  return generator.generate(storage);
+}
+async function writeAgentsMd(storage, filePath, config2) {
+  const content = await generateAgentsMd(storage, config2);
+  const dir = path9.dirname(filePath);
+  if (dir && !fs9.existsSync(dir)) {
+    fs9.mkdirSync(dir, { recursive: true });
+  }
+  fs9.writeFileSync(filePath, content);
+}
+async function importFromAgentsMd(filePath, storage, options) {
+  const sync = new AgentsSync();
+  return sync.sync(filePath, storage, {
+    direction: "import",
+    conflictStrategy: options?.conflictStrategy || "skip",
+    dryRun: options?.dryRun
+  });
+}
+var fs9, path9, AgentsSync;
+var init_sync = __esm({
+  "src/agents/sync.ts"() {
+    "use strict";
+    fs9 = __toESM(require("fs"));
+    path9 = __toESM(require("path"));
+    init_generator();
+    init_parser();
+    AgentsSync = class {
+      constructor() {
+        this.generator = new AgentsGenerator();
+        this.parser = new AgentsParser();
+      }
+      /**
+       * Sync AGENTS.md with skill bank
+       */
+      async sync(agentsPath, storage, options) {
+        const result = {
+          added: [],
+          updated: [],
+          removed: [],
+          unchanged: [],
+          warnings: []
+        };
+        switch (options.direction) {
+          case "import":
+            await this.importFromAgents(agentsPath, storage, options, result);
+            break;
+          case "export":
+            await this.exportToAgents(agentsPath, storage, options, result);
+            break;
+          case "bidirectional":
+            await this.bidirectionalSync(agentsPath, storage, options, result);
+            break;
+        }
+        return result;
+      }
+      /**
+       * Import skills from AGENTS.md to skill bank
+       */
+      async importFromAgents(agentsPath, storage, options, result) {
+        if (!fs9.existsSync(agentsPath)) {
+          result.warnings.push(`AGENTS.md not found at ${agentsPath}`);
+          return;
+        }
+        const content = fs9.readFileSync(agentsPath, "utf-8");
+        const parsed = this.parser.parse(content);
+        result.warnings.push(...parsed.warnings);
+        const existingSkills = await storage.listSkills();
+        const existingById = new Map(existingSkills.map((s) => [s.id, s]));
+        const existingByName = new Map(existingSkills.map((s) => [s.name.toLowerCase(), s]));
+        const processedIds = /* @__PURE__ */ new Set();
+        for (const parsedSkill of parsed.skills) {
+          const skill = this.parser.toSkill(parsedSkill);
+          processedIds.add(skill.id);
+          let existing = existingById.get(skill.id);
+          if (!existing) {
+            existing = existingByName.get(skill.name.toLowerCase());
+          }
+          if (existing) {
+            const shouldUpdate = this.resolveConflict(existing, skill, options.conflictStrategy);
+            if (shouldUpdate) {
+              if (!options.dryRun) {
+                const merged = this.mergeSkills(existing, skill);
+                await storage.saveSkill(merged);
+              }
+              result.updated.push(skill.id);
+            } else {
+              result.unchanged.push(skill.id);
+            }
+          } else {
+            if (!options.dryRun) {
+              await storage.saveSkill(skill);
+            }
+            result.added.push(skill.id);
+          }
+        }
+        if (options.removeOrphans) {
+          for (const existing of existingSkills) {
+            if (!processedIds.has(existing.id)) {
+              if (!options.dryRun) {
+                await storage.deleteSkill(existing.id);
+              }
+              result.removed.push(existing.id);
+            }
+          }
+        }
+      }
+      /**
+       * Export skills from skill bank to AGENTS.md
+       */
+      async exportToAgents(agentsPath, storage, options, result) {
+        const generator = new AgentsGenerator(options.generatorConfig);
+        const content = await generator.generate(storage);
+        let existingContent = "";
+        if (fs9.existsSync(agentsPath)) {
+          existingContent = fs9.readFileSync(agentsPath, "utf-8");
+        }
+        const existingParsed = this.parser.parse(existingContent);
+        const existingIds = new Set(existingParsed.skills.map((s) => s.id || s.name.toLowerCase()));
+        const skills = await storage.listSkills({
+          status: options.generatorConfig?.filter?.status || ["active"]
+        });
+        for (const skill of skills) {
+          if (existingIds.has(skill.id) || existingIds.has(skill.name.toLowerCase())) {
+            result.updated.push(skill.id);
+          } else {
+            result.added.push(skill.id);
+          }
+        }
+        if (!options.dryRun) {
+          const dir = path9.dirname(agentsPath);
+          if (!fs9.existsSync(dir)) {
+            fs9.mkdirSync(dir, { recursive: true });
+          }
+          fs9.writeFileSync(agentsPath, content);
+        }
+      }
+      /**
+       * Bidirectional sync
+       */
+      async bidirectionalSync(agentsPath, storage, options, result) {
+        await this.importFromAgents(agentsPath, storage, { ...options, removeOrphans: false }, result);
+        const exportResult = {
+          added: [],
+          updated: [],
+          removed: [],
+          unchanged: [],
+          warnings: []
+        };
+        await this.exportToAgents(agentsPath, storage, options, exportResult);
+        for (const id of exportResult.added) {
+          if (!result.added.includes(id) && !result.updated.includes(id)) {
+            result.added.push(id);
+          }
+        }
+      }
+      /**
+       * Resolve conflict between existing and new skill
+       */
+      resolveConflict(existing, incoming, strategy) {
+        switch (strategy) {
+          case "bank-wins":
+            return false;
+          case "agents-wins":
+            return true;
+          case "newer-wins":
+            return incoming.updatedAt > existing.updatedAt;
+          case "skip":
+          default:
+            return false;
+        }
+      }
+      /**
+       * Merge skills, preserving important data from existing
+       */
+      mergeSkills(existing, incoming) {
+        return {
+          ...incoming,
+          id: existing.id,
+          // 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
+        };
+      }
+    };
+  }
+});
+
 // src/cli/index.ts
-var import_commander36 = require("commander");
+var import_commander38 = require("commander");
 
 // src/types.ts
 function hasTaxonomySupport(storage) {
@@ -1860,13 +2551,8 @@ ${remoteValue}`;
   }
   getConflictingFields(local, remote) {
     const fields = [
-      "problem",
-      "solution",
-      "verification",
-      "triggerConditions",
-      "examples",
-      "tags",
-      "notes"
+      "instructions",
+      "tags"
     ];
     return fields.filter((field) => {
       const localValue = local[field];
@@ -1901,12 +2587,7 @@ ${remoteValue}`;
       name: metadata.name || skillId,
       version: metadata.version || "1.0.0",
       description: metadata.description || "",
-      problem: this.extractSection(body, "Problem") || "",
-      solution: this.extractSection(body, "Solution") || "",
-      verification: this.extractSection(body, "Verification") || "",
-      triggerConditions: [],
-      examples: [],
-      notes: this.extractSection(body, "Notes"),
+      instructions: body.trim(),
       author: metadata.author || "unknown",
       tags: metadata.tags ? metadata.tags.split(",").map((t) => t.trim()) : [],
       createdAt: metadata.created ? new Date(metadata.created) : /* @__PURE__ */ new Date(),
@@ -1919,14 +2600,6 @@ ${remoteValue}`;
       }
     };
   }
-  extractSection(content, heading) {
-    const regex = new RegExp(
-      `## ${heading}\\n([\\s\\S]*?)(?=\\n## |$)`,
-      "i"
-    );
-    const match = content.match(regex);
-    return match ? match[1].trim() : void 0;
-  }
   async writeSkill(skill) {
     const skillPath = this.getSkillFilePath(skill.id);
     const fullPath = path2.join(this.repoPath, skillPath);
@@ -1951,21 +2624,8 @@ ${remoteValue}`;
       "",
       skill.description,
       "",
-      "## Problem",
-      "",
-      skill.problem,
-      "",
-      "## Solution",
-      "",
-      skill.solution,
-      "",
-      "## Verification",
-      "",
-      skill.verification
+      skill.instructions
     ];
-    if (skill.notes) {
-      body.push("", "## Notes", "", skill.notes);
-    }
     return `${frontmatter}
 
 ${body.join("\n")}
@@ -2017,13 +2677,8 @@ ${body.join("\n")}
   }
   hashSkill(skill) {
     const content = JSON.stringify({
-      problem: skill.problem,
-      solution: skill.solution,
-      verification: skill.verification,
-      triggerConditions: skill.triggerConditions,
-      examples: skill.examples,
-      tags: skill.tags,
-      notes: skill.notes
+      instructions: skill.instructions,
+      tags: skill.tags
     });
     let hash = 0;
     for (let i = 0; i < content.length; i++) {
@@ -2419,11 +3074,7 @@ var LoadoutCompiler = class {
     const text = [
       skill.name,
       skill.description,
-      skill.problem,
-      skill.solution,
-      skill.verification,
-      skill.notes ?? "",
-      ...skill.examples.map((e) => `${e.scenario} ${e.before} ${e.after}`)
+      skill.instructions
     ].join(" ");
     return Math.ceil(text.length / 4);
   }
@@ -2658,8 +3309,7 @@ var ProjectDetector = _ProjectDetector;
 // src/serving/view-renderer.ts
 var DEFAULT_CONFIG2 = {
   includeTokenEstimates: false,
-  maxSummaryLength: 150,
-  includeExamples: true
+  maxSummaryLength: 150
 };
 var ViewRenderer = class {
   constructor(config2) {
@@ -2688,7 +3338,7 @@ var ViewRenderer = class {
           lines.push(`  <tokens>${tokens}</tokens>`);
         }
         lines.push("  <content>");
-        lines.push(this.renderSkillContent(skill));
+        lines.push(skill.instructions.split("\n").map((line) => "    " + line).join("\n"));
         lines.push("  </content>");
         lines.push("</skill>");
       } else {
@@ -2742,12 +3392,7 @@ var ViewRenderer = class {
       for (const [, skill] of expandedSkills) {
         lines.push(`### ${skill.name}`);
         lines.push("");
-        lines.push(`**Problem:** ${skill.problem}`);
-        lines.push("");
-        lines.push(`**Solution:**`);
-        lines.push(skill.solution);
-        lines.push("");
-        lines.push(`**Verification:** ${skill.verification}`);
+        lines.push(skill.instructions);
         lines.push("");
         lines.push("---");
         lines.push("");
@@ -2768,44 +3413,8 @@ var ViewRenderer = class {
     }
     lines.push("---");
     lines.push("");
-    lines.push(`# ${skill.name}`);
-    lines.push("");
-    lines.push("## Problem");
-    lines.push("");
-    lines.push(skill.problem);
-    lines.push("");
-    lines.push("## Solution");
+    lines.push(skill.instructions);
     lines.push("");
-    lines.push(skill.solution);
-    lines.push("");
-    lines.push("## Verification");
-    lines.push("");
-    lines.push(skill.verification);
-    lines.push("");
-    if (this.config.includeExamples && skill.examples.length > 0) {
-      lines.push("## Examples");
-      lines.push("");
-      for (const example of skill.examples) {
-        lines.push(`### ${example.scenario}`);
-        lines.push("");
-        lines.push("**Before:**");
-        lines.push("```");
-        lines.push(example.before);
-        lines.push("```");
-        lines.push("");
-        lines.push("**After:**");
-        lines.push("```");
-        lines.push(example.after);
-        lines.push("```");
-        lines.push("");
-      }
-    }
-    if (skill.notes) {
-      lines.push("## Notes");
-      lines.push("");
-      lines.push(skill.notes);
-      lines.push("");
-    }
     return lines.join("\n");
   }
   /**
@@ -2855,35 +3464,6 @@ var ViewRenderer = class {
     }
     return skill.description.substring(0, this.config.maxSummaryLength - 3) + "...";
   }
-  /**
-   * Render skill content for expanded view
-   */
-  renderSkillContent(skill) {
-    const lines = [];
-    lines.push("## Problem");
-    lines.push(skill.problem);
-    lines.push("");
-    lines.push("## Solution");
-    lines.push(skill.solution);
-    lines.push("");
-    lines.push("## Verification");
-    lines.push(skill.verification);
-    if (skill.notes) {
-      lines.push("");
-      lines.push("## Notes");
-      lines.push(skill.notes);
-    }
-    if (this.config.includeExamples && skill.examples.length > 0) {
-      lines.push("");
-      lines.push("## Examples");
-      for (const ex of skill.examples) {
-        lines.push(`### ${ex.scenario}`);
-        lines.push(`Before: ${ex.before}`);
-        lines.push(`After: ${ex.after}`);
-      }
-    }
-    return lines.map((line) => "    " + line).join("\n");
-  }
   /**
    * Escape special XML characters
    */
@@ -2900,11 +3480,7 @@ var ViewRenderer = class {
     const content = [
       skill.name,
       skill.description,
-      skill.problem,
-      skill.solution,
-      skill.verification,
-      skill.notes ?? "",
-      ...skill.examples.map((e) => `${e.scenario} ${e.before} ${e.after}`)
+      skill.instructions
     ].join(" ");
     return Math.ceil(content.length / 4);
   }
@@ -3262,7 +3838,7 @@ var SkillGraphServer = class {
     const allSkills = await this.storage.listSkills({ status: ["active"] });
     const queryLower = query.toLowerCase();
     const matches = allSkills.filter(
-      (skill) => skill.name.toLowerCase().includes(queryLower) || skill.description.toLowerCase().includes(queryLower) || skill.problem.toLowerCase().includes(queryLower) || skill.tags.some((tag) => tag.toLowerCase().includes(queryLower))
+      (skill) => skill.name.toLowerCase().includes(queryLower) || skill.description.toLowerCase().includes(queryLower) || skill.instructions.toLowerCase().includes(queryLower) || skill.tags.some((tag) => tag.toLowerCase().includes(queryLower))
     ).slice(0, limit);
     return matches.map((skill) => ({
       id: skill.id,
@@ -4255,12 +4831,7 @@ ${err.stderr || err.message}`
       name: metadata.name || skillId,
       version: metadata.version || "1.0.0",
       description: metadata.description || "",
-      problem: this.extractSection(body, "Problem") || "",
-      solution: this.extractSection(body, "Solution") || "",
-      verification: this.extractSection(body, "Verification") || "",
-      triggerConditions: this.parseTriggerConditions(metadata.triggers),
-      examples: this.parseExamples(body),
-      notes: this.extractSection(body, "Notes"),
+      instructions: body.trim(),
       author: metadata.author || "unknown",
       tags: this.parseTags(metadata.tags),
       createdAt: metadata.created ? new Date(metadata.created) : /* @__PURE__ */ new Date(),
@@ -4290,28 +4861,6 @@ ${err.stderr || err.message}`
     }
     return metadata;
   }
-  /**
-   * Extract a section from markdown body
-   */
-  extractSection(content, heading) {
-    const regex = new RegExp(`## ${heading}\\n([\\s\\S]*?)(?=\\n## |$)`, "i");
-    const match = content.match(regex);
-    return match ? match[1].trim() : void 0;
-  }
-  /**
-   * Parse trigger conditions from metadata
-   */
-  parseTriggerConditions(triggers) {
-    if (!triggers) return [];
-    try {
-      if (triggers.startsWith("[")) {
-        return JSON.parse(triggers);
-      }
-      return [{ type: "keyword", value: triggers }];
-    } catch {
-      return [];
-    }
-  }
   /**
    * Parse tags from metadata
    */
@@ -4319,12 +4868,6 @@ ${err.stderr || err.message}`
     if (!tags) return [];
     return tags.split(",").map((t) => t.trim()).filter(Boolean);
   }
-  /**
-   * Parse examples from body
-   */
-  parseExamples(body) {
-    return [];
-  }
   /**
    * Serialize a skill to SKILL.md format
    */
@@ -4345,21 +4888,8 @@ ${err.stderr || err.message}`
       "",
       skill.description,
       "",
-      "## Problem",
-      "",
-      skill.problem,
-      "",
-      "## Solution",
-      "",
-      skill.solution,
-      "",
-      "## Verification",
-      "",
-      skill.verification
+      skill.instructions
     ];
-    if (skill.notes) {
-      body.push("", "## Notes", "", skill.notes);
-    }
     return `${frontmatter}
 
 ${body.join("\n")}
@@ -4871,12 +5401,12 @@ var FederationManager = class {
     return {
       ...remote,
       id: local.id,
-      // Preserve local notes if they were modified
-      notes: local.notes !== remote.notes ? `${local.notes}
+      // Preserve local instructions if they were modified
+      instructions: local.instructions !== remote.instructions ? `${local.instructions}
 
 ---
 
-${remote.notes}` : remote.notes,
+${remote.instructions}` : remote.instructions,
       // Update upstream tracking
       upstream: {
         remote: local.upstream.remote,
@@ -5122,11 +5652,11 @@ var FilesystemStorageAdapter = class extends BaseStorageAdapter {
    */
   serializeSkill(skill) {
     const frontmatter = this.buildFrontmatter(skill);
-    const body = this.buildBody(skill);
     return `---
 ${frontmatter}---
 
-${body}`;
+${skill.instructions}
+`;
   }
   /**
    * Build YAML frontmatter
@@ -5155,59 +5685,19 @@ ${body}`;
         lines.push(`  - ${id}`);
       }
     }
-    return lines.join("\n") + "\n";
-  }
-  /**
-   * Build Markdown body (Claudeception-inspired structure)
-   */
-  buildBody(skill) {
-    const sections = [];
-    sections.push("## Problem\n");
-    sections.push(skill.problem);
-    sections.push("");
-    if (skill.triggerConditions.length > 0) {
-      sections.push("## Trigger Conditions\n");
-      for (const trigger of skill.triggerConditions) {
-        const desc = trigger.description ? ` - ${trigger.description}` : "";
-        sections.push(`- **${trigger.type}**: \`${trigger.value}\`${desc}`);
-      }
-      sections.push("");
-    }
-    sections.push("## Solution\n");
-    sections.push(skill.solution);
-    sections.push("");
-    sections.push("## Verification\n");
-    sections.push(skill.verification);
-    sections.push("");
-    if (skill.examples.length > 0) {
-      sections.push("## Examples\n");
-      for (const example of skill.examples) {
-        sections.push(`### ${example.scenario}
-`);
-        sections.push("**Before:**");
-        sections.push("```");
-        sections.push(example.before);
-        sections.push("```\n");
-        sections.push("**After:**");
-        sections.push("```");
-        sections.push(example.after);
-        sections.push("```");
-        sections.push("");
+    if (skill.related && skill.related.length > 0) {
+      lines.push(`related:`);
+      for (const id of skill.related) {
+        lines.push(`  - ${id}`);
       }
     }
-    if (skill.notes) {
-      sections.push("## Notes\n");
-      sections.push(skill.notes);
-      sections.push("");
-    }
-    return sections.join("\n");
+    return lines.join("\n") + "\n";
   }
   /**
    * Parse skill from YAML frontmatter + Markdown content
    */
   parseSkill(id, content, metadata) {
     const { frontmatter, body } = this.parseFrontmatterAndBody(content);
-    const sections = this.parseBodySections(body);
     const name = this.extractYamlField(frontmatter, "name") || id;
     const description = this.extractYamlMultiline(frontmatter, "description") || "";
     const version = this.extractYamlField(frontmatter, "version") || "1.0.0";
@@ -5217,12 +5707,8 @@ ${body}`;
     const tags = this.extractYamlList(frontmatter, "tags");
     const parentVersion = this.extractYamlField(frontmatter, "parentVersion");
     const derivedFrom = this.extractYamlList(frontmatter, "derivedFrom");
-    const problem = sections["problem"] || "";
-    const solution = sections["solution"] || "";
-    const verification = sections["verification"] || "";
-    const notes = sections["notes"];
-    const triggerConditions = this.parseTriggerConditions(sections["trigger conditions"] || "");
-    const examples = this.parseExamples(sections["examples"] || "");
+    const related = this.extractYamlList(frontmatter, "related");
+    const instructions = body.trim();
     const date = dateStr ? new Date(dateStr) : /* @__PURE__ */ new Date();
     let upstream = metadata?.upstream;
     if (upstream?.syncedAt) {
@@ -5236,12 +5722,8 @@ ${body}`;
       name,
       version,
       description,
-      problem,
-      triggerConditions,
-      solution,
-      verification,
-      examples,
-      notes,
+      instructions,
+      related: related.length > 0 ? related : void 0,
       author,
       tags,
       createdAt: date,
@@ -5269,23 +5751,6 @@ ${body}`;
     }
     return { frontmatter: "", body: content };
   }
-  /**
-   * Parse body into sections by ## headers
-   */
-  parseBodySections(body) {
-    const sections = {};
-    const parts = body.split(/^## /m);
-    for (const part of parts) {
-      if (!part.trim()) continue;
-      const lines = part.split("\n");
-      const header = lines[0]?.trim().toLowerCase();
-      const content = lines.slice(1).join("\n").trim();
-      if (header) {
-        sections[header] = content;
-      }
-    }
-    return sections;
-  }
   /**
    * Extract a single-line YAML field
    */
@@ -5313,47 +5778,6 @@ ${body}`;
     }
     return [];
   }
-  /**
-   * Parse trigger conditions from markdown
-   */
-  parseTriggerConditions(content) {
-    const conditions = [];
-    const lines = content.split("\n");
-    for (const line of lines) {
-      const match = line.match(/^-\s+\*\*(\w+)\*\*:\s*`([^`]+)`(?:\s*-\s*(.+))?/);
-      if (match) {
-        conditions.push({
-          type: match[1],
-          value: match[2],
-          description: match[3]?.trim()
-        });
-      }
-    }
-    return conditions;
-  }
-  /**
-   * Parse examples from markdown
-   */
-  parseExamples(content) {
-    const examples = [];
-    const parts = content.split(/^### /m);
-    for (const part of parts) {
-      if (!part.trim()) continue;
-      const lines = part.split("\n");
-      const scenario = lines[0]?.trim() || "Example";
-      const rest = lines.slice(1).join("\n");
-      const beforeMatch = rest.match(/\*\*Before:\*\*\n```\n?([\s\S]*?)```/);
-      const afterMatch = rest.match(/\*\*After:\*\*\n```\n?([\s\S]*?)```/);
-      if (beforeMatch || afterMatch) {
-        examples.push({
-          scenario,
-          before: beforeMatch?.[1]?.trim() || "",
-          after: afterMatch?.[1]?.trim() || ""
-        });
-      }
-    }
-    return examples;
-  }
   // ==========================================================================
   // Version Management
   // ==========================================================================
@@ -5468,9 +5892,7 @@ ${body}`;
    */
   hashContent(skill) {
     const content = JSON.stringify({
-      problem: skill.problem,
-      solution: skill.solution,
-      triggerConditions: skill.triggerConditions
+      instructions: skill.instructions
     });
     let hash = 0;
     for (let i = 0; i < content.length; i++) {
@@ -5796,30 +6218,17 @@ var LineageTracker = class {
     if (!targetSkill) throw new Error(`Target skill not found: ${targetId}`);
     if (!sourceSkill) throw new Error(`Source skill not found: ${sourceId}`);
     const fields = options.fields || [
-      "solution",
-      "triggerConditions",
-      "examples",
-      "notes"
+      "instructions"
     ];
     const strategy = options.conflictStrategy || "combine";
     const updates = {};
     for (const field of fields) {
-      if (field === "triggerConditions") {
-        updates.triggerConditions = this.mergeTriggerConditions(
-          targetSkill.triggerConditions,
-          sourceSkill.triggerConditions
-        );
-      } else if (field === "examples") {
-        updates.examples = this.mergeExamples(
-          targetSkill.examples,
-          sourceSkill.examples
-        );
-      } else if (field === "tags") {
+      if (field === "tags") {
         updates.tags = [.../* @__PURE__ */ new Set([...targetSkill.tags, ...sourceSkill.tags])];
-      } else if (field === "solution" || field === "notes") {
-        updates[field] = this.mergeText(
-          targetSkill[field] || "",
-          sourceSkill[field] || "",
+      } else if (field === "instructions") {
+        updates.instructions = this.mergeText(
+          targetSkill.instructions || "",
+          sourceSkill.instructions || "",
           strategy
         );
       }
@@ -5883,14 +6292,15 @@ var LineageTracker = class {
     const newVersion = bumpVersion(currentSkill.version, "patch");
     const rollbackReason = options?.reason || "No reason specified";
     const changelogEntry = options?.changelog || `Rollback from ${currentSkill.version} to ${toVersion}: ${rollbackReason}`;
-    const rollbackNote = `[rollback] ${currentSkill.version} \u2192 ${toVersion} (${rollbackReason})`;
-    const notes = targetSkill.notes ? `${targetSkill.notes}
-${rollbackNote}` : rollbackNote;
+    const rollbackNote = `
+
+[rollback] ${currentSkill.version} \u2192 ${toVersion} (${rollbackReason})`;
+    const instructions = targetSkill.instructions ? `${targetSkill.instructions}${rollbackNote}` : rollbackNote.trim();
     const rolledBackSkill = {
       ...targetSkill,
       version: newVersion,
       parentVersion: currentSkill.version,
-      notes,
+      instructions,
       updatedAt: /* @__PURE__ */ new Date()
     };
     await this.storage.saveSkill(rolledBackSkill);
@@ -5922,29 +6332,6 @@ ${rollbackNote}` : rollbackNote;
   // ==========================================================================
   // Private helpers
   // ==========================================================================
-  mergeTriggerConditions(target, source) {
-    const seen = new Set(target.map((t) => `${t.type}:${t.value}`));
-    const merged = [...target];
-    for (const trigger of source) {
-      const key = `${trigger.type}:${trigger.value}`;
-      if (!seen.has(key)) {
-        merged.push(trigger);
-        seen.add(key);
-      }
-    }
-    return merged;
-  }
-  mergeExamples(target, source) {
-    const seen = new Set(target.map((e) => e.scenario));
-    const merged = [...target];
-    for (const example of source) {
-      if (!seen.has(example.scenario)) {
-        merged.push(example);
-        seen.add(example.scenario);
-      }
-    }
-    return merged;
-  }
   mergeText(target, source, strategy) {
     switch (strategy) {
       case "source":
@@ -5970,10 +6357,7 @@ ${source}`;
     const textFields = [
       "name",
       "description",
-      "problem",
-      "solution",
-      "verification",
-      "notes"
+      "instructions"
     ];
     for (const field of textFields) {
       const valueA = skillA[field];
@@ -5986,18 +6370,6 @@ ${source}`;
         });
       }
     }
-    const triggersA = new Set(skillA.triggerConditions.map((t) => `${t.type}:${t.value}`));
-    const triggersB = new Set(skillB.triggerConditions.map((t) => `${t.type}:${t.value}`));
-    for (const trigger of triggersB) {
-      if (!triggersA.has(trigger)) {
-        changes.added.push({ type: "triggerCondition", value: trigger });
-      }
-    }
-    for (const trigger of triggersA) {
-      if (!triggersB.has(trigger)) {
-        changes.removed.push({ type: "triggerCondition", value: trigger });
-      }
-    }
     const tagsA = new Set(skillA.tags);
     const tagsB = new Set(skillB.tags);
     for (const tag of tagsB) {
@@ -6152,51 +6524,382 @@ var HookRegistry = class {
     };
   }
   /**
-   * Execute hooks and allow modification of data (for 'before' hooks)
+   * Execute hooks and allow modification of data (for 'before' hooks)
+   */
+  async executeWithTransform(event, context, data) {
+    const executionResult = await this.execute(event, context);
+    let transformedData = data;
+    for (const hookResult of executionResult.results) {
+      if (hookResult.result.modified !== void 0) {
+        transformedData = hookResult.result.modified;
+      }
+    }
+    return { result: executionResult, data: transformedData };
+  }
+  /**
+   * Clear all hooks
+   */
+  clear() {
+    this.hooks.clear();
+    this.eventIndex.clear();
+  }
+  /**
+   * Get statistics about registered hooks
+   */
+  stats() {
+    const hooks = Array.from(this.hooks.values());
+    const hooksByEvent = {};
+    const hooksByPriority = {
+      high: 0,
+      normal: 0,
+      low: 0
+    };
+    for (const hook of hooks) {
+      hooksByPriority[hook.priority]++;
+      for (const event of hook.events) {
+        hooksByEvent[event] = (hooksByEvent[event] || 0) + 1;
+      }
+    }
+    return {
+      totalHooks: hooks.length,
+      enabledHooks: hooks.filter((h) => h.enabled).length,
+      hooksByEvent,
+      hooksByPriority
+    };
+  }
+};
+var hookRegistry = new HookRegistry();
+
+// src/materialization/materializer.ts
+var fs10 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+var SKILLTREE_MARKER_START = "<!-- SKILLTREE_START -->";
+var SKILLTREE_MARKER_END = "<!-- SKILLTREE_END -->";
+var Materializer = class {
+  constructor(storage, basePath, config2) {
+    this.storage = storage;
+    this.basePath = basePath;
+    this.config = config2;
+    this.debounceTimer = null;
+    this.pendingRegen = false;
+    this.regenerating = false;
+    this.watcher = null;
+    this.watchDebounceTimer = null;
+  }
+  get mode() {
+    return this.config.mode ?? "symlink";
+  }
+  get skillsSourceDir() {
+    return path10.join(this.basePath, ".skilltree", "skills");
+  }
+  /**
+   * Initial materialization: create all symlinks/copies + generate AGENTS.md
+   */
+  async initialize() {
+    if (!this.config.enabled) return;
+    for (const targetPath of this.config.symlinkPaths ?? []) {
+      const resolved = this.resolvePath(targetPath);
+      fs10.mkdirSync(resolved, { recursive: true });
+    }
+    const skills = await this.storage.listSkills();
+    for (const skill of skills) {
+      await this.ensureMaterialized(skill.id);
+    }
+    await this.cleanup();
+    if (this.config.agentsMdPath) {
+      await this.regenerateAgentsMd();
+    }
+  }
+  /**
+   * Called when a skill is created or updated
+   */
+  async onSkillChanged(skillId) {
+    if (!this.config.enabled) return;
+    await this.ensureMaterialized(skillId);
+    this.scheduleAgentsMdRegen();
+  }
+  /**
+   * Called when a skill is deleted
+   */
+  async onSkillDeleted(skillId) {
+    if (!this.config.enabled) return;
+    await this.removeMaterialized(skillId);
+    this.scheduleAgentsMdRegen();
+  }
+  // ===========================================================================
+  // Symlink / Copy operations
+  // ===========================================================================
+  /**
+   * Materialize a skill to all configured paths (symlink or copy)
+   */
+  async ensureMaterialized(skillId) {
+    const sourcePath = path10.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);
+      if (this.mode === "copy") {
+        this.copyDir(sourcePath, targetPath);
+      } else {
+        this.ensureSymlink(sourcePath, targetPath);
+      }
+    }
+  }
+  /**
+   * Remove a materialized skill from all configured paths
+   */
+  async removeMaterialized(skillId) {
+    const sourcePath = path10.resolve(path10.join(this.skillsSourceDir, skillId));
+    for (const targetBase of this.config.symlinkPaths ?? []) {
+      const targetPath = path10.join(this.resolvePath(targetBase), skillId);
+      if (!fs10.existsSync(targetPath)) continue;
+      if (this.mode === "copy") {
+        const markerPath = path10.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) {
+            fs10.unlinkSync(targetPath);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * Create or verify a symlink
+   */
+  ensureSymlink(sourcePath, targetPath) {
+    if (fs10.existsSync(targetPath)) {
+      try {
+        const existing = fs10.readlinkSync(targetPath);
+        if (path10.resolve(existing) === path10.resolve(sourcePath)) return;
+        fs10.unlinkSync(targetPath);
+      } catch {
+        return;
+      }
+    }
+    try {
+      fs10.symlinkSync(sourcePath, targetPath, "dir");
+    } catch (err) {
+      if (err.code === "EPERM") {
+        try {
+          fs10.symlinkSync(sourcePath, targetPath, "junction");
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * Copy a skill directory, adding a marker file so we know we manage it
+   */
+  copyDir(sourcePath, targetPath) {
+    if (fs10.existsSync(targetPath)) {
+      const markerPath = path10.join(targetPath, ".skilltree-managed");
+      if (fs10.existsSync(markerPath)) {
+        fs10.rmSync(targetPath, { recursive: true, force: true });
+      } else {
+        return;
+      }
+    }
+    fs10.cpSync(sourcePath, targetPath, { recursive: true });
+    fs10.writeFileSync(
+      path10.join(targetPath, ".skilltree-managed"),
+      JSON.stringify({ source: sourcePath, copiedAt: (/* @__PURE__ */ new Date()).toISOString() })
+    );
+  }
+  // ===========================================================================
+  // AGENTS.md generation
+  // ===========================================================================
+  /**
+   * Schedule debounced AGENTS.md regeneration
+   */
+  scheduleAgentsMdRegen() {
+    if (!this.config.agentsMdPath) return;
+    this.pendingRegen = true;
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    const debounceMs = this.config.debounceMs ?? 500;
+    this.debounceTimer = setTimeout(async () => {
+      this.debounceTimer = null;
+      if (this.pendingRegen) {
+        this.pendingRegen = false;
+        await this.regenerateAgentsMd();
+      }
+    }, debounceMs);
+  }
+  /**
+   * Regenerate AGENTS.md with marker-based section replacement
+   */
+  async regenerateAgentsMd() {
+    const agentsMdPath = this.config.agentsMdPath;
+    if (!agentsMdPath) return;
+    if (this.regenerating) {
+      this.pendingRegen = true;
+      return;
+    }
+    this.regenerating = true;
+    try {
+      await this._doRegenerateAgentsMd(agentsMdPath);
+    } finally {
+      this.regenerating = false;
+      if (this.pendingRegen) {
+        this.pendingRegen = false;
+        await this.regenerateAgentsMd();
+      }
+    }
+  }
+  async _doRegenerateAgentsMd(agentsMdPath) {
+    const resolvedPath = this.resolvePath(agentsMdPath);
+    const generatorConfig = {
+      format: this.config.agentsMdFormat ?? "xml"
+    };
+    const { generateAgentsMd: generateAgentsMd2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+    const skillContent = await generateAgentsMd2(this.storage, generatorConfig);
+    const markedContent = `${SKILLTREE_MARKER_START}
+${skillContent}
+${SKILLTREE_MARKER_END}`;
+    if (fs10.existsSync(resolvedPath)) {
+      const existing = fs10.readFileSync(resolvedPath, "utf-8");
+      const startIdx = existing.indexOf(SKILLTREE_MARKER_START);
+      const endIdx = existing.indexOf(SKILLTREE_MARKER_END);
+      if (startIdx !== -1 && endIdx !== -1) {
+        const before = existing.slice(0, startIdx);
+        const after = existing.slice(endIdx + SKILLTREE_MARKER_END.length);
+        fs10.writeFileSync(resolvedPath, before + markedContent + after);
+        return;
+      }
+      fs10.writeFileSync(resolvedPath, existing + "\n\n" + markedContent + "\n");
+      return;
+    }
+    const dir = path10.dirname(resolvedPath);
+    if (!fs10.existsSync(dir)) {
+      fs10.mkdirSync(dir, { recursive: true });
+    }
+    fs10.writeFileSync(resolvedPath, markedContent + "\n");
+  }
+  // ===========================================================================
+  // Cleanup
+  // ===========================================================================
+  /**
+   * Remove stale entries (symlinks or copies) that point to non-existent skills
    */
-  async executeWithTransform(event, context, data) {
-    const executionResult = await this.execute(event, context);
-    let transformedData = data;
-    for (const hookResult of executionResult.results) {
-      if (hookResult.result.modified !== void 0) {
-        transformedData = hookResult.result.modified;
+  async cleanup() {
+    const skills = await this.storage.listSkills();
+    const skillIds = new Set(skills.map((s) => s.id));
+    for (const targetBase of this.config.symlinkPaths ?? []) {
+      const resolved = this.resolvePath(targetBase);
+      if (!fs10.existsSync(resolved)) continue;
+      const entries = fs10.readdirSync(resolved);
+      for (const entry of entries) {
+        const entryPath = path10.join(resolved, entry);
+        if (skillIds.has(entry)) continue;
+        if (this.mode === "copy") {
+          const markerPath = path10.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) {
+              fs10.unlinkSync(entryPath);
+            }
+          } catch {
+          }
+        }
       }
     }
-    return { result: executionResult, data: transformedData };
   }
+  // ===========================================================================
+  // File watcher
+  // ===========================================================================
   /**
-   * Clear all hooks
+   * Start watching .skilltree/skills/ for external changes.
+   * Re-materializes when files are added/changed/removed outside the SkillBank API.
+   */
+  watch() {
+    if (this.watcher) return;
+    if (!this.config.enabled) return;
+    const watchDir = this.skillsSourceDir;
+    if (!fs10.existsSync(watchDir)) return;
+    this.watcher = fs10.watch(watchDir, { recursive: true }, (_eventType, filename) => {
+      if (!filename) return;
+      if (this.watchDebounceTimer) {
+        clearTimeout(this.watchDebounceTimer);
+      }
+      this.watchDebounceTimer = setTimeout(async () => {
+        this.watchDebounceTimer = null;
+        try {
+          const skills = await this.storage.listSkills();
+          for (const skill of skills) {
+            await this.ensureMaterialized(skill.id);
+          }
+          await this.cleanup();
+          if (this.config.agentsMdPath) {
+            await this.regenerateAgentsMd();
+          }
+        } catch {
+        }
+      }, this.config.debounceMs ?? 500);
+    });
+  }
+  /**
+   * Stop watching for file changes
    */
-  clear() {
-    this.hooks.clear();
-    this.eventIndex.clear();
+  unwatch() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.watchDebounceTimer) {
+      clearTimeout(this.watchDebounceTimer);
+      this.watchDebounceTimer = null;
+    }
   }
+  // ===========================================================================
+  // Lifecycle
+  // ===========================================================================
   /**
-   * Get statistics about registered hooks
+   * Flush any pending debounced operations (useful for testing)
    */
-  stats() {
-    const hooks = Array.from(this.hooks.values());
-    const hooksByEvent = {};
-    const hooksByPriority = {
-      high: 0,
-      normal: 0,
-      low: 0
-    };
-    for (const hook of hooks) {
-      hooksByPriority[hook.priority]++;
-      for (const event of hook.events) {
-        hooksByEvent[event] = (hooksByEvent[event] || 0) + 1;
-      }
+  async flush() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
     }
-    return {
-      totalHooks: hooks.length,
-      enabledHooks: hooks.filter((h) => h.enabled).length,
-      hooksByEvent,
-      hooksByPriority
-    };
+    if (this.pendingRegen) {
+      this.pendingRegen = false;
+      await this.regenerateAgentsMd();
+    }
+  }
+  /**
+   * Tear down: cancel pending timers and stop watcher
+   */
+  shutdown() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    this.pendingRegen = false;
+    this.unwatch();
+  }
+  /**
+   * Resolve a path relative to basePath, handling ~ expansion
+   */
+  resolvePath(p) {
+    if (p.startsWith("~")) {
+      return path10.join(process.env.HOME || process.env.USERPROFILE || "", p.slice(1));
+    }
+    if (path10.isAbsolute(p)) return p;
+    return path10.resolve(this.basePath, p);
   }
 };
-var hookRegistry = new HookRegistry();
 
 // src/skill-bank.ts
 var SkillBank = class {
@@ -6239,6 +6942,13 @@ var SkillBank = class {
       });
       this.syncPullOnInit = config2.sync.pullOnInit ?? false;
     }
+    if (config2.materialization?.enabled && this.basePath) {
+      this.materializer = new Materializer(
+        this.storage,
+        this.basePath,
+        config2.materialization
+      );
+    }
   }
   /**
    * Initialize the skill bank (required before use)
@@ -6258,6 +6968,9 @@ var SkillBank = class {
         await this.syncManager.pull();
       }
     }
+    if (this.materializer) {
+      await this.materializer.initialize();
+    }
     this.initialized = true;
   }
   /**
@@ -6267,6 +6980,9 @@ var SkillBank = class {
     if (this.syncManager) {
       await this.syncManager.shutdown();
     }
+    if (this.materializer) {
+      this.materializer.shutdown();
+    }
   }
   /**
    * Ensure initialized before operations
@@ -6479,6 +7195,18 @@ var SkillBank = class {
         console.error("Hook execution error:", err);
       });
     }
+    if (this.materializer) {
+      const materialize = async () => {
+        if (event.type === "skill:created" || event.type === "skill:updated") {
+          await this.materializer.onSkillChanged(event.skill.id);
+        } else if (event.type === "skill:deleted") {
+          await this.materializer.onSkillDeleted(event.skillId);
+        }
+      };
+      materialize().catch((err) => {
+        console.error("Materialization error:", err);
+      });
+    }
   }
   /**
    * Map SkillTreeEvent type to HookEvent type
@@ -6734,6 +7462,12 @@ var SkillBank = class {
 init_base();
 init_sqlite();
 
+// src/agents/index.ts
+init_types();
+init_generator();
+init_parser();
+init_sync();
+
 // src/sync/index.ts
 function createDefaultSyncConfig(remoteUrl, agentId, options) {
   return {
@@ -6756,9 +7490,7 @@ function createDefaultSyncConfig(remoteUrl, agentId, options) {
     conflicts: {
       defaultStrategy: "prefer-newer",
       fieldStrategies: {
-        tags: "union",
-        examples: "union",
-        triggerConditions: "union"
+        tags: "union"
       }
     }
   };
@@ -6790,12 +7522,20 @@ var DEFAULT_CONFIG5 = {
     output_format: "table",
     color: true,
     quiet: false
+  },
+  materialization: {
+    enabled: false,
+    mode: "symlink",
+    symlink_paths: [],
+    agents_md_path: "",
+    agents_md_format: "xml",
+    debounce_ms: 500
   }
 };
 
 // src/config/loader.ts
-var fs9 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 var os = __toESM(require("os"));
 var ENV_MAPPINGS = {
   GITHUB_TOKEN: "indexer.github_token",
@@ -6806,17 +7546,17 @@ var ENV_MAPPINGS = {
   SKILL_TREE_NO_COLOR: "cli.color"
 };
 function getConfigDir() {
-  return path9.join(os.homedir(), ".skill-tree");
+  return path11.join(os.homedir(), ".skill-tree");
 }
 function getConfigPath() {
-  return path9.join(getConfigDir(), "config.yaml");
+  return path11.join(getConfigDir(), "config.yaml");
 }
 function expandPath(filePath) {
   if (filePath.startsWith("~/")) {
-    return path9.join(os.homedir(), filePath.slice(2));
+    return path11.join(os.homedir(), filePath.slice(2));
   }
   if (filePath.startsWith("~")) {
-    return path9.join(os.homedir(), filePath.slice(1));
+    return path11.join(os.homedir(), filePath.slice(1));
   }
   return filePath;
 }
@@ -6845,8 +7585,8 @@ function substituteEnvVarsInObject(obj) {
   }
   return obj;
 }
-function setNestedProperty(obj, path15, value) {
-  const parts = path15.split(".");
+function setNestedProperty(obj, path18, value) {
+  const parts = path18.split(".");
   let current = obj;
   for (let i = 0; i < parts.length - 1; i++) {
     const part = parts[i];
@@ -6929,11 +7669,11 @@ function parseSimpleYaml(content) {
 }
 function loadConfigFromFile(configPath) {
   const expandedPath = expandPath(configPath);
-  if (!fs9.existsSync(expandedPath)) {
+  if (!fs11.existsSync(expandedPath)) {
     return null;
   }
   try {
-    const content = fs9.readFileSync(expandedPath, "utf-8");
+    const content = fs11.readFileSync(expandedPath, "utf-8");
     const parsed = parseSimpleYaml(content);
     return substituteEnvVarsInObject(parsed);
   } catch (error) {
@@ -7005,8 +7745,8 @@ var ConfigLoader = class {
   /**
    * Get a specific config value by path
    */
-  get(path15) {
-    const parts = path15.split(".");
+  get(path18) {
+    const parts = path18.split(".");
     let current = this.getConfig();
     for (const part of parts) {
       if (current === null || typeof current !== "object") {
@@ -7020,15 +7760,15 @@ var ConfigLoader = class {
    * Check if config file exists
    */
   configFileExists() {
-    return fs9.existsSync(expandPath(this.configPath));
+    return fs11.existsSync(expandPath(this.configPath));
   }
   /**
    * Create default config file
    */
   createDefaultConfigFile() {
-    const configDir = path9.dirname(expandPath(this.configPath));
-    if (!fs9.existsSync(configDir)) {
-      fs9.mkdirSync(configDir, { recursive: true });
+    const configDir = path11.dirname(expandPath(this.configPath));
+    if (!fs11.existsSync(configDir)) {
+      fs11.mkdirSync(configDir, { recursive: true });
     }
     const configContent = `# Skill Tree Configuration
 # Generated by skill-tree
@@ -7059,8 +7799,22 @@ cli:
   output_format: table
   color: true
   quiet: false
+
+materialization:
+  # Enable automatic materialization to agent-discoverable paths
+  enabled: false
+  # Mode: 'symlink' (default) or 'copy'
+  mode: symlink
+  # Directories to expose skills in (e.g. .claude/skills, .agent/skills)
+  symlink_paths: []
+  # Path to auto-generate AGENTS.md (empty = disabled)
+  agents_md_path: ""
+  # Format for AGENTS.md: xml, markdown, json
+  agents_md_format: xml
+  # Debounce interval in ms for batch updates
+  debounce_ms: 500
 `;
-    fs9.writeFileSync(expandPath(this.configPath), configContent);
+    fs11.writeFileSync(expandPath(this.configPath), configContent);
   }
 };
 var globalConfig = null;
@@ -7078,8 +7832,8 @@ function loadConfig(configPath) {
 var import_commander = require("commander");
 
 // src/cli/utils/paths.ts
-var fs10 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
 var DEFAULT_PATHS = [
   ".claude/skills",
@@ -7093,13 +7847,13 @@ var DEFAULT_PATHS = [
 ];
 function expandHome(p) {
   if (p.startsWith("~/")) {
-    return path10.join(os2.homedir(), p.slice(2));
+    return path12.join(os2.homedir(), p.slice(2));
   }
   return p;
 }
 function dirExists(p) {
   try {
-    return fs10.statSync(p).isDirectory();
+    return fs12.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -7107,27 +7861,40 @@ function dirExists(p) {
 function resolveSkillPath(explicitPath) {
   if (explicitPath) {
     const resolved = expandHome(explicitPath);
-    return path10.resolve(resolved);
+    return path12.resolve(resolved);
   }
   const envPath = process.env.SKILL_TREE_PATH;
   if (envPath) {
-    return path10.resolve(expandHome(envPath));
+    return path12.resolve(expandHome(envPath));
   }
   for (const defaultPath of DEFAULT_PATHS) {
-    const resolved = path10.resolve(expandHome(defaultPath));
+    const resolved = path12.resolve(expandHome(defaultPath));
     if (dirExists(resolved)) {
       return resolved;
     }
   }
-  return path10.resolve(".claude/skills");
+  return path12.resolve(".claude/skills");
 }
 function ensureDir(dir) {
   if (!dirExists(dir)) {
-    fs10.mkdirSync(dir, { recursive: true });
+    fs12.mkdirSync(dir, { recursive: true });
   }
 }
 
 // src/cli/utils/skillbank.ts
+function getMaterializationConfig() {
+  const config2 = loadConfig();
+  const mat = config2.materialization;
+  if (!mat?.enabled) return void 0;
+  return {
+    enabled: true,
+    mode: mat.mode ?? "symlink",
+    symlinkPaths: mat.symlink_paths?.length ? mat.symlink_paths : void 0,
+    agentsMdPath: mat.agents_md_path || void 0,
+    agentsMdFormat: mat.agents_md_format ?? "xml",
+    debounceMs: mat.debounce_ms ?? 500
+  };
+}
 async function createSkillBankFromOptions(options) {
   const skillPath = resolveSkillPath(options.path);
   ensureDir(skillPath);
@@ -7135,7 +7902,8 @@ async function createSkillBankFromOptions(options) {
     storage: {
       basePath: skillPath,
       openSkillsCompatible: true
-    }
+    },
+    materialization: getMaterializationConfig()
   });
   await skillBank.initialize();
   return skillBank;
@@ -7193,33 +7961,10 @@ function formatSkillDetail(skill) {
   lines.push(import_chalk.default.dim("\u2500".repeat(50)));
   lines.push(skill.description);
   lines.push("");
-  lines.push(import_chalk.default.dim("Problem"));
-  lines.push(import_chalk.default.dim("\u2500".repeat(50)));
-  lines.push(skill.problem);
-  lines.push("");
-  if (skill.triggerConditions.length > 0) {
-    lines.push(import_chalk.default.dim("Trigger Conditions"));
-    lines.push(import_chalk.default.dim("\u2500".repeat(50)));
-    for (const trigger of skill.triggerConditions) {
-      const desc = trigger.description ? ` - ${trigger.description}` : "";
-      lines.push(`  ${import_chalk.default.cyan(trigger.type)}: ${trigger.value}${import_chalk.default.dim(desc)}`);
-    }
-    lines.push("");
-  }
-  lines.push(import_chalk.default.dim("Solution"));
-  lines.push(import_chalk.default.dim("\u2500".repeat(50)));
-  lines.push(skill.solution);
-  lines.push("");
-  if (skill.verification) {
-    lines.push(import_chalk.default.dim("Verification"));
-    lines.push(import_chalk.default.dim("\u2500".repeat(50)));
-    lines.push(skill.verification);
-    lines.push("");
-  }
-  if (skill.notes) {
-    lines.push(import_chalk.default.dim("Notes"));
+  if (skill.instructions) {
+    lines.push(import_chalk.default.dim("Instructions"));
     lines.push(import_chalk.default.dim("\u2500".repeat(50)));
-    lines.push(skill.notes);
+    lines.push(skill.instructions);
   }
   return lines.join("\n");
 }
@@ -7588,7 +8333,7 @@ var deleteCommand = new import_commander11.Command("delete").description("Delete
 
 // src/cli/commands/export.ts
 var import_commander12 = require("commander");
-var fs11 = __toESM(require("fs"));
+var fs13 = __toESM(require("fs"));
 var exportCommand = new import_commander12.Command("export").description("Export all skills to JSON").option("-o, --output <file>", "Output file path (defaults to stdout)").action(async (options, command) => {
   const globalOpts = command.optsWithGlobals();
   try {
@@ -7596,7 +8341,7 @@ var exportCommand = new import_commander12.Command("export").description("Export
     const skills = await skillBank.exportAll();
     const json = JSON.stringify(skills, null, 2);
     if (options.output) {
-      fs11.writeFileSync(options.output, json, "utf-8");
+      fs13.writeFileSync(options.output, json, "utf-8");
       if (!globalOpts.quiet) {
         printSuccess(`Exported ${skills.length} skill(s) to ${options.output}`);
       }
@@ -7611,228 +8356,16 @@ var exportCommand = new import_commander12.Command("export").description("Export
 
 // src/cli/commands/import.ts
 var import_commander13 = require("commander");
-var fs12 = __toESM(require("fs"));
+var fs14 = __toESM(require("fs"));
 
 // src/import/converter.ts
-var DEFAULT_SECTION_PATTERNS = {
-  problem: [
-    /^#+\s*(?:problem|issue|what\s+problem|the\s+problem)/i,
-    /^#+\s*(?:why|motivation|background)/i
-  ],
-  solution: [
-    /^#+\s*(?:solution|how\s+to|implementation|approach)/i,
-    /^#+\s*(?:usage|instructions|steps)/i
-  ],
-  verification: [
-    /^#+\s*(?:verification|verify|testing|test|validate)/i,
-    /^#+\s*(?:how\s+to\s+verify|checking)/i
-  ],
-  examples: [
-    /^#+\s*(?:examples?|sample|demo)/i,
-    /^#+\s*(?:use\s+cases?|scenarios?)/i
-  ],
-  notes: [
-    /^#+\s*(?:notes?|caveats?|warnings?|tips?)/i,
-    /^#+\s*(?:additional|edge\s+cases?|considerations?)/i
-  ],
-  triggers: [
-    /^#+\s*(?:triggers?|when\s+to\s+use|conditions?)/i,
-    /^#+\s*(?:activation|applies\s+when)/i
-  ]
-};
-function parseMarkdownSections(content) {
-  const lines = content.split("\n");
-  const sections = {
-    remainingContent: ""
-  };
-  let currentSection = "remaining";
-  let currentContent = [];
-  const flushSection = () => {
-    const text = currentContent.join("\n").trim();
-    if (!text) return;
-    switch (currentSection) {
-      case "problem":
-        sections.problem = text;
-        break;
-      case "solution":
-        sections.solution = text;
-        break;
-      case "verification":
-        sections.verification = text;
-        break;
-      case "examples":
-        sections.examples = parseExamples(text);
-        break;
-      case "notes":
-        sections.notes = text;
-        break;
-      case "triggers":
-        sections.triggers = parseTriggerList(text);
-        break;
-      case "remaining":
-        sections.remainingContent += (sections.remainingContent ? "\n\n" : "") + text;
-        break;
-    }
-    currentContent = [];
-  };
-  for (const line of lines) {
-    let matchedSection = null;
-    for (const [section, sectionPatterns] of Object.entries(DEFAULT_SECTION_PATTERNS)) {
-      for (const pattern of sectionPatterns) {
-        if (pattern.test(line)) {
-          matchedSection = section;
-          break;
-        }
-      }
-      if (matchedSection) break;
-    }
-    if (matchedSection) {
-      flushSection();
-      currentSection = matchedSection;
-    } else {
-      currentContent.push(line);
-    }
-  }
-  flushSection();
-  return sections;
-}
-function parseExamples(text) {
-  const examples = [];
-  const exampleBlocks = text.split(/^###\s+/m).filter(Boolean);
-  for (const block of exampleBlocks) {
-    const lines = block.split("\n");
-    const scenario = lines[0]?.trim() || "Example";
-    const content = lines.slice(1).join("\n");
-    const beforeMatch = content.match(/(?:before|input|given)[:\s]*\n?([\s\S]*?)(?=(?:after|output|then|result)|$)/i);
-    const afterMatch = content.match(/(?:after|output|then|result)[:\s]*\n?([\s\S]*?)$/i);
-    if (beforeMatch || afterMatch) {
-      examples.push({
-        scenario,
-        before: beforeMatch?.[1]?.trim() || "",
-        after: afterMatch?.[1]?.trim() || content.trim()
-      });
-    } else {
-      examples.push({
-        scenario,
-        before: "",
-        after: content.trim()
-      });
-    }
-  }
-  if (examples.length === 0 && text.trim()) {
-    examples.push({
-      scenario: "Example usage",
-      before: "",
-      after: text.trim()
-    });
-  }
-  return examples;
-}
-function parseTriggerList(text) {
-  const triggers = [];
-  const listItems = text.match(/^[\s]*[-*•]\s*(.+)$/gm) || text.match(/^[\s]*\d+\.\s*(.+)$/gm);
-  if (listItems) {
-    for (const item of listItems) {
-      const cleaned = item.replace(/^[\s]*[-*•\d.]+\s*/, "").trim();
-      if (cleaned) triggers.push(cleaned);
-    }
-  } else {
-    triggers.push(...text.split("\n").map((t) => t.trim()).filter(Boolean));
-  }
-  return triggers;
-}
-function inferTriggerType(text) {
-  const lower = text.toLowerCase();
-  if (lower.includes("error") || lower.includes("exception") || lower.includes("fail")) {
-    return { type: "error", value: text, description: "Triggered by error conditions" };
-  }
-  if (lower.includes("pattern") || lower.includes("regex") || lower.includes("match")) {
-    return { type: "pattern", value: text };
-  }
-  if (lower.includes("when") || lower.includes("context") || lower.includes("if ")) {
-    return { type: "context", value: text };
-  }
-  return { type: "keyword", value: text };
-}
-function extractKeywordsFromDescription(description) {
-  const keywords = [];
-  const techPatterns = [
-    /\b(react|vue|angular|svelte|next\.?js|nuxt)\b/gi,
-    /\b(node\.?js|deno|bun|python|rust|go|java|typescript|javascript)\b/gi,
-    /\b(docker|kubernetes|k8s|aws|gcp|azure)\b/gi,
-    /\b(git|github|gitlab|npm|yarn|pnpm)\b/gi,
-    /\b(sql|postgres|mysql|mongodb|redis)\b/gi,
-    /\b(api|rest|graphql|grpc)\b/gi,
-    /\b(test|testing|jest|vitest|pytest)\b/gi
-  ];
-  for (const pattern of techPatterns) {
-    const matches = description.match(pattern);
-    if (matches) {
-      keywords.push(...matches.map((m) => m.toLowerCase()));
-    }
-  }
-  return [...new Set(keywords)];
-}
-function extractTriggerConditions(skill, sections) {
-  const conditions = [];
-  if (sections?.triggers) {
-    for (const trigger of sections.triggers) {
-      conditions.push(inferTriggerType(trigger));
-    }
-  }
-  const keywords = extractKeywordsFromDescription(skill.description);
-  for (const keyword of keywords) {
-    if (!conditions.some((c) => c.value.toLowerCase() === keyword.toLowerCase())) {
-      conditions.push({
-        type: "keyword",
-        value: keyword,
-        description: "Keyword from description"
-      });
-    }
-  }
-  if (skill.tags) {
-    for (const tag of skill.tags.slice(0, 5)) {
-      if (!conditions.some((c) => c.value.toLowerCase() === tag.toLowerCase())) {
-        conditions.push({
-          type: "keyword",
-          value: tag,
-          description: "Tag from classification"
-        });
-      }
-    }
-  }
-  if (conditions.length === 0) {
-    conditions.push({
-      type: "context",
-      value: skill.description.substring(0, 100),
-      description: "Generated from skill description"
-    });
-  }
-  return conditions;
-}
 function convertIndexerSkill(indexerSkill) {
   const warnings = [];
-  const sections = parseMarkdownSections(indexerSkill.content);
-  const hasStructuredContent = !!(sections.problem || sections.solution || sections.verification || sections.examples?.length);
+  const instructions = indexerSkill.content || "";
+  const hasStructuredContent = instructions.trim().length > 0;
   if (!hasStructuredContent) {
-    warnings.push("No structured content sections found, using raw content");
-  }
-  const triggerConditions = extractTriggerConditions(indexerSkill, sections);
-  let examples = sections.examples || [];
-  if (examples.length === 0) {
-    examples = [{
-      scenario: "Usage example",
-      before: "",
-      after: indexerSkill.content.substring(0, 500)
-    }];
-    warnings.push("No examples found, created placeholder");
-  }
-  const problem = sections.problem || indexerSkill.description;
-  const solution = sections.solution || indexerSkill.content;
-  const verification = sections.verification || "Verify the skill output meets expectations";
-  if (!sections.problem) warnings.push("No problem section found, using description");
-  if (!sections.solution) warnings.push("No solution section found, using full content");
-  if (!sections.verification) warnings.push("No verification section found, using default");
+    warnings.push("No content found, instructions will be empty");
+  }
   const tags = [...indexerSkill.tags || []];
   if (indexerSkill.sourceRepo) {
     const repoName = indexerSkill.sourceRepo.split("/").pop();
@@ -7841,26 +8374,12 @@ function convertIndexerSkill(indexerSkill) {
     }
   }
   const status = indexerSkill.status === "indexed" ? "active" : indexerSkill.status === "raw" ? "draft" : "draft";
-  let notes = sections.notes || void 0;
-  if (indexerSkill.classificationReasoning) {
-    const classificationNote = `
-
----
-Classification: ${indexerSkill.primaryPath?.join(" > ") || "uncategorized"}
-Reasoning: ${indexerSkill.classificationReasoning}`;
-    notes = (notes || "") + classificationNote;
-  }
   const skill = {
     id: indexerSkill.slug,
     name: indexerSkill.displayName || indexerSkill.name,
     version: indexerSkill.version,
     description: indexerSkill.description,
-    problem,
-    triggerConditions,
-    solution,
-    verification,
-    examples,
-    notes,
+    instructions,
     author: indexerSkill.author,
     tags,
     createdAt: new Date(indexerSkill.scrapedAt),
@@ -7931,7 +8450,7 @@ function parseIndexerExport(content) {
 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.problem === "string" && typeof skill.solution === "string" && Array.isArray(skill.triggerConditions) && typeof skill.metrics === "object";
+  return typeof skill.id === "string" && typeof skill.name === "string" && typeof skill.version === "string" && typeof skill.instructions === "string" && typeof skill.metrics === "object";
 }
 function isIndexerSkill(obj) {
   if (typeof obj !== "object" || obj === null) return false;
@@ -7987,11 +8506,11 @@ function isLikelyIndexerFormat(content) {
 var importCommand = new import_commander13.Command("import").description("Import skills from JSON file").argument("<file>", "JSON file to import").option("--from-indexer", "Import from skill-indexer export format").option("--auto-detect", "Auto-detect format (default: true)", true).action(async (file, options, command) => {
   const globalOpts = command.optsWithGlobals();
   try {
-    if (!fs12.existsSync(file)) {
+    if (!fs14.existsSync(file)) {
       printError(`File not found: ${file}`);
       process.exit(1);
     }
-    const content = fs12.readFileSync(file, "utf-8");
+    const content = fs14.readFileSync(file, "utf-8");
     let skills;
     const isIndexerFormat = options.fromIndexer || options.autoDetect !== false && isLikelyIndexerFormat(content);
     if (isIndexerFormat) {
@@ -8060,8 +8579,8 @@ var import_commander14 = require("commander");
 var import_child_process2 = require("child_process");
 
 // src/services/indexer.ts
-var path11 = __toESM(require("path"));
-var fs13 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
 function hasIndexerSupport(storage) {
   const s = storage;
   return typeof s.addRelationship === "function" && typeof s.getTaxonomyTree === "function";
@@ -8097,16 +8616,16 @@ var IndexerService = class {
     try {
       const possiblePaths = [
         // Relative to this file in dist
-        path11.resolve(__dirname, "../../scraper/dist"),
+        path13.resolve(__dirname, "../../scraper/dist"),
         // Relative to project root
-        path11.resolve(process.cwd(), "scraper/dist"),
+        path13.resolve(process.cwd(), "scraper/dist"),
         // Absolute paths from config
-        this.serviceConfig.cacheDir ? path11.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 = path11.join(basePath, "scraper/index.js");
-        if (fs13.existsSync(scraperIndex)) {
+        const scraperIndex = path13.join(basePath, "scraper/index.js");
+        if (fs15.existsSync(scraperIndex)) {
           scraperBasePath = basePath;
           break;
         }
@@ -8114,9 +8633,9 @@ var IndexerService = class {
       if (!scraperBasePath) {
         throw new Error("Scraper modules not found. Run `cd scraper && npm run build` first.");
       }
-      const scraperPath = path11.join(scraperBasePath, "scraper/index.js");
-      const indexerPath = path11.join(scraperBasePath, "indexer/index.js");
-      const databasePath = path11.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
@@ -8130,7 +8649,7 @@ var IndexerService = class {
         databasePath
       );
       if (this.databaseModule.createDatabase) {
-        const dbPath = this.serviceConfig.databasePath || path11.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;
@@ -8345,7 +8864,7 @@ var IndexerService = class {
   detectSkillRelationships(skill, allSkills) {
     const relationships = [];
     const skillId = skill.id || skill.slug;
-    const skillContent = `${skill.name} ${skill.description} ${skill.problem || ""} ${skill.solution || ""} ${skill.content || ""}`.toLowerCase();
+    const skillContent = `${skill.name} ${skill.description} ${skill.instructions || ""} ${skill.content || ""}`.toLowerCase();
     for (const other of allSkills) {
       const otherId = other.id || other.slug;
       if (otherId === skillId) continue;
@@ -8832,7 +9351,7 @@ async function runStandaloneMode(url, options, globalOpts) {
   }
 }
 async function runSkillIndexer(args, quiet) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const proc = (0, import_child_process2.spawn)("skillindexer", args, {
       stdio: quiet ? "pipe" : "inherit",
       shell: true
@@ -8842,7 +9361,7 @@ async function runSkillIndexer(args, quiet) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve3();
+        resolve4();
       } else {
         reject(new Error(`skillindexer exited with code ${code}`));
       }
@@ -8926,7 +9445,7 @@ async function runStandaloneMode2(options, globalOpts) {
   }
 }
 async function runSkillIndexer2(args, quiet) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const proc = (0, import_child_process3.spawn)("skillindexer", args, {
       stdio: quiet ? "pipe" : "inherit",
       shell: true
@@ -8936,7 +9455,7 @@ async function runSkillIndexer2(args, quiet) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve3();
+        resolve4();
       } else {
         reject(new Error(`skillindexer exited with code ${code}`));
       }
@@ -9006,7 +9525,7 @@ async function runStandaloneMode3(pathArg, options, globalOpts) {
   }
 }
 async function runSkillIndexer3(args, quiet) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const proc = (0, import_child_process4.spawn)("skillindexer", args, {
       stdio: quiet ? "pipe" : "inherit",
       shell: true
@@ -9016,7 +9535,7 @@ async function runSkillIndexer3(args, quiet) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve3();
+        resolve4();
       } else {
         reject(new Error(`skillindexer exited with code ${code}`));
       }
@@ -9092,7 +9611,7 @@ async function runStandaloneMode4(options, globalOpts) {
   }
 }
 async function runSkillIndexer4(args, quiet) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const proc = (0, import_child_process5.spawn)("skillindexer", args, {
       stdio: quiet ? "pipe" : "inherit",
       shell: true
@@ -9102,7 +9621,7 @@ async function runSkillIndexer4(args, quiet) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve3();
+        resolve4();
       } else {
         reject(new Error(`skillindexer exited with code ${code}`));
       }
@@ -9171,7 +9690,7 @@ async function runStandaloneMode5(globalOpts) {
   }
 }
 async function runSkillIndexer5(args, quiet) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const proc = (0, import_child_process6.spawn)("skillindexer", args, {
       stdio: quiet ? "pipe" : "inherit",
       shell: true
@@ -9181,7 +9700,7 @@ async function runSkillIndexer5(args, quiet) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve3();
+        resolve4();
       } else {
         reject(new Error(`skillindexer exited with code ${code}`));
       }
@@ -9191,8 +9710,8 @@ async function runSkillIndexer5(args, quiet) {
 
 // src/cli/commands/indexer/sync.ts
 var import_commander19 = require("commander");
-var fs14 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
 var import_child_process7 = require("child_process");
 
@@ -9653,11 +10172,11 @@ async function runLegacyImport(options, globalOpts) {
     if (!globalOpts.quiet) {
       printInfo("Exporting skills from indexer...");
     }
-    exportPath = path12.join(os3.tmpdir(), `skill-tree-sync-${Date.now()}.json`);
+    exportPath = path14.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);
-    if (!fs14.existsSync(exportPath)) {
+    if (!fs16.existsSync(exportPath)) {
       printError("Failed to export skills from indexer");
       process.exit(1);
     }
@@ -9665,7 +10184,7 @@ async function runLegacyImport(options, globalOpts) {
   if (!globalOpts.quiet) {
     printInfo(`Reading export from ${exportPath}...`);
   }
-  const content = fs14.readFileSync(exportPath, "utf-8");
+  const content = fs16.readFileSync(exportPath, "utf-8");
   const { skills, stats } = parseIndexerExport(content);
   if (!globalOpts.quiet) {
     printInfo(`Found ${stats.total} skills (${stats.withStructuredContent} with structured content)`);
@@ -9685,7 +10204,7 @@ async function runLegacyImport(options, globalOpts) {
   const result = await skillBank.importSkills(skills);
   if (!options.exportPath && exportPath) {
     try {
-      fs14.unlinkSync(exportPath);
+      fs16.unlinkSync(exportPath);
     } catch {
     }
   }
@@ -9699,7 +10218,7 @@ async function runLegacyImport(options, globalOpts) {
   }
 }
 async function runSkillIndexer6(args, quiet) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const proc = (0, import_child_process7.spawn)("skillindexer", args, {
       stdio: quiet ? "pipe" : "inherit",
       shell: true
@@ -9709,7 +10228,7 @@ async function runSkillIndexer6(args, quiet) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve3();
+        resolve4();
       } else {
         reject(new Error(`skillindexer exited with code ${code}`));
       }
@@ -9722,7 +10241,7 @@ var indexerCommand = new import_commander20.Command("index").description("Skill
 
 // src/cli/commands/config.ts
 var import_commander21 = require("commander");
-var fs15 = __toESM(require("fs"));
+var fs17 = __toESM(require("fs"));
 var configCommand = new import_commander21.Command("config").description("View and manage configuration");
 configCommand.command("show").description("Show current configuration").option("--path <path>", "Path to specific config value (e.g., storage.path)").action((options) => {
   const globalOpts = configCommand.parent?.opts() || {};
@@ -9755,7 +10274,7 @@ configCommand.command("show").description("Show current configuration").option("
 configCommand.command("init").description("Create default configuration file").option("-f, --force", "Overwrite existing config file").action((options) => {
   const globalOpts = configCommand.parent?.opts() || {};
   const configPath = expandPath(globalOpts.config || getConfigPath());
-  if (fs15.existsSync(configPath) && !options.force) {
+  if (fs17.existsSync(configPath) && !options.force) {
     console.error(`Config file already exists: ${configPath}`);
     console.error("Use --force to overwrite");
     process.exit(1);
@@ -9774,7 +10293,7 @@ configCommand.command("path").description("Show configuration file path").action
 configCommand.command("edit").description("Open configuration file in editor").action(() => {
   const globalOpts = configCommand.parent?.opts() || {};
   const configPath = expandPath(globalOpts.config || getConfigPath());
-  if (!fs15.existsSync(configPath)) {
+  if (!fs17.existsSync(configPath)) {
     const loader = new ConfigLoader(configPath);
     loader.createDefaultConfigFile();
   }
@@ -9805,7 +10324,7 @@ configCommand.command("defaults").description("Show default configuration values
 configCommand.command("validate").description("Validate configuration file").action(() => {
   const globalOpts = configCommand.parent?.opts() || {};
   const configPath = expandPath(globalOpts.config || getConfigPath());
-  if (!fs15.existsSync(configPath)) {
+  if (!fs17.existsSync(configPath)) {
     console.error(`Config file not found: ${configPath}`);
     process.exit(1);
   }
@@ -9872,15 +10391,15 @@ function printConfig(obj, indent) {
 
 // src/cli/commands/sync.ts
 var import_commander22 = require("commander");
-var path13 = __toESM(require("path"));
-var fs16 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
 function getSyncConfigPath(basePath) {
-  return path13.join(basePath, ".skillbank", "sync-config.json");
+  return path15.join(basePath, ".skillbank", "sync-config.json");
 }
 async function loadSyncConfig(basePath) {
   const configPath = getSyncConfigPath(basePath);
   try {
-    const content = await fs16.promises.readFile(configPath, "utf-8");
+    const content = await fs18.promises.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -9888,8 +10407,8 @@ async function loadSyncConfig(basePath) {
 }
 async function saveSyncConfig(basePath, config2) {
   const configPath = getSyncConfigPath(basePath);
-  await fs16.promises.mkdir(path13.dirname(configPath), { recursive: true });
-  await fs16.promises.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  await fs18.promises.mkdir(path15.dirname(configPath), { recursive: true });
+  await fs18.promises.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
 }
 async function createSyncAdapter(basePath, globalOpts) {
   const config2 = await loadSyncConfig(basePath);
@@ -9919,8 +10438,8 @@ function initCommand() {
         agentName: options.name,
         environment: options.env
       });
-      const gitDir = path13.join(basePath, ".git");
-      if (!fs16.existsSync(gitDir)) {
+      const gitDir = path15.join(basePath, ".git");
+      if (!fs18.existsSync(gitDir)) {
         printError(`Not a git repository: ${basePath}`);
         printInfo("Initialize a git repository first with: git init");
         process.exit(1);
@@ -10194,20 +10713,144 @@ function resolveCommand() {
   });
 }
 
+// src/cli/commands/read.ts
+var import_commander23 = require("commander");
+var path16 = __toESM(require("path"));
+function serializeSkillMd(skill) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`name: ${skill.name}`);
+  lines.push(`description: |`);
+  lines.push(`  ${skill.description}`);
+  lines.push(`version: ${skill.version}`);
+  if (skill.tags.length > 0) {
+    lines.push(`tags:`);
+    for (const tag of skill.tags) {
+      lines.push(`  - ${tag}`);
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(skill.instructions);
+  return lines.join("\n");
+}
+async function resolveSkill(bank, query) {
+  const exact = await bank.getSkill(query);
+  if (exact) return { skill: exact, fuzzy: false };
+  const results = await bank.searchSkills(query);
+  if (results.length > 0) {
+    return { skill: results[0], fuzzy: true };
+  }
+  return null;
+}
+var readCommand = new import_commander23.Command("read").description("Read skill(s) to stdout (for agent activation)").argument("<names>", "Skill name(s), comma-separated").action(async (names, _options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const basePath = getSkillPath(globalOpts);
+    const nameList = names.split(",").map((n) => n.trim()).filter(Boolean);
+    for (const name of nameList) {
+      const result = await resolveSkill(skillBank, name);
+      if (!result) {
+        printError(`Skill not found: ${name}`);
+        process.exit(1);
+      }
+      const { skill, fuzzy } = result;
+      if (fuzzy) {
+        console.log(`Reading: ${skill.name} (matched: ${skill.id})`);
+      } else {
+        console.log(`Reading: ${skill.name}`);
+      }
+      const skillDir = path16.join(basePath, ".skilltree", "skills", skill.id);
+      console.log(`Base directory: ${skillDir}`);
+      console.log("");
+      console.log(serializeSkillMd(skill));
+      console.log("");
+      console.log(`Skill read: ${skill.name}`);
+      if (nameList.length > 1 && name !== nameList[nameList.length - 1]) {
+        console.log("---");
+      }
+    }
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/materialize.ts
+var import_commander24 = require("commander");
+var materializeCommand = new import_commander24.Command("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();
+  try {
+    if (!options.paths && !options.agentsMd) {
+      printError("Specify at least --paths or --agents-md");
+      console.log("");
+      printInfo("Examples:");
+      console.log("  skill-tree materialize --paths .claude/skills,.agent/skills");
+      console.log("  skill-tree materialize --agents-md ./AGENTS.md");
+      console.log("  skill-tree materialize --paths .claude/skills --agents-md ./AGENTS.md --mode copy");
+      process.exit(1);
+    }
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const storage = skillBank.getStorage();
+    const basePath = getSkillPath(globalOpts);
+    const symlinkPaths = options.paths ? options.paths.split(",").map((p) => p.trim()).filter(Boolean) : [];
+    const config2 = {
+      enabled: true,
+      mode: options.mode ?? "symlink",
+      symlinkPaths,
+      agentsMdPath: options.agentsMd,
+      agentsMdFormat: options.format ?? "xml",
+      debounceMs: 500
+    };
+    const materializer = new Materializer(storage, basePath, config2);
+    await materializer.initialize();
+    const skills = await storage.listSkills();
+    printSuccess(`Materialized ${skills.length} skill(s)`);
+    if (symlinkPaths.length > 0) {
+      const modeLabel = config2.mode === "copy" ? "Copied" : "Symlinked";
+      for (const p of symlinkPaths) {
+        printInfo(`${modeLabel} to: ${p}`);
+      }
+    }
+    if (options.agentsMd) {
+      printInfo(`AGENTS.md written to: ${options.agentsMd}`);
+    }
+    if (options.watch) {
+      printInfo("Watching for changes... (Ctrl+C to stop)");
+      printWarning(
+        "Note: Only detects changes to .skilltree/skills/. Changes via the SkillBank API are handled automatically when materialization is enabled in config."
+      );
+      materializer.watch();
+      await new Promise((resolve4) => {
+        process.on("SIGINT", () => {
+          materializer.shutdown();
+          resolve4();
+        });
+      });
+    } else {
+      materializer.shutdown();
+    }
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
 // src/cli/commands/loadout/index.ts
-var import_commander35 = require("commander");
+var import_commander37 = require("commander");
 
 // src/cli/commands/loadout/list.ts
-var import_commander23 = require("commander");
+var import_commander25 = require("commander");
 
 // src/serving/state-persistence.ts
-var fs17 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 var STATE_FILENAME = ".loadout-state.json";
 function loadState(skillPath) {
-  const filePath = path14.join(skillPath, STATE_FILENAME);
+  const filePath = path17.join(skillPath, STATE_FILENAME);
   try {
-    const raw = fs17.readFileSync(filePath, "utf-8");
+    const raw = fs19.readFileSync(filePath, "utf-8");
     const data = JSON.parse(raw);
     return {
       available: new Map(data.available),
@@ -10221,7 +10864,7 @@ function loadState(skillPath) {
   }
 }
 function saveState(skillPath, state) {
-  const filePath = path14.join(skillPath, STATE_FILENAME);
+  const filePath = path17.join(skillPath, STATE_FILENAME);
   const data = {
     available: Array.from(state.available.entries()),
     expanded: Array.from(state.expanded),
@@ -10229,12 +10872,12 @@ function saveState(skillPath, state) {
     source: state.source,
     updatedAt: state.updatedAt.toISOString()
   };
-  fs17.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  fs19.writeFileSync(filePath, JSON.stringify(data, null, 2));
 }
 function clearState(skillPath) {
-  const filePath = path14.join(skillPath, STATE_FILENAME);
+  const filePath = path17.join(skillPath, STATE_FILENAME);
   try {
-    fs17.unlinkSync(filePath);
+    fs19.unlinkSync(filePath);
     return true;
   } catch {
     return false;
@@ -10264,7 +10907,7 @@ async function createLoadoutServer(options) {
 }
 
 // src/cli/commands/loadout/list.ts
-var listSubcommand = new import_commander23.Command("list").description("List skills in the current loadout").option("-f, --filter <filter>", "Filter: all, expanded, available, pending", "all").action(async (options, command) => {
+var listSubcommand = new import_commander25.Command("list").description("List skills in the current loadout").option("-f, --filter <filter>", "Filter: all, expanded, available, pending", "all").action(async (options, command) => {
   const globalOpts = command.optsWithGlobals();
   try {
     const { server } = await createLoadoutServer(globalOpts);
@@ -10308,8 +10951,8 @@ var listSubcommand = new import_commander23.Command("list").description("List sk
 });
 
 // src/cli/commands/loadout/search.ts
-var import_commander24 = require("commander");
-var searchSubcommand = new import_commander24.Command("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) => {
+var import_commander26 = require("commander");
+var searchSubcommand = new import_commander26.Command("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();
   try {
     const { server } = await createLoadoutServer(globalOpts);
@@ -10339,8 +10982,8 @@ var searchSubcommand = new import_commander24.Command("search").description("Sea
 });
 
 // src/cli/commands/loadout/add.ts
-var import_commander25 = require("commander");
-var addSubcommand = new import_commander25.Command("add").description("Add skills to the loadout").argument("<ids...>", "Skill IDs to add").action(async (ids, _options, command) => {
+var import_commander27 = require("commander");
+var addSubcommand = new import_commander27.Command("add").description("Add skills to the loadout").argument("<ids...>", "Skill IDs to add").action(async (ids, _options, command) => {
   const globalOpts = command.optsWithGlobals();
   try {
     const { server, save } = await createLoadoutServer(globalOpts);
@@ -10358,8 +11001,8 @@ var addSubcommand = new import_commander25.Command("add").description("Add skill
 });
 
 // src/cli/commands/loadout/remove.ts
-var import_commander26 = require("commander");
-var removeSubcommand = new import_commander26.Command("remove").description("Remove skills from the loadout").argument("<ids...>", "Skill IDs to remove").action(async (ids, _options, command) => {
+var import_commander28 = require("commander");
+var removeSubcommand = new import_commander28.Command("remove").description("Remove skills from the loadout").argument("<ids...>", "Skill IDs to remove").action(async (ids, _options, command) => {
   const globalOpts = command.optsWithGlobals();
   try {
     const { server, save } = await createLoadoutServer(globalOpts);
@@ -10377,8 +11020,8 @@ var removeSubcommand = new import_commander26.Command("remove").description("Rem
 });
 
 // src/cli/commands/loadout/profile.ts
-var import_commander27 = require("commander");
-var profileSubcommand = new import_commander27.Command("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) => {
+var import_commander29 = require("commander");
+var profileSubcommand = new import_commander29.Command("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();
   try {
     const { server, save } = await createLoadoutServer(globalOpts);
@@ -10409,8 +11052,8 @@ var profileSubcommand = new import_commander27.Command("profile").description("S
 });
 
 // src/cli/commands/loadout/set.ts
-var import_commander28 = require("commander");
-var setSubcommand = new import_commander28.Command("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) => {
+var import_commander30 = require("commander");
+var setSubcommand = new import_commander30.Command("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();
   try {
     const { server, save } = await createLoadoutServer(globalOpts);
@@ -10439,8 +11082,8 @@ var setSubcommand = new import_commander28.Command("set").description("Set loado
 });
 
 // src/cli/commands/loadout/expand.ts
-var import_commander29 = require("commander");
-var expandSubcommand = new import_commander29.Command("expand").description("Expand a skill to see its full content").argument("<id>", "Skill ID to expand").action(async (id, _options, command) => {
+var import_commander31 = require("commander");
+var expandSubcommand = new import_commander31.Command("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();
   try {
     const { server, save } = await createLoadoutServer(globalOpts);
@@ -10465,8 +11108,8 @@ var expandSubcommand = new import_commander29.Command("expand").description("Exp
 });
 
 // src/cli/commands/loadout/collapse.ts
-var import_commander30 = require("commander");
-var collapseSubcommand = new import_commander30.Command("collapse").description("Collapse an expanded skill back to summary").argument("<id>", "Skill ID to collapse").action(async (id, _options, command) => {
+var import_commander32 = require("commander");
+var collapseSubcommand = new import_commander32.Command("collapse").description("Collapse an expanded skill back to summary").argument("<id>", "Skill ID to collapse").action(async (id, _options, command) => {
   const globalOpts = command.optsWithGlobals();
   try {
     const { server, save } = await createLoadoutServer(globalOpts);
@@ -10488,8 +11131,8 @@ var collapseSubcommand = new import_commander30.Command("collapse").description(
 });
 
 // src/cli/commands/loadout/use.ts
-var import_commander31 = require("commander");
-var useSubcommand = new import_commander31.Command("use").description("Mark a skill as being used (auto-expands and records usage)").argument("<id>", "Skill ID to use").action(async (id, _options, command) => {
+var import_commander33 = require("commander");
+var useSubcommand = new import_commander33.Command("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);
@@ -10515,8 +11158,8 @@ var useSubcommand = new import_commander31.Command("use").description("Mark a sk
 });
 
 // src/cli/commands/loadout/get.ts
-var import_commander32 = require("commander");
-var getSubcommand = new import_commander32.Command("get").description("Get details about a skill in the loadout").argument("<id>", "Skill ID").action(async (id, _options, command) => {
+var import_commander34 = require("commander");
+var getSubcommand = new import_commander34.Command("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);
@@ -10538,8 +11181,8 @@ var getSubcommand = new import_commander32.Command("get").description("Get detai
 });
 
 // src/cli/commands/loadout/render.ts
-var import_commander33 = require("commander");
-var renderSubcommand = new import_commander33.Command("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) => {
+var import_commander35 = require("commander");
+var renderSubcommand = new import_commander35.Command("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);
@@ -10557,8 +11200,8 @@ var renderSubcommand = new import_commander33.Command("render").description("Ren
 });
 
 // src/cli/commands/loadout/clear.ts
-var import_commander34 = require("commander");
-var clearSubcommand = new import_commander34.Command("clear").description("Clear the current loadout state").action(async (_options, command) => {
+var import_commander36 = require("commander");
+var clearSubcommand = new import_commander36.Command("clear").description("Clear the current loadout state").action(async (_options, command) => {
   const globalOpts = command.optsWithGlobals();
   try {
     const skillPath = resolveSkillPath(globalOpts.path);
@@ -10579,10 +11222,10 @@ var clearSubcommand = new import_commander34.Command("clear").description("Clear
 });
 
 // src/cli/commands/loadout/index.ts
-var loadoutCommand = new import_commander35.Command("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);
+var loadoutCommand = new import_commander37.Command("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);
 
 // src/cli/index.ts
-var program = new import_commander36.Command();
+var program = new import_commander38.Command();
 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);
@@ -10601,5 +11244,7 @@ program.addCommand(importCommand);
 program.addCommand(indexerCommand);
 program.addCommand(configCommand);
 program.addCommand(syncCommand2);
+program.addCommand(readCommand);
+program.addCommand(materializeCommand);
 program.addCommand(loadoutCommand);
 program.parse();