assistme 0.2.8 → 0.3.0

package/src/agent/skills.ts

@@ -1,6 +1,6 @@
 import { execSync } from "child_process";
 import { log } from "../utils/logger.js";
-import { getSupabase } from "../db/supabase.js";
+import { callMcpHandler } from "../db/api-client.js";
 
 // ── Text Processing Helpers ─────────────────────────────────────────
 
@@ -25,12 +25,10 @@ const STOP_WORDS = new Set([
  * Supports both English (space-delimited) and Chinese (character bigrams).
  */
 function tokenize(text: string): string[] {
-  // English tokens: split on delimiters, filter stop words
   const englishTokens = text
     .split(/[\s\-_/.,;:!?()[\]{}'"]+/)
     .filter((w) => w.length > 2 && !STOP_WORDS.has(w));
 
-  // Chinese character bigrams for CJK text
   const chineseChars = text.replace(/[^\u4e00-\u9fff]/g, "");
   const chineseBigrams: string[] = [];
   for (let i = 0; i < chineseChars.length - 1; i++) {
@@ -40,9 +38,6 @@ function tokenize(text: string): string[] {
   return [...englishTokens, ...chineseBigrams];
 }
 
-/**
- * Generate bigrams (consecutive word pairs) from a token list.
- */
 function bigrams(tokens: string[]): Set<string> {
   const result = new Set<string>();
   for (let i = 0; i < tokens.length - 1; i++) {
@@ -67,26 +62,6 @@ export interface SkillMetadata {
   skillKey?: string;
 }
 
-/**
- * A variable that a skill requires from the user.
- * Variables are defined in the skill template (e.g. `{{github_repos}}`)
- * and resolved with user-specific values stored in agent_skills.config.
- */
-export interface SkillVariable {
-  /** Variable name used in templates, e.g. "github_repos" */
-  name: string;
-  /** Human-readable description, e.g. "GitHub repositories to monitor" */
-  description: string;
-  /** Data type of the variable */
-  type: "string" | "string[]" | "number" | "boolean";
-  /** Whether the skill cannot function without this variable */
-  required: boolean;
-  /** Default value if not configured by user */
-  default?: string;
-  /** Example value to guide the user, e.g. "octocat/hello-world, myorg/myrepo" */
-  example?: string;
-}
-
 export interface Skill {
   name: string;
   description: string;
@@ -98,20 +73,14 @@ export interface Skill {
   argumentHint: string;
   metadata: SkillMetadata;
   homepage: string;
-  content: string; // The markdown body (instructions)
-  filePath: string; // Empty for DB-only skills
+  content: string;
+  filePath: string;
   source: "bundled" | "manual" | "external" | "auto_extracted" | "auto_improved" | "job_generated";
-  dbId?: string; // UUID from agent_skills table
-  sourceSkillId?: string; // UUID from skills table (origin)
-  /** Variable definitions declared by the skill template */
-  variables?: SkillVariable[];
-  /** User-specific variable values (from agent_skills.config) */
-  config?: Record<string, unknown>;
+  dbId?: string;
+  sourceSkillId?: string;
+  invocationCount: number;
 }
 
-/**
- * Parse metadata JSONB from DB row into SkillMetadata.
- */
 function parseDbMetadata(raw: unknown): SkillMetadata {
   if (!raw || typeof raw !== "object") return {};
   const obj = raw as Record<string, unknown>;
@@ -127,63 +96,33 @@ function parseDbMetadata(raw: unknown): SkillMetadata {
 }
 
 // ── Skill Manager ───────────────────────────────────────────────────
-// Architecture:
-//   skills table    = repository of all skill definitions (like npm)
-//   agent_skills    = user's active collection (approved/added skills)
-//   in-memory map   = loaded from agent_skills for fast access
-//
-// Flow:
-//   create()     → saves to skills table only (draft, is_public: false)
-//   addSkill()   → copies from skills to agent_skills + in-memory map
-//   publish()    → sets skills.is_public = true
 
 export class SkillManager {
   private skills: Map<string, Skill> = new Map();
   private idfCache: Map<string, number> = new Map();
   private userId: string | null = null;
 
-  /** Budget for skill descriptions in system prompt (characters). */
+  /** Cache for findRelevant() — keyed by prompt, invalidated on skill changes */
+  private relevanceCache: Map<string, { results: Skill[]; maxResults: number }> = new Map();
+
   private readonly DESCRIPTION_BUDGET_CHARS = 16_000;
 
-  /**
-   * Set the user ID for DB operations.
-   * Called after authentication; enables DB-backed skill storage.
-   */
   setUserId(userId: string): void {
     this.userId = userId;
   }
 
-  /**
-   * Load skills from DB (user's agent_skills collection).
-   * This is the only loading mechanism — no file-based loading.
-   */
   async loadFromDb(): Promise<void> {
     if (!this.userId) return;
 
     try {
-      const sb = getSupabase();
-
-      // Load only the user's active skills from agent_skills
-      const { data, error } = await sb
-        .from("agent_skills")
-        .select("*")
-        .eq("user_id", this.userId)
-        .eq("is_active", true);
-
-      if (error) {
-        log.debug(`DB skill load failed: ${error.message}`);
-        return;
-      }
+      const data = await callMcpHandler<Record<string, unknown>[]>("skill.load");
 
       this.skills.clear();
-      const dbRows = (data || []) as Record<string, unknown>[];
-
-      for (const row of dbRows) {
+      for (const row of data || []) {
         const skill = this.rowToSkill(row);
         this.skills.set(skill.name, skill);
       }
 
-      // Build IDF cache for relevance matching
       this.buildIdfCache();
 
       if (this.skills.size > 0) {
@@ -194,19 +133,7 @@ export class SkillManager {
     }
   }
 
-  /**
-   * Convert a DB row to a Skill object.
-   */
   private rowToSkill(row: Record<string, unknown>): Skill {
-    // Parse variables from metadata.variables or top-level variables column
-    const meta = (row.metadata || {}) as Record<string, unknown>;
-    const rawVars = (row.variables || meta.variables) as SkillVariable[] | undefined;
-    const variables = Array.isArray(rawVars) ? rawVars : undefined;
-
-    // Parse user config (variable values) from config column
-    const rawConfig = row.config as Record<string, unknown> | undefined;
-    const config = rawConfig && typeof rawConfig === "object" ? rawConfig : undefined;
-
     return {
       name: row.name as string,
       description: (row.description as string) || "",
@@ -223,15 +150,16 @@ export class SkillManager {
       source: (row.source as Skill["source"]) || "manual",
       dbId: row.id as string,
       sourceSkillId: (row.source_skill_id as string) || undefined,
-      variables,
-      config,
+      invocationCount: (row.invocation_count as number) || 0,
     };
   }
 
-  /**
-   * Pre-compute IDF (Inverse Document Frequency) for all tokens across skills.
-   * Called once after loadFromDb(), avoids recomputing on every findRelevant() call.
-   */
+  /** Invalidate caches when skills change (create, add, update, remove). */
+  private invalidateCaches(): void {
+    this.relevanceCache.clear();
+    this.buildIdfCache();
+  }
+
   private buildIdfCache(): void {
     this.idfCache.clear();
     const docFreq = new Map<string, number>();
@@ -248,102 +176,98 @@ export class SkillManager {
     }
   }
 
-  /**
-   * Get all loaded skills (from user's agent_skills collection).
-   */
   getAll(): Skill[] {
     return Array.from(this.skills.values());
   }
 
-  /**
-   * Get a skill by name.
-   */
   get(name: string): Skill | undefined {
     return this.skills.get(name);
   }
 
-  /**
-   * Find skills relevant to a given task prompt.
-   * Uses a TF-IDF-inspired scoring approach with pre-computed IDF cache.
-   */
   findRelevant(prompt: string, maxResults = 3): Skill[] {
-    const lower = prompt.toLowerCase();
+    // Check cache (hit if same prompt and at least as many results cached)
+    const cacheKey = prompt.toLowerCase();
+    const cached = this.relevanceCache.get(cacheKey);
+    if (cached && cached.maxResults >= maxResults) {
+      return cached.results.slice(0, maxResults);
+    }
+
+    const lower = cacheKey;
     const promptTokens = tokenize(lower);
     const promptTokenSet = new Set(promptTokens);
-
     const idf = (word: string): number => this.idfCache.get(word) || 1;
-
     const scored: Array<{ skill: Skill; score: number }> = [];
 
     for (const skill of this.skills.values()) {
       if (skill.disableModelInvocation) continue;
-
       let score = 0;
-
-      // Name match (strongest signal)
       if (lower.includes(skill.name.toLowerCase())) score += 10;
-
-      // Keywords match (explicit frontmatter keywords — high signal)
       for (const kw of skill.keywords) {
-        if (lower.includes(kw.toLowerCase())) {
-          score += 8;
-        }
+        if (lower.includes(kw.toLowerCase())) score += 8;
       }
-
-      // Description word overlap with IDF weighting
       const descTokens = tokenize(skill.description.toLowerCase());
       for (const word of descTokens) {
-        if (promptTokenSet.has(word)) {
-          score += 3 * idf(word);
-        }
+        if (promptTokenSet.has(word)) score += 3 * idf(word);
       }
-
-      // Content keyword matches with IDF weighting (lighter)
       const contentTokens = tokenize(skill.content.toLowerCase());
       for (const word of contentTokens) {
-        if (promptTokenSet.has(word)) {
-          score += 0.5 * idf(word);
-        }
+        if (promptTokenSet.has(word)) score += 0.5 * idf(word);
       }
-
-      // Bigram matching: consecutive word pairs
       const promptBigrams = bigrams(promptTokens);
       const descBigrams = bigrams(descTokens);
       for (const bg of descBigrams) {
         if (promptBigrams.has(bg)) score += 5;
       }
-
-      if (score > 0) {
-        scored.push({ skill, score });
-      }
+      if (score > 0) scored.push({ skill, score });
     }
 
-    return scored
+    const results = scored
       .sort((a, b) => b.score - a.score)
       .slice(0, maxResults)
       .map((s) => s.skill);
+
+    // Cache the result
+    this.relevanceCache.set(cacheKey, { results, maxResults });
+    return results;
   }
 
   /**
-   * Build a lightweight prompt section with skill descriptions only.
-   * Full skill content is loaded on-demand via the skill_invoke tool.
+   * Build lightweight skill descriptions for the system prompt.
+   * When a taskPrompt is provided, relevant skills are prioritized to the top;
+   * remaining skills are sorted by usage frequency (invocationCount).
    */
-  buildSkillDescriptions(): string {
-    const skills = this.getAll()
-      .filter((s) => !s.disableModelInvocation)
-      .sort((a, b) => {
-        // always=true skills first
-        if (a.metadata.always && !b.metadata.always) return -1;
-        if (!a.metadata.always && b.metadata.always) return 1;
-        // Then shorter descriptions first (fit more skills in budget)
-        return a.description.length - b.description.length;
-      });
+  buildSkillDescriptions(taskPrompt?: string): string {
+    const all = this.getAll().filter((s) => !s.disableModelInvocation);
+    if (all.length === 0) return "";
+
+    // Split into "always" skills and the rest
+    const alwaysSkills = all.filter((s) => s.metadata.always);
+    const rest = all.filter((s) => !s.metadata.always);
+
+    // If a task prompt is provided, find relevant skills and prioritize them
+    let relevantNames: Set<string> | null = null;
+    if (taskPrompt) {
+      const relevant = this.findRelevant(taskPrompt, 10);
+      relevantNames = new Set(relevant.map((s) => s.name));
+    }
 
-    if (skills.length === 0) return "";
+    // Sort: relevant skills first (by match score, already sorted), then by invocation count
+    const sorted = rest.sort((a, b) => {
+      if (relevantNames) {
+        const aRelevant = relevantNames.has(a.name);
+        const bRelevant = relevantNames.has(b.name);
+        if (aRelevant && !bRelevant) return -1;
+        if (!aRelevant && bRelevant) return 1;
+      }
+      return (b.invocationCount || 0) - (a.invocationCount || 0);
+    });
+
+    const skills = [...alwaysSkills, ...sorted];
 
     let budget = this.DESCRIPTION_BUDGET_CHARS;
     let prompt = "\n\n## Your Skills\n";
-    prompt += "These are your approved skills. Use skill_invoke to load full instructions when a task matches.\n\n";
+    prompt += "These are your approved skills. Use skill_invoke to load full instructions when a task matches.\n";
+    prompt += "If no skill matches but the task is a reusable pattern, consider creating one with skill_create.\n\n";
     let included = 0;
 
     for (const skill of skills) {
@@ -357,22 +281,19 @@ export class SkillManager {
     }
 
     if (included < skills.length) {
-      prompt += `\n_(${skills.length - included} additional skills available — use skill_invoke to explore)_\n`;
+      prompt += `\n_(${skills.length - included} additional skills available — use skill_search to find more)_\n`;
     }
 
     return prompt;
   }
 
-  /**
-   * @deprecated Use buildSkillDescriptions() + skill_invoke tool instead.
-   */
+  /** @deprecated Use buildSkillDescriptions() + skill_invoke tool instead. */
   buildSkillPrompt(taskPrompt: string): string {
     const relevant = this.findRelevant(taskPrompt);
     if (relevant.length === 0) return "";
 
     let prompt = "\n\n## Available Skills\n";
-    prompt +=
-      "The following skills provide detailed instructions for this type of task:\n\n";
+    prompt += "The following skills provide detailed instructions for this type of task:\n\n";
 
     for (const skill of relevant) {
       const emoji = skill.metadata.emoji || "";
@@ -384,48 +305,30 @@ export class SkillManager {
     return prompt;
   }
 
-  /**
-   * Create a new skill. Saves to `skills` table only (as private draft).
-   * The skill is NOT added to user's active collection (agent_skills) until
-   * the user approves it via addSkill().
-   *
-   * Returns { id, name } of the created skill, or null on failure.
-   */
   async create(
     name: string,
     description: string,
     content: string,
-    options?: { source?: string; emoji?: string; keywords?: string[]; variables?: SkillVariable[] }
+    options?: { source?: string; emoji?: string; keywords?: string[] }
   ): Promise<{ id: string; name: string } | null> {
     if (!this.userId) return null;
 
     try {
-      const sb = getSupabase();
-      const source = options?.source || "manual";
-      const metadata: Record<string, unknown> = {};
-      if (options?.emoji) {
-        metadata.openclaw = { emoji: options.emoji };
-      }
-      if (options?.variables && options.variables.length > 0) {
-        metadata.variables = options.variables;
-      }
-
-      const { data, error } = await sb.rpc("create_skill", {
-        p_user_id: this.userId,
-        p_name: name,
-        p_description: description,
-        p_content: content,
-        p_version: "1.0.0",
-        p_source: source,
-        p_emoji: options?.emoji || null,
-        p_keywords: options?.keywords || [],
-        p_metadata: metadata,
-      });
-
-      if (error) {
-        log.debug(`Skill create failed for "${name}": ${error.message}`);
-        return null;
-      }
+      const metadata = options?.emoji ? { openclaw: { emoji: options.emoji } } : {};
+
+      const data = await callMcpHandler<Record<string, unknown> | Record<string, unknown>[]>(
+        "skill.create",
+        {
+          name,
+          description,
+          content,
+          version: "1.0.0",
+          source: options?.source || "manual",
+          emoji: options?.emoji || null,
+          keywords: options?.keywords || [],
+          metadata,
+        },
+      );
 
       const row = (Array.isArray(data) ? data[0] : data) as Record<string, unknown> | null;
       if (!row) {
@@ -433,10 +336,29 @@ export class SkillManager {
         return null;
       }
 
-      // RPC returns out_id/out_name to avoid column ambiguity
       const id = (row.out_id || row.id) as string;
       const skillName = (row.out_name || row.name) as string;
 
+      // Add to in-memory map so the skill is immediately searchable
+      this.skills.set(skillName, {
+        name: skillName,
+        description,
+        version: "1.0.0",
+        userInvocable: true,
+        disableModelInvocation: false,
+        keywords: options?.keywords || [],
+        allowedTools: [],
+        argumentHint: "",
+        metadata: options?.emoji ? { emoji: options.emoji } : {},
+        homepage: "",
+        content,
+        filePath: "",
+        source: (options?.source as Skill["source"]) || "manual",
+        dbId: id,
+        invocationCount: 0,
+      });
+      this.invalidateCaches();
+
       log.info(`Skill "${skillName}" created in skills table (pending approval)`);
       return { id, name: skillName };
     } catch (err) {
@@ -445,63 +367,19 @@ export class SkillManager {
     }
   }
 
-  /**
-   * Add a skill to the user's active collection (agent_skills).
-   * Copies content from the skills table.
-   * This is the "approval" step — after this, the skill is usable.
-   */
   async addSkill(skillId: string): Promise<Skill | null> {
     if (!this.userId) return null;
 
     try {
-      const sb = getSupabase();
-
-      // Fetch from skills table
-      const { data: pub, error: fetchErr } = await sb
-        .from("skills")
-        .select("*")
-        .eq("id", skillId)
-        .eq("is_active", true)
-        .single();
-
-      if (fetchErr || !pub) {
-        log.debug(`Skill not found: ${skillId}`);
-        return null;
-      }
-
-      const row = pub as Record<string, unknown>;
-
-      // Add to user's agent_skills via upsert
-      const { data, error } = await sb.rpc("upsert_agent_skill", {
-        p_user_id: this.userId,
-        p_name: row.name as string,
-        p_description: (row.description as string) || "",
-        p_content: row.content as string,
-        p_version: (row.version as string) || "1.0.0",
-        p_source: (row.source as string) || "manual",
-        p_emoji: (row.emoji as string) || null,
-        p_keywords: (row.keywords as string[]) || [],
-        p_source_skill_id: skillId,
-      });
-
-      if (error) {
-        log.debug(`addSkill failed: ${error.message}`);
-        return null;
-      }
-
-      // Update install count on skills table (non-critical)
-      try {
-        await sb.rpc("increment_install_count", { p_skill_id: skillId });
-      } catch {
-        try {
-          await sb.from("skills")
-            .update({ install_count: (row.install_count as number || 0) + 1 })
-            .eq("id", skillId);
-        } catch { /* ignore */ }
-      }
-
-      // Add to in-memory map
-      const agentSkillRow = (data && typeof data === "object" ? data : row) as Record<string, unknown>;
+      const result = await callMcpHandler<{ skill: Record<string, unknown>; agent_skill: unknown }>(
+        "skill.fetch_and_add",
+        { skill_id: skillId },
+      );
+
+      const row = result.skill;
+      const agentSkillRow = (result.agent_skill && typeof result.agent_skill === "object"
+        ? result.agent_skill
+        : row) as Record<string, unknown>;
       const skill = this.rowToSkill({
         ...agentSkillRow,
         name: row.name,
@@ -510,7 +388,7 @@ export class SkillManager {
         source_skill_id: skillId,
       });
       this.skills.set(skill.name, skill);
-      this.buildIdfCache();
+      this.invalidateCaches();
 
       log.info(`Skill "${row.name}" added to user's collection`);
       return skill;
@@ -520,28 +398,18 @@ export class SkillManager {
     }
   }
 
-  /**
-   * Remove a skill from user's collection (soft-delete in agent_skills).
-   */
   remove(name: string): boolean {
     const skill = this.skills.get(name);
     if (!skill) return false;
-
     this.skills.delete(name);
-
-    // Mark inactive in DB (fire-and-forget)
+    this.invalidateCaches();
     this.removeFromDb(name).catch(() => {});
     return true;
   }
 
-  /**
-   * List skills with summary info.
-   */
   listFormatted(): string {
     const skills = this.getAll();
-    if (skills.length === 0) {
-      return "No skills in your collection.";
-    }
+    if (skills.length === 0) return "No skills in your collection.";
 
     return skills
       .map((s) => {
@@ -551,29 +419,15 @@ export class SkillManager {
       .join("\n\n");
   }
 
-  /**
-   * Check if a skill with a similar name already exists in user's collection.
-   */
   findSimilar(name: string): Skill | null {
-    // Exact match
     if (this.skills.has(name)) return this.skills.get(name)!;
 
-    // Fuzzy match: check if names overlap significantly
     const normalizedName = name.toLowerCase().replace(/[^a-z0-9]/g, "");
     for (const [existingName, skill] of this.skills) {
-      const normalizedExisting = existingName
-        .toLowerCase()
-        .replace(/[^a-z0-9]/g, "");
-
-      // One contains the other
-      if (
-        normalizedName.includes(normalizedExisting) ||
-        normalizedExisting.includes(normalizedName)
-      ) {
+      const normalizedExisting = existingName.toLowerCase().replace(/[^a-z0-9]/g, "");
+      if (normalizedName.includes(normalizedExisting) || normalizedExisting.includes(normalizedName)) {
         return skill;
       }
-
-      // High word overlap
       const nameWords = new Set(name.split("-"));
       const existingWords = new Set(existingName.split("-"));
       let overlap = 0;
@@ -584,45 +438,34 @@ export class SkillManager {
         return skill;
       }
     }
-
     return null;
   }
 
-  /**
-   * Update an existing skill in user's collection.
-   * Bumps the patch version automatically. Also updates skills table if user is author.
-   */
   update(name: string, newContent: string, description?: string): boolean {
     const skill = this.skills.get(name);
     if (!skill) return false;
 
-    // Bump patch version
     const versionParts = skill.version.split(".").map(Number);
     versionParts[2] = (versionParts[2] || 0) + 1;
     const newVersion = versionParts.join(".");
     const newDescription = description || skill.description;
 
-    // Update in-memory
     skill.content = newContent;
     skill.description = newDescription;
     skill.version = newVersion;
+    this.invalidateCaches();
 
-    // Persist to agent_skills (fire-and-forget)
     this.syncToAgentSkills(name, newDescription, newContent, newVersion, {
       source: "auto_improved",
     }).catch(() => {});
 
-    // Also update skills table if this skill has a source (fire-and-forget)
     if (skill.sourceSkillId && this.userId) {
-      const sb = getSupabase();
-      void (async () => {
-        try {
-          await sb.from("skills")
-            .update({ content: newContent, description: newDescription, version: newVersion })
-            .eq("id", skill.sourceSkillId!)
-            .eq("author_id", this.userId!);
-        } catch { /* non-critical */ }
-      })();
+      callMcpHandler("skill.update_source", {
+        source_skill_id: skill.sourceSkillId,
+        content: newContent,
+        description: newDescription,
+        version: newVersion,
+      }).catch(() => {});
     }
 
     log.info(`Skill "${name}" updated to v${newVersion}`);
@@ -631,10 +474,6 @@ export class SkillManager {
 
   // ── DB Integration ─────────────────────────────────────────────────
 
-  /**
-   * Persist a skill to agent_skills via upsert_agent_skill().
-   * Fire-and-forget: failures are logged but don't block.
-   */
   async syncToAgentSkills(
     name: string,
     description: string,
@@ -646,46 +485,26 @@ export class SkillManager {
       keywords?: string[];
       changeSummary?: string;
       sourceSkillId?: string;
-      variables?: SkillVariable[];
     }
   ): Promise<void> {
     if (!this.userId) return;
 
     try {
-      const sb = getSupabase();
-
-      // Store variables in metadata for agent_skills
-      const metadata: Record<string, unknown> = {};
-      if (options?.variables && options.variables.length > 0) {
-        metadata.variables = options.variables;
-      }
-
-      const { data, error } = await sb.rpc("upsert_agent_skill", {
-        p_user_id: this.userId,
-        p_name: name,
-        p_description: description,
-        p_content: content,
-        p_version: version,
-        p_source: options?.source || "manual",
-        p_emoji: options?.emoji || null,
-        p_keywords: options?.keywords || [],
-        p_change_summary: options?.changeSummary || null,
-        p_source_skill_id: options?.sourceSkillId || null,
-        p_metadata: Object.keys(metadata).length > 0 ? metadata : null,
+      const data = await callMcpHandler<Record<string, unknown> | null>("skill.upsert", {
+        name,
+        description,
+        content,
+        version,
+        source: options?.source || "manual",
+        emoji: options?.emoji || null,
+        keywords: options?.keywords || [],
+        change_summary: options?.changeSummary || null,
+        source_skill_id: options?.sourceSkillId || null,
       });
 
-      if (error) {
-        log.debug(`DB skill sync failed for "${name}": ${error.message}`);
-        return;
-      }
-
-      // Update in-memory skill with dbId and variables
       const skill = this.skills.get(name);
-      if (skill && data && typeof data === "object" && "id" in (data as Record<string, unknown>)) {
-        skill.dbId = (data as Record<string, unknown>).id as string;
-      }
-      if (skill && options?.variables) {
-        skill.variables = options.variables;
+      if (skill && data && typeof data === "object" && "id" in data) {
+        skill.dbId = data.id as string;
       }
 
       log.debug(`Skill "${name}" synced to agent_skills`);
@@ -694,10 +513,6 @@ export class SkillManager {
     }
   }
 
-  /**
-   * Log a skill invocation to agent_skill_invocations.
-   * Fire-and-forget: failures don't block task execution.
-   */
   async logInvocation(
     skillName: string,
     options?: {
@@ -718,29 +533,19 @@ export class SkillManager {
     }
 
     try {
-      const sb = getSupabase();
-      const { error } = await sb.from("agent_skill_invocations").insert({
+      await callMcpHandler("skill.log_invocation", {
         skill_id: skillDbId,
-        user_id: this.userId,
         message_id: options?.messageId || null,
         session_id: options?.sessionId || null,
         task_prompt: options?.taskPrompt?.slice(0, 500) || null,
         arguments: options?.arguments || null,
         success: options?.success ?? null,
       });
-
-      if (error) {
-        log.debug(`Invocation log failed: ${error.message}`);
-      }
     } catch (err) {
       log.debug(`Invocation log error: ${err}`);
     }
   }
 
-  /**
-   * Search user's skills in DB using full-text search.
-   * Falls back to in-memory findRelevant() if DB is unavailable.
-   */
   async searchDb(query: string, limit = 10): Promise<Array<{
     name: string;
     description: string;
@@ -748,19 +553,11 @@ export class SkillManager {
     source: string;
     invocationCount: number;
   }>> {
-    // Try DB search first
     if (this.userId) {
       try {
-        const sb = getSupabase();
-        const { data, error } = await sb.rpc("search_agent_skills", {
-          p_user_id: this.userId,
-          p_query: query,
-          p_limit: limit,
-        });
-
-        if (!error && data) {
-          const rows = data as Record<string, unknown>[];
-          return rows.map((row) => ({
+        const data = await callMcpHandler<Record<string, unknown>[]>("skill.search", { query, limit });
+        if (data) {
+          return data.map((row) => ({
             name: row.name as string,
             description: (row.description as string) || "",
             emoji: (row.emoji as string) || "",
@@ -768,12 +565,9 @@ export class SkillManager {
             invocationCount: (row.invocation_count as number) || 0,
           }));
         }
-      } catch {
-        // Fall through to in-memory search
-      }
+      } catch { /* Fall through to in-memory search */ }
     }
 
-    // Fallback: in-memory search
     const results = this.findRelevant(query, limit);
     return results.map((s) => ({
       name: s.name,
@@ -784,88 +578,52 @@ export class SkillManager {
     }));
   }
 
-  /**
-   * Remove a skill from DB (soft-delete).
-   */
   async removeFromDb(name: string): Promise<void> {
     if (!this.userId) return;
-
     try {
-      const sb = getSupabase();
-      await sb
-        .from("agent_skills")
-        .update({ is_active: false })
-        .eq("user_id", this.userId)
-        .eq("name", name);
-    } catch {
-      // Non-critical
-    }
+      await callMcpHandler("skill.remove", { name });
+    } catch { /* Non-critical */ }
   }
 
   // ── Marketplace ────────────────────────────────────────────────────
 
-  /**
-   * Publish a skill to the marketplace (sets is_public = true in skills table).
-   */
   async publish(
     name: string,
     options?: { category?: string; authorName?: string }
   ): Promise<{ id: string } | null> {
     if (!this.userId) return null;
-
     const skill = this.skills.get(name);
     if (!skill) return null;
-
     if (skill.source === "external") {
       log.debug(`Cannot publish external skill "${name}"`);
       return null;
     }
 
     try {
-      const sb = getSupabase();
-
-      // Upsert to skills table with is_public = true
-      const { data, error } = await sb
-        .from("skills")
-        .upsert(
-          {
-            name: skill.name,
-            description: skill.description,
-            version: skill.version,
-            emoji: skill.metadata.emoji || null,
-            content: skill.content,
-            argument_hint: skill.argumentHint || null,
-            keywords: skill.keywords,
-            allowed_tools: skill.allowedTools,
-            author_id: this.userId,
-            author_name: options?.authorName || null,
-            metadata: skill.metadata,
-            homepage: skill.homepage || null,
-            category: options?.category || null,
-            source: skill.source,
-            is_public: true,
-          },
-          { onConflict: "author_id,name" }
-        )
-        .select("id")
-        .single();
-
-      if (error) {
-        log.debug(`Publish failed for "${name}": ${error.message}`);
-        return null;
-      }
+      const data = await callMcpHandler<{ id: string }>("skill.publish", {
+        name: skill.name,
+        description: skill.description,
+        version: skill.version,
+        emoji: skill.metadata.emoji || null,
+        content: skill.content,
+        argument_hint: skill.argumentHint || null,
+        keywords: skill.keywords,
+        allowed_tools: skill.allowedTools,
+        author_name: options?.authorName || null,
+        metadata: skill.metadata,
+        homepage: skill.homepage || null,
+        category: options?.category || null,
+        source: skill.source,
+      });
 
       log.info(`Skill "${name}" published to marketplace`);
-      return data as { id: string };
+      return data;
     } catch (err) {
       log.debug(`Publish error: ${err}`);
       return null;
     }
   }
 
-  /**
-   * Browse marketplace skills (public + active).
-   */
   async browse(options?: {
     query?: string;
     category?: string;
@@ -885,18 +643,15 @@ export class SkillManager {
     ratingCount: number;
   }>> {
     try {
-      const sb = getSupabase();
-      const { data, error } = await sb.rpc("browse_skills", {
-        p_query: options?.query || null,
-        p_category: options?.category || null,
-        p_sort: options?.sort || "popular",
-        p_limit: options?.limit || 20,
-        p_offset: options?.offset || 0,
+      const data = await callMcpHandler<Record<string, unknown>[]>("skill.browse", {
+        query: options?.query || null,
+        category: options?.category || null,
+        sort: options?.sort || "popular",
+        limit: options?.limit || 20,
+        offset: options?.offset || 0,
       });
 
-      if (error || !data) return [];
-
-      return (data as Record<string, unknown>[]).map((r) => ({
+      return (data || []).map((r) => ({
         id: r.id as string,
         name: r.name as string,
         description: (r.description as string) || "",
@@ -912,93 +667,39 @@ export class SkillManager {
       return [];
     }
   }
-
-  // ── Variable Configuration ──────────────────────────────────────────
-
-  /**
-   * Update user-specific variable values (config) for a skill.
-   * Persists to agent_skills.config in DB and updates in-memory.
-   */
-  async updateConfig(
-    skillName: string,
-    config: Record<string, unknown>
-  ): Promise<boolean> {
-    const skill = this.skills.get(skillName);
-    if (!skill) return false;
-
-    // Merge with existing config
-    const merged = { ...(skill.config || {}), ...config };
-    skill.config = merged;
-
-    // Persist to DB
-    if (this.userId && skill.dbId) {
-      try {
-        const sb = getSupabase();
-        await sb
-          .from("agent_skills")
-          .update({ config: merged })
-          .eq("id", skill.dbId)
-          .eq("user_id", this.userId);
-        log.debug(`Config updated for skill "${skillName}"`);
-      } catch (err) {
-        log.debug(`Config update failed for "${skillName}": ${err}`);
-      }
-    }
-
-    return true;
-  }
-
-  /**
-   * Get the unresolved (unconfigured) variables for a skill.
-   * Returns variables that are required but have no value in config.
-   */
-  getUnconfiguredVariables(skillName: string): SkillVariable[] {
-    const skill = this.skills.get(skillName);
-    if (!skill?.variables) return [];
-
-    return skill.variables.filter((v) => {
-      if (!v.required) return false;
-      const value = skill.config?.[v.name];
-      return value === undefined || value === null || value === "";
-    });
-  }
 }
 
 // ── Exported Utility Functions ─────────────────────────────────────
 
 /**
- * Substitute {{variable_name}} placeholders in skill content with user config values.
- * Also handles array values by joining with ", ".
- *
- * Unresolved variables are left as-is with a note: {{variable_name: [NOT CONFIGURED]}}
+ * Validate a skill name against the Agent Skills spec:
+ * 1-64 chars, lowercase kebab-case (a-z, 0-9, hyphens),
+ * no leading/trailing/consecutive hyphens.
+ * Returns null if valid, or an error message if invalid.
  */
-export function substituteVariables(
-  content: string,
-  config: Record<string, unknown> | undefined,
-  variables?: SkillVariable[]
-): string {
-  if (!content.includes("{{")) return content;
-
-  return content.replace(/\{\{(\w+)\}\}/g, (match, varName: string) => {
-    const value = config?.[varName];
-
-    if (value !== undefined && value !== null) {
-      if (Array.isArray(value)) return value.join(", ");
-      return String(value);
-    }
-
-    // Check for default value in variable definitions
-    const varDef = variables?.find((v) => v.name === varName);
-    if (varDef?.default !== undefined) return varDef.default;
-
-    // Leave as-is with warning for unresolved
-    return `{{${varName}: [NOT CONFIGURED]}}`;
-  });
+export function validateSkillName(name: string): string | null {
+  if (!name || name.length === 0) return "name is empty";
+  if (name.length > 64) return `name too long (${name.length}/64 chars)`;
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(name)) {
+    return `name must be lowercase kebab-case (a-z, 0-9, hyphens), no leading/trailing/consecutive hyphens. Got: "${name}"`;
+  }
+  return null;
 }
 
 /**
- * Substitute $ARGUMENTS, $ARGUMENTS[N], and $N placeholders in skill content.
+ * Normalize a skill name to valid kebab-case.
+ * Converts to lowercase, replaces non-alphanumeric with hyphens,
+ * collapses consecutive hyphens, trims, and truncates to 64 chars.
  */
+export function normalizeSkillName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .replace(/-{2,}/g, "-")
+    .slice(0, 64);
+}
+
 export function substituteArguments(content: string, args: string): string {
   const parts = args.split(/\s+/);
   content = content.replace(/\$ARGUMENTS/g, args);
@@ -1007,10 +708,6 @@ export function substituteArguments(content: string, args: string): string {
   return content;
 }
 
-/**
- * Preprocess dynamic context in skill content.
- * Replaces !`command` patterns with the command's stdout.
- */
 export function preprocessDynamicContext(content: string, cwd?: string): string {
   return content.replace(/!`([^`]+)`/g, (_, cmd) => {
     try {