wyrm-mcp 7.3.2 → 7.3.3

package/dist/handlers/skill.js

@@ -1,67 +1,449 @@
-import{TOOL_ANNOTATIONS as v}from"../tool-annotations.js";import{currentReadCacheKey as $}from"./boundary.js";import{cache as h}from"../performance.js";import{sanitizeFtsQuery as O}from"../security.js";import{deploySkill as j,validateAtomicSkill as L}from"../skill-author.js";const A=[{name:"wyrm_skill_create",description:"Author + deploy + register an ATOMIC skill in one clean step. Validates atomicity (one focused capability, discoverable 12\u2013280 char description, proper frontmatter), writes <skillsDir>/<slug>/SKILL.md, and registers it so it's instantly findable via wyrm_skill_search. Refuses to clobber an existing skill unless force=true. Use this to create skills as they're needed instead of leaving them un-deployed.",inputSchema:{type:"object",properties:{name:{type:"string",description:"Skill name (slugified to kebab-case)"},description:{type:"string",description:"One-line description, 12\u2013280 chars \u2014 used for discovery/recall ranking"},body:{type:"string",description:"The SKILL.md markdown body (the actual skill content; should be ONE focused capability)"},argumentHint:{type:"string",description:"Optional argument-hint frontmatter (for user-invocable skills)"},userInvocable:{type:"boolean",description:"Whether it's a user-invocable slash command"},category:{type:"string",description:"Optional category"},tags:{type:"array",items:{type:"string"},description:"Optional tags"},force:{type:"boolean",description:"Overwrite an existing skill of the same slug (default false)"},register:{type:"boolean",description:"Register in the skill registry for discovery (default true)"}},required:["name","description","body"]},annotations:v.wyrm_skill_create,aliases:[],handler:async(c,p)=>{const{db:d}=p,n=c||{},o=(S=>{const x=S.filter(_=>!n[_]&&n[_]!==0&&n[_]!==!1);return x.length>0?{content:[{type:"text",text:`Missing required arguments: ${x.join(", ")}`}],isError:!0}:null})(["name","description","body"]);if(o)return o;const{name:t,description:s,body:g,argumentHint:m,userInvocable:a,category:y,tags:i,force:e,register:l}=c,k={name:t,description:s,body:g,argumentHint:m,userInvocable:a,category:y,tags:i},u=L(k);if(!u.ok)return{content:[{type:"text",text:`\u274C Skill rejected (not clean/atomic):
-- ${u.errors.join(`
-- `)}`}]};let f;try{f=j(k,{force:e})}catch(S){return{content:[{type:"text",text:`\u274C Deploy failed: ${S instanceof Error?S.message:String(S)}`}]}}let b=!1;if(l!==!1)try{d.registerSkill(u.slug,s,f.path,y,"Ghost Protocol","1.0.0",(i||[]).join(",")),b=!0}catch{}const w=u.warnings.length?`
-
-\u26A0\uFE0F  ${u.warnings.join(`
-\u26A0\uFE0F  `)}`:"";return{content:[{type:"text",text:`\u{F115D} Skill "${u.slug}" ${f.action}${b?" + registered (discoverable via wyrm_skill_search)":""}
-   ${f.path}${w}`}]}}},{name:"wyrm_skill_register",description:"Register or update a skill and store metadata in Wyrm. Supports GOD-SKILL SPEC v2 apex tiers (god > mega > atomic) with governs/composes routing.",inputSchema:{type:"object",properties:{name:{type:"string",description:"Skill name (e.g., 'professional-lead-scraping')"},description:{type:"string",description:"Skill description"},skillPath:{type:"string",description:"File path to skill (e.g., ~/.copilot/skills/name or project relative path)"},category:{type:"string",description:"Skill category (e.g., 'data-extraction', 'testing', 'documentation')"},author:{type:"string",description:"Skill author or creator"},version:{type:"string",description:"Skill version"},tags:{type:"string",description:"Comma-separated tags (e.g., 'scraping,leads,email-validation')"},tier:{type:"string",enum:["atomic","mega","god"],description:"GOD-SKILL SPEC v2 apex tier. Default 'atomic'. 'mega' composes atomics; 'god' governs megas."},governs:{type:"array",items:{type:"string"},description:"Skill names this node routes DOWN to (god\u2192megas, mega\u2192atomics). Default []."},composes:{type:"array",items:{type:"string"},description:"Skill names this node pulls in laterally. Default []."}},required:["name","description","skillPath"]},annotations:v.wyrm_skill_register,aliases:[],handler:async(c,p)=>{const{db:d}=p,{name:n,description:r,skillPath:o,category:t,author:s,version:g,tags:m,tier:a,governs:y,composes:i}=c,e=a||y||i?{tier:a,governs:y,composes:i}:void 0,l=d.registerSkill(n,r,o,t,s,g,m,e);h.invalidate("wyrm_skill_list"),h.invalidate("wyrm_skill_stats");const k=l.governs?JSON.parse(l.governs):[],u=l.composes?JSON.parse(l.composes):[];let f=`\u{F115D} **Skill Registered**
-
-Name: ${l.name}
-Path: ${l.skill_path}
-Category: ${l.category||"uncategorized"}
-Version: ${l.version||"1.0.0"}
-Tier: ${l.tier}
-Status: ${l.is_active?"Active":"Inactive"}`;return k.length&&(f+=`
-Governs: ${k.join(", ")}`),u.length&&(f+=`
-Composes: ${u.join(", ")}`),{content:[{type:"text",text:f}]}}},{name:"wyrm_skill_list",description:"List registered skills with filtering options",inputSchema:{type:"object",properties:{active:{type:"boolean",description:"Filter by active status"},category:{type:"string",description:"Filter by category"},search:{type:"string",description:"Full-text search by name, description, or tags"},tier:{type:"string",enum:["atomic","mega","god"],description:"Filter by GOD-SKILL SPEC v2 tier (atomic|mega|god)"}}},annotations:v.wyrm_skill_list,aliases:[],handler:async(c,p)=>{const{cachedResponse:d,db:n}=p,r=$(),{active:o,category:t,search:s,tier:g}=c,m=n.listSkills(o,t,s,g);if(m.length===0)return{content:[{type:"text",text:`\u{F115D} **Skills**
-
-No skills found matching your criteria.`}]};let a=`\u{F115D} **Skills Registry** (${m.length} total)
-
-`;for(const i of m){const e=i.tier&&i.tier!=="atomic"?` [${i.tier.toUpperCase()}]`:"";a+=`### ${i.name}${e} ${i.is_active?"\u2705":"\u274C"}
-`,a+=`Category: ${i.category||"uncategorized"}
-`,a+=`Description: ${i.description}
-`,i.version&&(a+=`Version: ${i.version}
-`),i.author&&(a+=`Author: ${i.author}
-`),i.tags&&(a+=`Tags: ${i.tags}
-`),a+=`Path: \`${i.skill_path}\`
-`,a+=`Used: ${i.usage_count} times`,i.last_used&&(a+=` (last: ${i.last_used})`),a+=`
-
-`}const y=d(a);return r&&h.set(r,y,3e4),y}},{name:"wyrm_skill_get",description:"Get detailed information about a specific skill",inputSchema:{type:"object",properties:{name:{type:"string",description:"Skill name"}},required:["name"]},annotations:v.wyrm_skill_get,aliases:[],handler:async(c,p)=>{const{cachedResponse:d,db:n}=p,r=$(),{name:o}=c,t=n.getSkill(o);if(!t)return{content:[{type:"text",text:`\u{F115D} **Skill Not Found**: ${o}`}]};let s=`\u{F115D} **Skill: ${t.name}** ${t.is_active?"\u2705 Active":"\u274C Inactive"}
-
-`;s+=`**Description:** ${t.description}
-`,s+=`**Path:** \`${t.skill_path}\`
-`,s+=`**Category:** ${t.category||"uncategorized"}
-`,t.author&&(s+=`**Author:** ${t.author}
-`),t.version&&(s+=`**Version:** ${t.version}
-`),t.tags&&(s+=`**Tags:** ${t.tags}
-`),s+=`**Usage Count:** ${t.usage_count}
-`,t.last_used&&(s+=`**Last Used:** ${t.last_used}
-`),s+=`**Created:** ${t.created_at}
-`,s+=`**Updated:** ${t.updated_at}
-`;const g=d(s);return r&&h.set(r,g,3e4),g}},{name:"wyrm_skill_delete",description:"Delete a skill from Wyrm registry",inputSchema:{type:"object",properties:{name:{type:"string",description:"Skill name"}},required:["name"]},annotations:v.wyrm_skill_delete,aliases:[],handler:async(c,p)=>{const{db:d}=p,{name:n}=c,r=d.deleteSkill(n);return h.invalidate("wyrm_skill_list"),h.invalidate("wyrm_skill_stats"),r?{content:[{type:"text",text:`\u{F115D} **Skill Deleted**: ${n}`}]}:{content:[{type:"text",text:`\u{F115D} **Skill Not Found**: ${n}`}]}}},{name:"wyrm_skill_activate",description:"Activate a skill (mark as active)",inputSchema:{type:"object",properties:{name:{type:"string",description:"Skill name"}},required:["name"]},annotations:v.wyrm_skill_activate,aliases:[],handler:async(c,p)=>{const{db:d}=p,{name:n}=c,r=d.activateSkill(n);return h.invalidate("wyrm_skill_list"),h.invalidate("wyrm_skill_stats"),r?{content:[{type:"text",text:`\u{F115D} **Skill Activated**: ${n}`}]}:{content:[{type:"text",text:`\u{F115D} **Skill Not Found**: ${n}`}]}}},{name:"wyrm_skill_deactivate",description:"Deactivate a skill (mark as inactive)",inputSchema:{type:"object",properties:{name:{type:"string",description:"Skill name"}},required:["name"]},annotations:v.wyrm_skill_deactivate,aliases:[],handler:async(c,p)=>{const{db:d}=p,{name:n}=c,r=d.deactivateSkill(n);return h.invalidate("wyrm_skill_list"),h.invalidate("wyrm_skill_stats"),r?{content:[{type:"text",text:`\u{F115D} **Skill Deactivated**: ${n}`}]}:{content:[{type:"text",text:`\u{F115D} **Skill Not Found**: ${n}`}]}}},{name:"wyrm_skill_search",description:"Search for skills by name, description, or tags. Optionally filter by GOD-SKILL SPEC v2 tier.",inputSchema:{type:"object",properties:{query:{type:"string",description:"Search query"},limit:{type:"number",description:"Max results (default: 20)"},tier:{type:"string",enum:["atomic","mega","god"],description:"Restrict results to a GOD-SKILL SPEC v2 tier (atomic|mega|god)"}},required:["query"]},annotations:v.wyrm_skill_search,aliases:[],handler:async(c,p)=>{const{cachedResponse:d,db:n}=p,r=$(),{query:o,limit:t,tier:s}=c,g=O(o),m=n.searchSkills(g,t||20,s);if(m.length===0)return{content:[{type:"text",text:`\u{F115D} **Search Skills**: No results found for "${o}"${s?` (tier=${s})`:""}`}]};let a=`\u{F115D} **Skill Search Results for "${o}"** (${m.length} found)
-
-`;for(const i of m){const e=i.tier&&i.tier!=="atomic"?` [${i.tier.toUpperCase()}]`:"";a+=`- **${i.name}**${e} (${i.category||"uncategorized"}) ${i.is_active?"\u2705":"\u274C"}
-`,a+=`  ${i.description}
-
-`}const y=d(a);return r&&h.set(r,y,3e4),y}},{name:"wyrm_skill_stats",description:"Get statistics on registered skills",inputSchema:{type:"object",properties:{}},annotations:v.wyrm_skill_stats,aliases:[],handler:async(c,p)=>{const{cachedResponse:d,db:n}=p,r=$(),o=n.getSkillStats();let t=`\u{F115D} **Skill Statistics**
-
-`;if(t+=`**Total Skills:** ${o.total}
-`,t+=`**Active Skills:** ${o.active}
-`,t+=`**Inactive Skills:** ${o.total-o.active}
-
-`,Object.keys(o.byCategory).length>0){t+=`**By Category:**
-`;for(const[g,m]of Object.entries(o.byCategory))t+=`- ${g}: ${m}
-`}const s=d(t);return r&&h.set(r,s,3e4),s}},{name:"wyrm_skill_graph",description:"Return the GOD-SKILL SPEC v2 governance graph: walks god \u2192 governs(mega) \u2192 governs(atomic) plus each node's composes, as a tree + edge-list the caller can render. Pass a root skill to scope to one apex; omit it to get the forest of every 'god' tier skill.",inputSchema:{type:"object",properties:{root:{type:"string",description:"Optional root skill name to scope the graph (e.g. 'ghost-godhead'). Omit for all god-tier apexes."},format:{type:"string",enum:["tree","edges","both"],description:"Output shape: 'tree' (nested), 'edges' (flat edge-list), or 'both' (default)."}}},annotations:v.wyrm_skill_graph,aliases:[],handler:async(c,p)=>{const{db:d,graph:n}=p,{root:r,format:o}=c,t=o||"both",s=d.getSkillGraph(r);if(s.length===0)return{content:[{type:"text",text:`\u{F115D} **Skill Graph**
-
-${r?`Skill "${r}" is not registered (or has no graph).`:"No god-tier skills registered. Register one with wyrm_skill_register tier='god' + governs=[...]."}`}]};const g=[],m=e=>{for(const l of e.governs)g.push({from:e.name,to:l,kind:"governs",resolved:e.children.some(k=>k.name===l)});for(const l of e.composes)g.push({from:e.name,to:l,kind:"composes",resolved:!1});for(const l of e.children)m(l)};for(const e of s)m(e);const a=e=>e==="god"?"\u{1F451}":e==="mega"?"\u25C6":"\xB7",y=(e,l)=>{const k="  ".repeat(l);let u=`${k}${a(e.tier)} ${e.name} (${e.tier})
-`;e.composes.length&&(u+=`${k}    ~composes: ${e.composes.join(", ")}
-`),e.missing&&e.missing.length&&(u+=`${k}    \u26A0 missing: ${e.missing.join(", ")}
-`);for(const f of e.children)u+=y(f,l+1);return u};let i=`\u{F115D} **Skill Governance Graph**${r?` (root: ${r})`:" (all god apexes)"}
-
-`;if(t==="tree"||t==="both")for(const e of s)i+=y(e,0);if(t==="edges"||t==="both"){i+=`
-**Edges (${g.length}):**
-`;for(const e of g)i+=`- ${e.from} \u2014${e.kind}\u2192 ${e.to}${e.kind==="governs"&&!e.resolved?" (unresolved)":""}
-`}return i+=`
-\`\`\`json
-${JSON.stringify({tree:s,edges:g},null,2)}
-\`\`\``,{content:[{type:"text",text:i}]}}}];export{A as skillToolSpecs};
+/**
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { TOOL_ANNOTATIONS } from "../tool-annotations.js";
+import { currentReadCacheKey } from "./boundary.js";
+import { cache } from "../performance.js";
+import { sanitizeFtsQuery } from "../security.js";
+import { deploySkill, validateAtomicSkill } from "../skill-author.js";
+export const skillToolSpecs = [
+    {
+        name: "wyrm_skill_create",
+        description: "Author + deploy + register an ATOMIC skill in one clean step. Validates atomicity (one focused capability, discoverable 12–280 char description, proper frontmatter), writes <skillsDir>/<slug>/SKILL.md, and registers it so it's instantly findable via wyrm_skill_search. Refuses to clobber an existing skill unless force=true. Use this to create skills as they're needed instead of leaving them un-deployed.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Skill name (slugified to kebab-case)" },
+                description: { type: "string", description: "One-line description, 12–280 chars — used for discovery/recall ranking" },
+                body: { type: "string", description: "The SKILL.md markdown body (the actual skill content; should be ONE focused capability)" },
+                argumentHint: { type: "string", description: "Optional argument-hint frontmatter (for user-invocable skills)" },
+                userInvocable: { type: "boolean", description: "Whether it's a user-invocable slash command" },
+                category: { type: "string", description: "Optional category" },
+                tags: { type: "array", items: { type: "string" }, description: "Optional tags" },
+                force: { type: "boolean", description: "Overwrite an existing skill of the same slug (default false)" },
+                register: { type: "boolean", description: "Register in the skill registry for discovery (default true)" },
+            },
+            required: ["name", "description", "body"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_skill_create"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { db } = ctx;
+            const a = args || {};
+            const requireArgs = (fields) => {
+                const missing = fields.filter(f => !a[f] && a[f] !== 0 && a[f] !== false);
+                if (missing.length > 0) {
+                    return { content: [{ type: "text", text: `Missing required arguments: ${missing.join(', ')}` }], isError: true };
+                }
+                return null;
+            };
+            const argErr = requireArgs(['name', 'description', 'body']);
+            if (argErr)
+                return argErr;
+            const { name, description, body, argumentHint, userInvocable, category, tags, force, register } = args;
+            const spec = { name, description, body, argumentHint, userInvocable, category, tags };
+            const v = validateAtomicSkill(spec);
+            if (!v.ok) {
+                return { content: [{ type: "text", text: `❌ Skill rejected (not clean/atomic):\n- ${v.errors.join('\n- ')}` }] };
+            }
+            let deploy;
+            try {
+                deploy = deploySkill(spec, { force });
+            }
+            catch (e) {
+                return { content: [{ type: "text", text: `❌ Deploy failed: ${e instanceof Error ? e.message : String(e)}` }] };
+            }
+            let registered = false;
+            if (register !== false) {
+                try {
+                    db.registerSkill(v.slug, description, deploy.path, category, 'Ghost Protocol', '1.0.0', (tags || []).join(','));
+                    registered = true;
+                }
+                catch { /* registry optional; file is deployed regardless */ }
+            }
+            const warn = v.warnings.length ? `\n\n⚠️  ${v.warnings.join('\n⚠️  ')}` : '';
+            return { content: [{ type: "text", text: `󱅝 Skill "${v.slug}" ${deploy.action}${registered ? ' + registered (discoverable via wyrm_skill_search)' : ''}\n   ${deploy.path}${warn}` }] };
+        },
+    },
+    {
+        name: "wyrm_skill_register",
+        description: "Register or update a skill and store metadata in Wyrm. Supports GOD-SKILL SPEC v2 apex tiers (god > mega > atomic) with governs/composes routing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Skill name (e.g., 'professional-lead-scraping')" },
+                description: { type: "string", description: "Skill description" },
+                skillPath: { type: "string", description: "File path to skill (e.g., ~/.copilot/skills/name or project relative path)" },
+                category: { type: "string", description: "Skill category (e.g., 'data-extraction', 'testing', 'documentation')" },
+                author: { type: "string", description: "Skill author or creator" },
+                version: { type: "string", description: "Skill version" },
+                tags: { type: "string", description: "Comma-separated tags (e.g., 'scraping,leads,email-validation')" },
+                tier: { type: "string", enum: ["atomic", "mega", "god"], description: "GOD-SKILL SPEC v2 apex tier. Default 'atomic'. 'mega' composes atomics; 'god' governs megas." },
+                governs: { type: "array", items: { type: "string" }, description: "Skill names this node routes DOWN to (god→megas, mega→atomics). Default []." },
+                composes: { type: "array", items: { type: "string" }, description: "Skill names this node pulls in laterally. Default []." },
+            },
+            required: ["name", "description", "skillPath"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_skill_register"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { db } = ctx;
+            const { name, description, skillPath, category, author, version, tags, tier, governs, composes } = args;
+            const governance = (tier || governs || composes)
+                ? { tier, governs, composes }
+                : undefined;
+            const skill = db.registerSkill(name, description, skillPath, category, author, version, tags, governance);
+            cache.invalidate('wyrm_skill_list');
+            cache.invalidate('wyrm_skill_stats');
+            const governsList = skill.governs ? JSON.parse(skill.governs) : [];
+            const composesList = skill.composes ? JSON.parse(skill.composes) : [];
+            let text = `󱅝 **Skill Registered**\n\nName: ${skill.name}\nPath: ${skill.skill_path}\nCategory: ${skill.category || 'uncategorized'}\nVersion: ${skill.version || '1.0.0'}\nTier: ${skill.tier}\nStatus: ${skill.is_active ? 'Active' : 'Inactive'}`;
+            if (governsList.length)
+                text += `\nGoverns: ${governsList.join(', ')}`;
+            if (composesList.length)
+                text += `\nComposes: ${composesList.join(', ')}`;
+            return { content: [{ type: "text", text }] };
+        },
+    },
+    {
+        name: "wyrm_skill_list",
+        description: "List registered skills with filtering options",
+        inputSchema: {
+            type: "object",
+            properties: {
+                active: { type: "boolean", description: "Filter by active status" },
+                category: { type: "string", description: "Filter by category" },
+                search: { type: "string", description: "Full-text search by name, description, or tags" },
+                tier: { type: "string", enum: ["atomic", "mega", "god"], description: "Filter by GOD-SKILL SPEC v2 tier (atomic|mega|god)" },
+            },
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_skill_list"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { cachedResponse, db } = ctx;
+            const cacheKey = currentReadCacheKey();
+            const { active, category, search, tier } = args;
+            const skills = db.listSkills(active, category, search, tier);
+            if (skills.length === 0) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `󱅝 **Skills**\n\nNo skills found matching your criteria.`
+                        }]
+                };
+            }
+            let text = `󱅝 **Skills Registry** (${skills.length} total)\n\n`;
+            for (const skill of skills) {
+                const tierBadge = skill.tier && skill.tier !== 'atomic' ? ` [${skill.tier.toUpperCase()}]` : '';
+                text += `### ${skill.name}${tierBadge} ${skill.is_active ? '✅' : '❌'}\n`;
+                text += `Category: ${skill.category || 'uncategorized'}\n`;
+                text += `Description: ${skill.description}\n`;
+                if (skill.version)
+                    text += `Version: ${skill.version}\n`;
+                if (skill.author)
+                    text += `Author: ${skill.author}\n`;
+                if (skill.tags)
+                    text += `Tags: ${skill.tags}\n`;
+                text += `Path: \`${skill.skill_path}\`\n`;
+                text += `Used: ${skill.usage_count} times`;
+                if (skill.last_used)
+                    text += ` (last: ${skill.last_used})`;
+                text += '\n\n';
+            }
+            const response = cachedResponse(text);
+            if (cacheKey)
+                cache.set(cacheKey, response, 30000);
+            return response;
+        },
+    },
+    {
+        name: "wyrm_skill_get",
+        description: "Get detailed information about a specific skill",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Skill name" },
+            },
+            required: ["name"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_skill_get"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { cachedResponse, db } = ctx;
+            const cacheKey = currentReadCacheKey();
+            const { name } = args;
+            const skill = db.getSkill(name);
+            if (!skill) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `󱅝 **Skill Not Found**: ${name}`
+                        }]
+                };
+            }
+            let text = `󱅝 **Skill: ${skill.name}** ${skill.is_active ? '✅ Active' : '❌ Inactive'}\n\n`;
+            text += `**Description:** ${skill.description}\n`;
+            text += `**Path:** \`${skill.skill_path}\`\n`;
+            text += `**Category:** ${skill.category || 'uncategorized'}\n`;
+            if (skill.author)
+                text += `**Author:** ${skill.author}\n`;
+            if (skill.version)
+                text += `**Version:** ${skill.version}\n`;
+            if (skill.tags)
+                text += `**Tags:** ${skill.tags}\n`;
+            text += `**Usage Count:** ${skill.usage_count}\n`;
+            if (skill.last_used)
+                text += `**Last Used:** ${skill.last_used}\n`;
+            text += `**Created:** ${skill.created_at}\n`;
+            text += `**Updated:** ${skill.updated_at}\n`;
+            const response = cachedResponse(text);
+            if (cacheKey)
+                cache.set(cacheKey, response, 30000);
+            return response;
+        },
+    },
+    {
+        name: "wyrm_skill_delete",
+        description: "Delete a skill from Wyrm registry",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Skill name" },
+            },
+            required: ["name"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_skill_delete"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { db } = ctx;
+            const { name } = args;
+            const success = db.deleteSkill(name);
+            cache.invalidate('wyrm_skill_list');
+            cache.invalidate('wyrm_skill_stats');
+            if (success) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `󱅝 **Skill Deleted**: ${name}`
+                        }]
+                };
+            }
+            else {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `󱅝 **Skill Not Found**: ${name}`
+                        }]
+                };
+            }
+        },
+    },
+    {
+        name: "wyrm_skill_activate",
+        description: "Activate a skill (mark as active)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Skill name" },
+            },
+            required: ["name"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_skill_activate"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { db } = ctx;
+            const { name } = args;
+            const skill = db.activateSkill(name);
+            cache.invalidate('wyrm_skill_list');
+            cache.invalidate('wyrm_skill_stats');
+            if (skill) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `󱅝 **Skill Activated**: ${name}`
+                        }]
+                };
+            }
+            else {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `󱅝 **Skill Not Found**: ${name}`
+                        }]
+                };
+            }
+        },
+    },
+    {
+        name: "wyrm_skill_deactivate",
+        description: "Deactivate a skill (mark as inactive)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Skill name" },
+            },
+            required: ["name"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_skill_deactivate"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { db } = ctx;
+            const { name } = args;
+            const skill = db.deactivateSkill(name);
+            cache.invalidate('wyrm_skill_list');
+            cache.invalidate('wyrm_skill_stats');
+            if (skill) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `󱅝 **Skill Deactivated**: ${name}`
+                        }]
+                };
+            }
+            else {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `󱅝 **Skill Not Found**: ${name}`
+                        }]
+                };
+            }
+        },
+    },
+    {
+        name: "wyrm_skill_search",
+        description: "Search for skills by name, description, or tags. Optionally filter by GOD-SKILL SPEC v2 tier.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Search query" },
+                limit: { type: "number", description: "Max results (default: 20)" },
+                tier: { type: "string", enum: ["atomic", "mega", "god"], description: "Restrict results to a GOD-SKILL SPEC v2 tier (atomic|mega|god)" },
+            },
+            required: ["query"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_skill_search"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { cachedResponse, db } = ctx;
+            const cacheKey = currentReadCacheKey();
+            const { query, limit, tier } = args;
+            const sanitizedQuery = sanitizeFtsQuery(query);
+            const skills = db.searchSkills(sanitizedQuery, limit || 20, tier);
+            if (skills.length === 0) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `󱅝 **Search Skills**: No results found for "${query}"${tier ? ` (tier=${tier})` : ''}`
+                        }]
+                };
+            }
+            let text = `󱅝 **Skill Search Results for "${query}"** (${skills.length} found)\n\n`;
+            for (const skill of skills) {
+                const tierBadge = skill.tier && skill.tier !== 'atomic' ? ` [${skill.tier.toUpperCase()}]` : '';
+                text += `- **${skill.name}**${tierBadge} (${skill.category || 'uncategorized'}) ${skill.is_active ? '✅' : '❌'}\n`;
+                text += `  ${skill.description}\n\n`;
+            }
+            const response = cachedResponse(text);
+            if (cacheKey)
+                cache.set(cacheKey, response, 30000);
+            return response;
+        },
+    },
+    {
+        name: "wyrm_skill_stats",
+        description: "Get statistics on registered skills",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_skill_stats"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { cachedResponse, db } = ctx;
+            const cacheKey = currentReadCacheKey();
+            const stats = db.getSkillStats();
+            let text = `󱅝 **Skill Statistics**\n\n`;
+            text += `**Total Skills:** ${stats.total}\n`;
+            text += `**Active Skills:** ${stats.active}\n`;
+            text += `**Inactive Skills:** ${stats.total - stats.active}\n\n`;
+            if (Object.keys(stats.byCategory).length > 0) {
+                text += `**By Category:**\n`;
+                for (const [category, count] of Object.entries(stats.byCategory)) {
+                    text += `- ${category}: ${count}\n`;
+                }
+            }
+            const response = cachedResponse(text);
+            if (cacheKey)
+                cache.set(cacheKey, response, 30000);
+            return response;
+        },
+    },
+    {
+        name: "wyrm_skill_graph",
+        description: "Return the GOD-SKILL SPEC v2 governance graph: walks god → governs(mega) → governs(atomic) plus each node's composes, as a tree + edge-list the caller can render. Pass a root skill to scope to one apex; omit it to get the forest of every 'god' tier skill.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                root: { type: "string", description: "Optional root skill name to scope the graph (e.g. 'ghost-godhead'). Omit for all god-tier apexes." },
+                format: { type: "string", enum: ["tree", "edges", "both"], description: "Output shape: 'tree' (nested), 'edges' (flat edge-list), or 'both' (default)." },
+            },
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_skill_graph"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { db, graph } = ctx;
+            const { root, format } = args;
+            const fmt = format || 'both';
+            const forest = db.getSkillGraph(root);
+            if (forest.length === 0) {
+                const reason = root
+                    ? `Skill "${root}" is not registered (or has no graph).`
+                    : `No god-tier skills registered. Register one with wyrm_skill_register tier='god' + governs=[...].`;
+                return { content: [{ type: "text", text: `󱅝 **Skill Graph**\n\n${reason}` }] };
+            }
+            const edges = [];
+            const walk = (n) => {
+                for (const g of n.governs) {
+                    edges.push({ from: n.name, to: g, kind: 'governs', resolved: n.children.some((c) => c.name === g) });
+                }
+                for (const c of n.composes) {
+                    edges.push({ from: n.name, to: c, kind: 'composes', resolved: false });
+                }
+                for (const child of n.children)
+                    walk(child);
+            };
+            for (const r of forest)
+                walk(r);
+            // Human-readable tree render.
+            const tierIcon = (t) => (t === 'god' ? '👑' : t === 'mega' ? '◆' : '·');
+            const renderTree = (n, depth) => {
+                const indent = '  '.repeat(depth);
+                let out = `${indent}${tierIcon(n.tier)} ${n.name} (${n.tier})\n`;
+                if (n.composes.length)
+                    out += `${indent}    ~composes: ${n.composes.join(', ')}\n`;
+                if (n.missing && n.missing.length)
+                    out += `${indent}    ⚠ missing: ${n.missing.join(', ')}\n`;
+                for (const child of n.children)
+                    out += renderTree(child, depth + 1);
+                return out;
+            };
+            let text = `󱅝 **Skill Governance Graph**${root ? ` (root: ${root})` : ' (all god apexes)'}\n\n`;
+            if (fmt === 'tree' || fmt === 'both') {
+                for (const r of forest)
+                    text += renderTree(r, 0);
+            }
+            if (fmt === 'edges' || fmt === 'both') {
+                text += `\n**Edges (${edges.length}):**\n`;
+                for (const e of edges) {
+                    text += `- ${e.from} —${e.kind}→ ${e.to}${e.kind === 'governs' && !e.resolved ? ' (unresolved)' : ''}\n`;
+                }
+            }
+            // Machine-readable payload appended for programmatic callers.
+            text += `\n\`\`\`json\n${JSON.stringify({ tree: forest, edges }, null, 2)}\n\`\`\``;
+            return { content: [{ type: "text", text }] };
+        },
+    },
+];
+//# sourceMappingURL=skill.js.map