@vellumai/assistant 0.4.11 → 0.4.13

package/src/daemon/handlers/skills.ts

@@ -1,15 +1,40 @@
-import { existsSync, rmSync } from 'node:fs';
-import * as net from 'node:net';
-import { join } from 'node:path';
-
-import { getConfig, invalidateConfigCache,loadRawConfig, saveRawConfig } from '../../config/loader.js';
-import { resolveSkillStates } from '../../config/skill-state.js';
-import { ensureSkillIcon,loadSkillBySelector, loadSkillCatalog, type SkillSummary } from '../../config/skills.js';
-import { createTimeout,extractText, getConfiguredProvider, userMessage } from '../../providers/provider-send-message.js';
-import { clawhubCheckUpdates, clawhubInspect, clawhubInstall, clawhubSearch, type ClawhubSearchResultItem,clawhubUpdate } from '../../skills/clawhub.js';
-import { createManagedSkill,deleteManagedSkill, removeSkillsIndexEntry, validateManagedSkillId } from '../../skills/managed-store.js';
-import { checkVellumSkill,installFromVellumCatalog, listCatalogEntries } from '../../tools/skills/vellum-catalog.js';
-import { getWorkspaceSkillsDir } from '../../util/platform.js';
+import { existsSync, rmSync } from "node:fs";
+import * as net from "node:net";
+import { join } from "node:path";
+
+import {
+  getConfig,
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+} from "../../config/loader.js";
+import { resolveSkillStates } from "../../config/skill-state.js";
+import {
+  ensureSkillIcon,
+  loadSkillBySelector,
+  loadSkillCatalog,
+  type SkillSummary,
+} from "../../config/skills.js";
+import {
+  createTimeout,
+  extractText,
+  getConfiguredProvider,
+  userMessage,
+} from "../../providers/provider-send-message.js";
+import {
+  clawhubCheckUpdates,
+  clawhubInspect,
+  clawhubInstall,
+  clawhubSearch,
+  clawhubUpdate,
+} from "../../skills/clawhub.js";
+import {
+  createManagedSkill,
+  deleteManagedSkill,
+  removeSkillsIndexEntry,
+  validateManagedSkillId,
+} from "../../skills/managed-store.js";
+import { getWorkspaceSkillsDir } from "../../util/platform.js";
 import type {
   SkillDetailRequest,
   SkillsCheckUpdatesRequest,
@@ -23,52 +48,65 @@ import type {
   SkillsSearchRequest,
   SkillsUninstallRequest,
   SkillsUpdateRequest,
-} from '../ipc-protocol.js';
-import { CONFIG_RELOAD_DEBOUNCE_MS, defineHandlers, ensureSkillEntry, type HandlerContext,log } from './shared.js';
+} from "../ipc-protocol.js";
+import {
+  CONFIG_RELOAD_DEBOUNCE_MS,
+  defineHandlers,
+  ensureSkillEntry,
+  type HandlerContext,
+  log,
+} from "./shared.js";
 
 // ─── Provenance resolution ──────────────────────────────────────────────────
 
 interface SkillProvenance {
-  kind: 'first-party' | 'third-party' | 'local';
+  kind: "first-party" | "third-party" | "local";
   provider?: string;
   originId?: string;
   sourceUrl?: string;
 }
 
-const CLAWHUB_BASE_URL = 'https://skills.sh';
+const CLAWHUB_BASE_URL = "https://skills.sh";
 
 function resolveProvenance(summary: SkillSummary): SkillProvenance {
   // Bundled skills are always first-party (shipped with Vellum)
-  if (summary.source === 'bundled') {
-    return { kind: 'first-party', provider: 'Vellum' };
+  if (summary.source === "bundled") {
+    return { kind: "first-party", provider: "Vellum" };
   }
 
-  // Managed skills could be either first-party (installed from Vellum catalog)
-  // or third-party (installed from clawhub). The homepage field serves as a
-  // heuristic: Vellum catalog skills don't typically have a clawhub homepage.
-  if (summary.source === 'managed') {
-    if (summary.homepage?.includes('skills.sh') || summary.homepage?.includes('clawhub')) {
+  // Managed skills are third-party (installed from clawhub). The homepage field
+  // confirms provenance.
+  if (summary.source === "managed") {
+    if (
+      summary.homepage?.includes("skills.sh") ||
+      summary.homepage?.includes("clawhub")
+    ) {
       return {
-        kind: 'third-party',
-        provider: 'skills.sh',
+        kind: "third-party",
+        provider: "skills.sh",
         originId: summary.id,
-        sourceUrl: summary.homepage ?? `${CLAWHUB_BASE_URL}/skills/${encodeURIComponent(summary.id)}`,
+        sourceUrl:
+          summary.homepage ??
+          `${CLAWHUB_BASE_URL}/skills/${encodeURIComponent(summary.id)}`,
       };
     }
-    // No positive evidence of origin -- could be user-authored or from Vellum catalog.
-    // Default to "local" to avoid mislabeling user-created skills as first-party.
-    return { kind: 'local' };
+    // No positive evidence of clawhub origin -- likely user-authored.
+    // Default to "local" to avoid mislabeling.
+    return { kind: "local" };
   }
 
   // Workspace and extra skills are user-provided
-  if (summary.source === 'workspace' || summary.source === 'extra') {
-    return { kind: 'local' };
+  if (summary.source === "workspace" || summary.source === "extra") {
+    return { kind: "local" };
   }
 
-  return { kind: 'local' };
+  return { kind: "local" };
 }
 
-export function handleSkillsList(socket: net.Socket, ctx: HandlerContext): void {
+export function handleSkillsList(
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
   const config = getConfig();
   const catalog = loadSkillCatalog();
   const resolved = resolveSkillStates(catalog, config);
@@ -80,7 +118,10 @@ export function handleSkillsList(socket: net.Socket, ctx: HandlerContext): void
     emoji: r.summary.emoji,
     homepage: r.summary.homepage,
     source: r.summary.source,
-    state: (r.state === 'degraded' ? 'enabled' : r.state) as 'enabled' | 'disabled' | 'available',
+    state: (r.state === "degraded" ? "enabled" : r.state) as
+      | "enabled"
+      | "disabled"
+      | "available",
     degraded: r.degraded,
     missingRequirements: r.missingRequirements,
     updateAvailable: false,
@@ -88,7 +129,7 @@ export function handleSkillsList(socket: net.Socket, ctx: HandlerContext): void
     provenance: resolveProvenance(r.summary),
   }));
 
-  ctx.send(socket, { type: 'skills_list_response', skills });
+  ctx.send(socket, { type: "skills_list_response", skills });
 }
 
 export function handleSkillsEnable(
@@ -109,26 +150,32 @@ export function handleSkillsEnable(
     }
     invalidateConfigCache();
 
-    ctx.debounceTimers.schedule('__suppress_reset__', () => { ctx.setSuppressConfigReload(false); }, CONFIG_RELOAD_DEBOUNCE_MS);
+    ctx.debounceTimers.schedule(
+      "__suppress_reset__",
+      () => {
+        ctx.setSuppressConfigReload(false);
+      },
+      CONFIG_RELOAD_DEBOUNCE_MS,
+    );
 
     ctx.updateConfigFingerprint();
 
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'enable',
+      type: "skills_operation_response",
+      operation: "enable",
       success: true,
     });
     ctx.broadcast({
-      type: 'skills_state_changed',
+      type: "skills_state_changed",
       name: msg.name,
-      state: 'enabled',
+      state: "enabled",
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, 'Failed to enable skill');
+    log.error({ err }, "Failed to enable skill");
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'enable',
+      type: "skills_operation_response",
+      operation: "enable",
       success: false,
       error: message,
     });
@@ -153,26 +200,32 @@ export function handleSkillsDisable(
     }
     invalidateConfigCache();
 
-    ctx.debounceTimers.schedule('__suppress_reset__', () => { ctx.setSuppressConfigReload(false); }, CONFIG_RELOAD_DEBOUNCE_MS);
+    ctx.debounceTimers.schedule(
+      "__suppress_reset__",
+      () => {
+        ctx.setSuppressConfigReload(false);
+      },
+      CONFIG_RELOAD_DEBOUNCE_MS,
+    );
 
     ctx.updateConfigFingerprint();
 
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'disable',
+      type: "skills_operation_response",
+      operation: "disable",
       success: true,
     });
     ctx.broadcast({
-      type: 'skills_state_changed',
+      type: "skills_state_changed",
       name: msg.name,
-      state: 'disabled',
+      state: "disabled",
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, 'Failed to disable skill');
+    log.error({ err }, "Failed to disable skill");
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'disable',
+      type: "skills_operation_response",
+      operation: "disable",
       success: false,
       error: message,
     });
@@ -207,21 +260,27 @@ export function handleSkillsConfigure(
     }
     invalidateConfigCache();
 
-    ctx.debounceTimers.schedule('__suppress_reset__', () => { ctx.setSuppressConfigReload(false); }, CONFIG_RELOAD_DEBOUNCE_MS);
+    ctx.debounceTimers.schedule(
+      "__suppress_reset__",
+      () => {
+        ctx.setSuppressConfigReload(false);
+      },
+      CONFIG_RELOAD_DEBOUNCE_MS,
+    );
 
     ctx.updateConfigFingerprint();
 
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'configure',
+      type: "skills_operation_response",
+      operation: "configure",
       success: true,
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, 'Failed to configure skill');
+    log.error({ err }, "Failed to configure skill");
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'configure',
+      type: "skills_operation_response",
+      operation: "configure",
       success: false,
       error: message,
     });
@@ -234,39 +293,33 @@ export async function handleSkillsInstall(
   ctx: HandlerContext,
 ): Promise<void> {
   try {
-    // Check if the slug matches a vellum-skills catalog entry first
-    const isVellumSkill = await checkVellumSkill(msg.slug);
-
-    let skillId: string;
+    // Bundled skills are already available — no install needed
+    const catalog = loadSkillCatalog();
+    const bundled = catalog.find(
+      (s) => s.id === msg.slug && s.source === "bundled",
+    );
+    if (bundled) {
+      ctx.send(socket, {
+        type: "skills_operation_response",
+        operation: "install",
+        success: true,
+      });
+      return;
+    }
 
-    if (isVellumSkill) {
-      // Install from vellum-skills catalog (remote with bundled fallback)
-      const result = await installFromVellumCatalog(msg.slug);
-      if (!result.success) {
-        ctx.send(socket, {
-          type: 'skills_operation_response',
-          operation: 'install',
-          success: false,
-          error: result.error ?? 'Unknown error',
-        });
-        return;
-      }
-      skillId = result.skillName ?? msg.slug;
-    } else {
-      // Install from clawhub (community)
-      const result = await clawhubInstall(msg.slug, { version: msg.version });
-      if (!result.success) {
-        ctx.send(socket, {
-          type: 'skills_operation_response',
-          operation: 'install',
-          success: false,
-          error: result.error ?? 'Unknown error',
-        });
-        return;
-      }
-      const rawId = result.skillName ?? msg.slug;
-      skillId = rawId.includes('/') ? rawId.split('/').pop()! : rawId;
+    // Install from clawhub (community)
+    const result = await clawhubInstall(msg.slug, { version: msg.version });
+    if (!result.success) {
+      ctx.send(socket, {
+        type: "skills_operation_response",
+        operation: "install",
+        success: false,
+        error: result.error ?? "Unknown error",
+      });
+      return;
     }
+    const rawId = result.skillName ?? msg.slug;
+    const skillId = rawId.includes("/") ? rawId.split("/").pop()! : rawId;
 
     // Reload skill catalog so the newly installed skill is picked up
     loadSkillCatalog();
@@ -283,28 +336,34 @@ export async function handleSkillsInstall(
         throw err;
       }
       invalidateConfigCache();
-      ctx.debounceTimers.schedule('__suppress_reset__', () => { ctx.setSuppressConfigReload(false); }, CONFIG_RELOAD_DEBOUNCE_MS);
+      ctx.debounceTimers.schedule(
+        "__suppress_reset__",
+        () => {
+          ctx.setSuppressConfigReload(false);
+        },
+        CONFIG_RELOAD_DEBOUNCE_MS,
+      );
       ctx.updateConfigFingerprint();
     } catch (err) {
-      log.warn({ err, skillId }, 'Failed to auto-enable installed skill');
+      log.warn({ err, skillId }, "Failed to auto-enable installed skill");
     }
 
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'install',
+      type: "skills_operation_response",
+      operation: "install",
       success: true,
     });
     ctx.broadcast({
-      type: 'skills_state_changed',
+      type: "skills_state_changed",
       name: skillId,
-      state: 'enabled',
+      state: "enabled",
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, 'Failed to install skill');
+    log.error({ err }, "Failed to install skill");
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'install',
+      type: "skills_operation_response",
+      operation: "install",
       success: false,
       error: message,
     });
@@ -317,14 +376,19 @@ export async function handleSkillsUninstall(
   ctx: HandlerContext,
 ): Promise<void> {
   // Validate skill name to prevent path traversal while allowing namespaced slugs (org/name)
-  const validNamespacedSlug = /^[a-zA-Z0-9][a-zA-Z0-9._-]*\/[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+  const validNamespacedSlug =
+    /^[a-zA-Z0-9][a-zA-Z0-9._-]*\/[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
   const validSimpleName = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-  if (msg.name.includes('..') || msg.name.includes('\\') || !(validSimpleName.test(msg.name) || validNamespacedSlug.test(msg.name))) {
+  if (
+    msg.name.includes("..") ||
+    msg.name.includes("\\") ||
+    !(validSimpleName.test(msg.name) || validNamespacedSlug.test(msg.name))
+  ) {
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'uninstall',
+      type: "skills_operation_response",
+      operation: "uninstall",
       success: false,
-      error: 'Invalid skill name',
+      error: "Invalid skill name",
     });
     return;
   }
@@ -336,10 +400,10 @@ export async function handleSkillsUninstall(
       const result = deleteManagedSkill(msg.name);
       if (!result.deleted) {
         ctx.send(socket, {
-          type: 'skills_operation_response',
-          operation: 'uninstall',
+          type: "skills_operation_response",
+          operation: "uninstall",
           success: false,
-          error: result.error ?? 'Failed to delete managed skill',
+          error: result.error ?? "Failed to delete managed skill",
         });
         return;
       }
@@ -348,15 +412,19 @@ export async function handleSkillsUninstall(
       const skillDir = join(getWorkspaceSkillsDir(), msg.name);
       if (!existsSync(skillDir)) {
         ctx.send(socket, {
-          type: 'skills_operation_response',
-          operation: 'uninstall',
+          type: "skills_operation_response",
+          operation: "uninstall",
           success: false,
-          error: 'Skill not found',
+          error: "Skill not found",
         });
         return;
       }
       rmSync(skillDir, { recursive: true });
-      try { removeSkillsIndexEntry(msg.name); } catch { /* best effort */ }
+      try {
+        removeSkillsIndexEntry(msg.name);
+      } catch {
+        /* best effort */
+      }
     }
 
     // Clean config entry
@@ -375,27 +443,33 @@ export async function handleSkillsUninstall(
       }
       invalidateConfigCache();
 
-      ctx.debounceTimers.schedule('__suppress_reset__', () => { ctx.setSuppressConfigReload(false); }, CONFIG_RELOAD_DEBOUNCE_MS);
+      ctx.debounceTimers.schedule(
+        "__suppress_reset__",
+        () => {
+          ctx.setSuppressConfigReload(false);
+        },
+        CONFIG_RELOAD_DEBOUNCE_MS,
+      );
 
       ctx.updateConfigFingerprint();
     }
 
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'uninstall',
+      type: "skills_operation_response",
+      operation: "uninstall",
       success: true,
     });
     ctx.broadcast({
-      type: 'skills_state_changed',
+      type: "skills_state_changed",
       name: msg.name,
-      state: 'uninstalled',
+      state: "uninstalled",
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, 'Failed to uninstall skill');
+    log.error({ err }, "Failed to uninstall skill");
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'uninstall',
+      type: "skills_operation_response",
+      operation: "uninstall",
       success: false,
       error: message,
     });
@@ -411,10 +485,10 @@ export async function handleSkillsUpdate(
     const result = await clawhubUpdate(msg.name);
     if (!result.success) {
       ctx.send(socket, {
-        type: 'skills_operation_response',
-        operation: 'update',
+        type: "skills_operation_response",
+        operation: "update",
         success: false,
-        error: result.error ?? 'Unknown error',
+        error: result.error ?? "Unknown error",
       });
       return;
     }
@@ -423,16 +497,16 @@ export async function handleSkillsUpdate(
     loadSkillCatalog();
 
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'update',
+      type: "skills_operation_response",
+      operation: "update",
       success: true,
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, 'Failed to update skill');
+    log.error({ err }, "Failed to update skill");
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'update',
+      type: "skills_operation_response",
+      operation: "update",
       success: false,
       error: message,
     });
@@ -447,17 +521,17 @@ export async function handleSkillsCheckUpdates(
   try {
     const updates = await clawhubCheckUpdates();
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'check_updates',
+      type: "skills_operation_response",
+      operation: "check_updates",
       success: true,
       data: updates,
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, 'Failed to check for skill updates');
+    log.error({ err }, "Failed to check for skill updates");
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'check_updates',
+      type: "skills_operation_response",
+      operation: "check_updates",
       success: false,
       error: message,
     });
@@ -470,43 +544,20 @@ export async function handleSkillsSearch(
   ctx: HandlerContext,
 ): Promise<void> {
   try {
-    // Search vellum-skills catalog (platform API with bundled fallback)
-    const catalogEntries = await listCatalogEntries();
-    const query = (msg.query ?? '').toLowerCase();
-    const matchingCatalog = catalogEntries.filter((e) => {
-      if (!query) return true;
-      return e.name.toLowerCase().includes(query) || e.description.toLowerCase().includes(query) || e.id.toLowerCase().includes(query);
-    });
-    const vellumSkills: ClawhubSearchResultItem[] = matchingCatalog.map((e) => ({
-      name: e.name,
-      slug: e.id,
-      description: e.description,
-      author: 'Vellum',
-      stars: 0,
-      installs: 0,
-      version: '',
-      createdAt: 0,
-      source: 'vellum' as const,
-    }));
-
-    // Search clawhub concurrently
-    const clawhubResult = await clawhubSearch(msg.query);
-
-    // Merge: vellum first, then clawhub
-    const merged = { skills: [...vellumSkills, ...clawhubResult.skills] };
+    const result = await clawhubSearch(msg.query);
 
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'search',
+      type: "skills_operation_response",
+      operation: "search",
       success: true,
-      data: merged,
+      data: result,
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, 'Failed to search skills');
+    log.error({ err }, "Failed to search skills");
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'search',
+      type: "skills_operation_response",
+      operation: "search",
       success: false,
       error: message,
     });
@@ -521,16 +572,16 @@ export async function handleSkillsInspect(
   try {
     const result = await clawhubInspect(msg.slug);
     ctx.send(socket, {
-      type: 'skills_inspect_response',
+      type: "skills_inspect_response",
       slug: msg.slug,
       ...(result.data ? { data: result.data } : {}),
       ...(result.error ? { error: result.error } : {}),
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, 'Failed to inspect skill');
+    log.error({ err }, "Failed to inspect skill");
     ctx.send(socket, {
-      type: 'skills_inspect_response',
+      type: "skills_inspect_response",
       slug: msg.slug,
       error: message,
     });
@@ -544,19 +595,23 @@ export async function handleSkillDetail(
 ): Promise<void> {
   const result = loadSkillBySelector(msg.skillId);
   if (result.skill) {
-    const icon = await ensureSkillIcon(result.skill.directoryPath, result.skill.name, result.skill.description);
+    const icon = await ensureSkillIcon(
+      result.skill.directoryPath,
+      result.skill.name,
+      result.skill.description,
+    );
     ctx.send(socket, {
-      type: 'skill_detail_response',
+      type: "skill_detail_response",
       skillId: result.skill.id,
       body: result.skill.body,
       ...(icon ? { icon } : {}),
     });
   } else {
     ctx.send(socket, {
-      type: 'skill_detail_response',
+      type: "skill_detail_response",
       skillId: msg.skillId,
-      body: '',
-      error: result.error ?? 'Skill not found',
+      body: "",
+      error: result.error ?? "Skill not found",
     });
   }
 }
@@ -578,7 +633,7 @@ function parseFrontmatter(sourceText: string): ParsedFrontmatter {
   if (!match) return { body: sourceText };
 
   const yamlBlock = match[1];
-  const body = match[2].replace(/\r\n/g, '\n');
+  const body = match[2].replace(/\r\n/g, "\n");
 
   const result: ParsedFrontmatter = { body };
 
@@ -589,22 +644,25 @@ function parseFrontmatter(sourceText: string): ParsedFrontmatter {
     const key = kvMatch[1];
     // Strip surrounding quotes
     let value = kvMatch[2].trim();
-    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
       value = value.slice(1, -1);
     }
     switch (key) {
-      case 'skill-id':
-      case 'skillId':
-      case 'id':
+      case "skill-id":
+      case "skillId":
+      case "id":
         result.skillId = value;
         break;
-      case 'name':
+      case "name":
         result.name = value;
         break;
-      case 'description':
+      case "description":
         result.description = value;
         break;
-      case 'emoji':
+      case "emoji":
         result.emoji = value;
         break;
     }
@@ -618,22 +676,28 @@ function parseFrontmatter(sourceText: string): ParsedFrontmatter {
 function toSkillSlug(raw: string): string {
   return raw
     .toLowerCase()
-    .replace(/[^a-z0-9._-]+/g, '-')  // replace non-valid chars with hyphens
-    .replace(/^[^a-z0-9]+/, '')        // must start with alphanumeric
-    .replace(/-+/g, '-')              // collapse multiple hyphens
+    .replace(/[^a-z0-9._-]+/g, "-") // replace non-valid chars with hyphens
+    .replace(/^[^a-z0-9]+/, "") // must start with alphanumeric
+    .replace(/-+/g, "-") // collapse multiple hyphens
     .slice(0, 50)
-    .replace(/-$/, '');               // no trailing hyphen (after truncation)
+    .replace(/-$/, ""); // no trailing hyphen (after truncation)
 }
 
 // ─── Deterministic heuristic draft ───────────────────────────────────────────
 
-function heuristicDraft(body: string): { skillId: string; name: string; description: string; emoji: string } {
-  const lines = body.split('\n').filter((l) => l.trim());
-  const firstLine = lines[0]?.trim() ?? '';
-  const name = firstLine.replace(/^#+\s*/, '').slice(0, 100) || 'Untitled Skill';
-  const skillId = toSkillSlug(name) || 'untitled-skill';
-  const description = body.trim().slice(0, 200) || 'No description provided';
-  return { skillId, name, description, emoji: '\u{1F4DD}' };
+function heuristicDraft(body: string): {
+  skillId: string;
+  name: string;
+  description: string;
+  emoji: string;
+} {
+  const lines = body.split("\n").filter((l) => l.trim());
+  const firstLine = lines[0]?.trim() ?? "";
+  const name =
+    firstLine.replace(/^#+\s*/, "").slice(0, 100) || "Untitled Skill";
+  const skillId = toSkillSlug(name) || "untitled-skill";
+  const description = body.trim().slice(0, 200) || "No description provided";
+  return { skillId, name, description, emoji: "\u{1F4DD}" };
 }
 
 // ─── Draft handler ───────────────────────────────────────────────────────────
@@ -654,10 +718,10 @@ export async function handleSkillsDraft(
 
     // Determine which fields still need filling
     const missing: string[] = [];
-    if (!skillId) missing.push('skillId');
-    if (!name) missing.push('name');
-    if (!description) missing.push('description');
-    if (!emoji) missing.push('emoji');
+    if (!skillId) missing.push("skillId");
+    if (!name) missing.push("name");
+    if (!description) missing.push("description");
+    if (!emoji) missing.push("emoji");
 
     // Attempt LLM generation for missing fields
     if (missing.length > 0) {
@@ -668,23 +732,26 @@ export async function handleSkillsDraft(
           const { signal, cleanup } = createTimeout(LLM_DRAFT_TIMEOUT_MS);
           try {
             const prompt = [
-              'Given the following skill body text, generate metadata for a managed skill.',
-              `Return ONLY valid JSON with these fields: ${missing.join(', ')}.`,
-              'Field descriptions:',
-              '- skillId: a short kebab-case identifier (lowercase, alphanumeric + hyphens/dots/underscores, max 50 chars, must start with a letter or digit)',
-              '- name: a human-readable name (max 100 chars)',
-              '- description: a brief one-line description (max 200 chars)',
-              '- emoji: a single emoji character representing the skill',
-              '',
-              'Skill body:',
+              "Given the following skill body text, generate metadata for a managed skill.",
+              `Return ONLY valid JSON with these fields: ${missing.join(", ")}.`,
+              "Field descriptions:",
+              "- skillId: a short kebab-case identifier (lowercase, alphanumeric + hyphens/dots/underscores, max 50 chars, must start with a letter or digit)",
+              "- name: a human-readable name (max 100 chars)",
+              "- description: a brief one-line description (max 200 chars)",
+              "- emoji: a single emoji character representing the skill",
+              "",
+              "Skill body:",
               body.slice(0, 2000),
-            ].join('\n');
+            ].join("\n");
 
             const response = await provider.sendMessage(
               [userMessage(prompt)],
               [],
               undefined,
-              { config: { modelIntent: 'latency-optimized', max_tokens: 256 }, signal },
+              {
+                config: { modelIntent: "latency-optimized", max_tokens: 256 },
+                signal,
+              },
             );
             cleanup();
 
@@ -693,41 +760,62 @@ export async function handleSkillsDraft(
             const jsonMatch = /\{[\s\S]*?\}/.exec(responseText);
             if (jsonMatch) {
               const generated = JSON.parse(jsonMatch[0]);
-              if (typeof generated === 'object' && generated) {
-                if (!skillId && typeof generated.skillId === 'string') skillId = generated.skillId;
-                if (!name && typeof generated.name === 'string') name = generated.name;
-                if (!description && typeof generated.description === 'string') description = generated.description;
-                if (!emoji && typeof generated.emoji === 'string') emoji = generated.emoji;
+              if (typeof generated === "object" && generated) {
+                if (!skillId && typeof generated.skillId === "string")
+                  skillId = generated.skillId;
+                if (!name && typeof generated.name === "string")
+                  name = generated.name;
+                if (!description && typeof generated.description === "string")
+                  description = generated.description;
+                if (!emoji && typeof generated.emoji === "string")
+                  emoji = generated.emoji;
                 llmGenerated = true;
               }
             }
           } catch (err) {
             cleanup();
-            log.warn({ err }, 'LLM draft generation failed, falling back to heuristic');
-            warnings.push('LLM draft generation failed, used heuristic fallback');
+            log.warn(
+              { err },
+              "LLM draft generation failed, falling back to heuristic",
+            );
+            warnings.push(
+              "LLM draft generation failed, used heuristic fallback",
+            );
           }
         } else {
-          warnings.push('No LLM provider available, used heuristic fallback');
+          warnings.push("No LLM provider available, used heuristic fallback");
         }
       } catch (err) {
-        log.warn({ err }, 'Provider resolution failed for draft generation');
-        warnings.push('Provider resolution failed, used heuristic fallback');
+        log.warn({ err }, "Provider resolution failed for draft generation");
+        warnings.push("Provider resolution failed, used heuristic fallback");
       }
 
       // Fall back to heuristic for any fields still missing
       if (!skillId || !name || !description || !emoji) {
         const heuristic = heuristicDraft(body);
-        if (!skillId) { skillId = heuristic.skillId; if (!llmGenerated) warnings.push('skillId derived from heuristic'); }
-        if (!name) { name = heuristic.name; if (!llmGenerated) warnings.push('name derived from heuristic'); }
-        if (!description) { description = heuristic.description; if (!llmGenerated) warnings.push('description derived from heuristic'); }
-        if (!emoji) { emoji = heuristic.emoji; }
+        if (!skillId) {
+          skillId = heuristic.skillId;
+          if (!llmGenerated) warnings.push("skillId derived from heuristic");
+        }
+        if (!name) {
+          name = heuristic.name;
+          if (!llmGenerated) warnings.push("name derived from heuristic");
+        }
+        if (!description) {
+          description = heuristic.description;
+          if (!llmGenerated)
+            warnings.push("description derived from heuristic");
+        }
+        if (!emoji) {
+          emoji = heuristic.emoji;
+        }
       }
     }
 
     // Normalize skillId to valid managed-skill slug format
     const originalId = skillId!;
     skillId = toSkillSlug(originalId);
-    if (!skillId) skillId = 'untitled-skill';
+    if (!skillId) skillId = "untitled-skill";
     if (skillId !== originalId) {
       warnings.push(`skillId normalized from "${originalId}" to "${skillId}"`);
     }
@@ -735,12 +823,15 @@ export async function handleSkillsDraft(
     // Final validation pass
     const validationError = validateManagedSkillId(skillId);
     if (validationError) {
-      skillId = toSkillSlug(skillId.replace(/[^a-z0-9]/g, '-')) || 'untitled-skill';
-      warnings.push(`skillId re-normalized due to validation: ${validationError}`);
+      skillId =
+        toSkillSlug(skillId.replace(/[^a-z0-9]/g, "-")) || "untitled-skill";
+      warnings.push(
+        `skillId re-normalized due to validation: ${validationError}`,
+      );
     }
 
     ctx.send(socket, {
-      type: 'skills_draft_response',
+      type: "skills_draft_response",
       success: true,
       draft: {
         skillId: skillId!,
@@ -753,9 +844,9 @@ export async function handleSkillsDraft(
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, 'Failed to generate skill draft');
+    log.error({ err }, "Failed to generate skill draft");
     ctx.send(socket, {
-      type: 'skills_draft_response',
+      type: "skills_draft_response",
       success: false,
       error: message,
     });
@@ -783,10 +874,10 @@ export async function handleSkillsCreate(
 
     if (!result.created) {
       ctx.send(socket, {
-        type: 'skills_operation_response',
-        operation: 'create',
+        type: "skills_operation_response",
+        operation: "create",
         success: false,
-        error: result.error ?? 'Failed to create managed skill',
+        error: result.error ?? "Failed to create managed skill",
       });
       return;
     }
@@ -804,31 +895,40 @@ export async function handleSkillsCreate(
         throw err;
       }
       invalidateConfigCache();
-      ctx.debounceTimers.schedule('__suppress_reset__', () => { ctx.setSuppressConfigReload(false); }, CONFIG_RELOAD_DEBOUNCE_MS);
+      ctx.debounceTimers.schedule(
+        "__suppress_reset__",
+        () => {
+          ctx.setSuppressConfigReload(false);
+        },
+        CONFIG_RELOAD_DEBOUNCE_MS,
+      );
       ctx.updateConfigFingerprint();
       autoEnabled = true;
     } catch (err) {
-      log.warn({ err, skillId: msg.skillId }, 'Failed to auto-enable created skill');
+      log.warn(
+        { err, skillId: msg.skillId },
+        "Failed to auto-enable created skill",
+      );
     }
 
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'create',
+      type: "skills_operation_response",
+      operation: "create",
       success: true,
     });
     if (autoEnabled) {
       ctx.broadcast({
-        type: 'skills_state_changed',
+        type: "skills_state_changed",
         name: msg.skillId,
-        state: 'enabled',
+        state: "enabled",
       });
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, 'Failed to create skill');
+    log.error({ err }, "Failed to create skill");
     ctx.send(socket, {
-      type: 'skills_operation_response',
-      operation: 'create',
+      type: "skills_operation_response",
+      operation: "create",
       success: false,
       error: message,
     });