@polderlabs/bizar 4.4.13 → 4.5.1

package/bizar-dash/src/server/serve-info.mjs

@@ -60,12 +60,27 @@ import { createConnection, isIP } from 'node:net';
 const HOME = homedir();
 
 // Mirrors plugins/bizar/src/serve-info.ts → BG_DIRS pattern.
-const SERVE_INFO_FILES = [
+const DEFAULT_SERVE_INFO_FILES = [
   join(HOME, '.cache', 'bizar', 'serve.json'),
   join(HOME, '.config', 'opencode', 'serve.json'),
   join(HOME, '.bizar', 'serve.json'),
 ];
 
+/**
+ * Resolve the serve.json candidate paths at call time so test
+ * suites can override with `BIZAR_SERVE_JSON_PATH=/tmp/...json`.
+ * Order: env override (if set and exists) → default search list.
+ *
+ * @returns {string[]}
+ */
+function serveInfoFiles() {
+  const override = process.env.BIZAR_SERVE_JSON_PATH;
+  if (override && typeof override === 'string' && override.length > 0) {
+    return [override];
+  }
+  return DEFAULT_SERVE_INFO_FILES;
+}
+
 /**
  * @typedef {Object} ServeInfo
  * @property {string} baseUrl     e.g. "http://127.0.0.1:4097"
@@ -100,7 +115,7 @@ const SERVE_INFO_FILES = [
  * @returns {ServeInfo|null}
  */
 export function readServeInfo() {
-  for (const file of SERVE_INFO_FILES) {
+  for (const file of serveInfoFiles()) {
     if (!existsSync(file)) continue;
     try {
       const raw = readFileSync(file, 'utf8');
@@ -304,7 +319,7 @@ export async function listOpencodeSessions(info, timeoutMs = 5000) {
   }
 }
 
-export const SERVE_INFO_FILE_PATHS = SERVE_INFO_FILES;
+export const SERVE_INFO_FILE_PATHS = DEFAULT_SERVE_INFO_FILES;
 
 // ── v3.5.4 (bug: dispatch stuck) — spawn helpers ─────────────────────────
 //
@@ -623,7 +638,123 @@ export function normalizeOpencodeMessage(msg) {
 }
 
 /**
- * `GET /health` — used by the dispatcher startup check to verify the
+ * `DELETE /api/session/{id}?directory=...` — delete a session on the
+ * opencode serve child. v4.2.4 dashboard feature parity: the rail
+ * menu offers delete and the chat info panel can prune finished
+ * sessions from inside the dashboard.
+ *
+ * Idempotent: a 404 (already gone) is treated as a successful delete.
+ *
+ * @param {ServeInfo} info
+ * @param {string} sessionId
+ * @param {string} [directory]
+ * @param {number} [timeoutMs]
+ * @returns {Promise<{ok:true,status:number}|{ok:false,error:string,status?:number}>}
+ */
+export async function deleteOpencodeSession(info, sessionId, directory, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  if (!info) return { ok: false, error: 'serve-info not available — plugin is not running' };
+  if (!sessionId) return { ok: false, error: 'sessionId is required' };
+  const dir = directory || info.worktree || '';
+  const url = `${info.baseUrl}/api/session/${encodeURIComponent(sessionId)}?directory=${encodeURIComponent(dir)}`;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: 'DELETE',
+      headers: {
+        Authorization: buildAuthHeader(info),
+        Accept: 'application/json',
+      },
+      signal: ac.signal,
+    });
+    if (res.ok || res.status === 404) {
+      return { ok: true, status: res.status };
+    }
+    let detail = '';
+    try { detail = (await res.text()).slice(0, 500); } catch { /* ignore */ }
+    return {
+      ok: false,
+      status: res.status,
+      error: `DELETE /api/session/${sessionId} failed: ${res.status} ${res.statusText}${detail ? ` — ${detail}` : ''}`,
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const isAbort = err instanceof Error && err.name === 'AbortError';
+    return {
+      ok: false,
+      error: isAbort ? `deleteSession timed out after ${timeoutMs}ms` : `deleteSession network error: ${msg}`,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * `PATCH /api/session/{id}?directory=...` — update session fields
+ * (currently just `title`) on the opencode serve child. Used by the
+ * rail row-menu "Rename" affordance.
+ *
+ * @param {ServeInfo} info
+ * @param {string} sessionId
+ * @param {{ title?: string }} patch
+ * @param {string} [directory]
+ * @param {number} [timeoutMs]
+ * @returns {Promise<{ok:true,session:object}|{ok:false,error:string,status?:number}>}
+ */
+export async function updateOpencodeSession(info, sessionId, patch, directory, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  if (!info) return { ok: false, error: 'serve-info not available — plugin is not running' };
+  if (!sessionId) return { ok: false, error: 'sessionId is required' };
+  if (!patch || typeof patch !== 'object') return { ok: false, error: 'patch is required' };
+  const dir = directory || info.worktree || '';
+  const url = `${info.baseUrl}/api/session/${encodeURIComponent(sessionId)}?directory=${encodeURIComponent(dir)}`;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const body = {};
+    if (typeof patch.title === 'string') {
+      const t = patch.title.trim();
+      if (!t) return { ok: false, error: 'title cannot be empty' };
+      if (t.length > 200) return { ok: false, error: 'title too long (> 200 chars)' };
+      body.title = t;
+    } else {
+      return { ok: false, error: 'no supported fields in patch (only `title` is wired)' };
+    }
+    const res = await fetch(url, {
+      method: 'PATCH',
+      headers: {
+        Authorization: buildAuthHeader(info),
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+      },
+      body: JSON.stringify(body),
+      signal: ac.signal,
+    });
+    if (!res.ok) {
+      let detail = '';
+      try { detail = (await res.text()).slice(0, 500); } catch { /* ignore */ }
+      return {
+        ok: false,
+        status: res.status,
+        error: `PATCH /api/session/${sessionId} failed: ${res.status} ${res.statusText}${detail ? ` — ${detail}` : ''}`,
+      };
+    }
+    let session = null;
+    try { session = await res.json(); } catch { /* non-JSON body is fine — we still got 2xx */ }
+    return { ok: true, session };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const isAbort = err instanceof Error && err.name === 'AbortError';
+    return {
+      ok: false,
+      error: isAbort ? `updateSession timed out after ${timeoutMs}ms` : `updateSession network error: ${msg}`,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * GET /health — used by the dispatcher startup check to verify the
  * serve child is actually reachable before we try to enqueue work.
  *
  * v3.11.0 — Replaced the HTTP `GET /health` probe with a TCP-connect

package/bizar-dash/src/server/server.mjs

@@ -302,6 +302,10 @@ export async function createServer({
   }
   currentBroadcast = localBroadcast;
 
+  // v4 — Load BIZAR_* env vars from ~/.config/bizar/env.json into process.env.
+  const { loadEnvJson } = await import('./routes/env-vars.mjs');
+  loadEnvJson();
+
   const apiRouter = await createApiRouter({
     state,
     watcher,
@@ -311,6 +315,22 @@ export async function createServer({
     broadcast: localBroadcast,
   });
 
+  // v5.0.0 — Headroom startup hook. Runs after api.mjs is loaded so the
+  // headroom routes are registered. Errors are caught and logged — startup
+  // must not fail if Headroom has issues.
+  const { headroomStartupHook } = await import('./headroom.mjs');
+  const { readSettings } = await import('./routes/_shared.mjs');
+  try {
+    const settings = readSettings();
+    if (settings?.data?.headroom) {
+      headroomStartupHook(settings.data.headroom).catch((err) => {
+        console.warn('[bizar-dash] headroomStartupHook error:', err?.message || err);
+      });
+    }
+  } catch (err) {
+    console.warn('[bizar-dash] headroom startup hook skipped:', err?.message || err);
+  }
+
   // All /api/* routes go through apiRouter (after mod routes are checked).
   // IMPORTANT: mount v2 router FIRST so `/api/v2/*` matches before
   // apiRouter's internal 404 catch-all (api.mjs line ~109) can swallow it.

package/bizar-dash/src/server/skills-store.mjs

@@ -1,300 +1,190 @@
-/**
- * src/server/skills-store.mjs
- *
- * v3.1.0 — Skills registry. Wraps the `skills` CLI (npm i -g skills)
- * and exposes a stable JSON surface for the dashboard.
- *
- *   - list:   skills list --json
- *   - search: skills search <query>   (or local mock)
- *   - install: skills add <pkg>
- *   - disable / enable: edit a small registry under
- *     ~/.config/bizar/skills-state.json so we don't tamper with the
- *     upstream CLI's own state.
- */
+// src/server/skills-store.mjs
+//
+// v4.0.0 - Skills registry that scans SKILL.md files from all local
+// sources rather than relying on the `skills` CLI npm registry.
+//
+// Sources (in priority order for conflicts):
+//   1. ~/.opencode/skills/<name>/SKILL.md    - user-overridable builtins
+//   2. ~/.agents/skills/<name>/SKILL.md      - user-added skills
+//   3. bizar-dash/skills/<name>/SKILL.md     - BizarHarness shipped
+//   4. .agents/skills/<name>/SKILL.md        - project-local
+//   5. .opencode/skills/<name>/SKILL.md      - project-local
+//
+// Each SKILL.md is parsed for YAML frontmatter (description:) and
+// the first # H1 heading (display name fallback).  No external deps.
 import {
   existsSync,
+  readdirSync,
   readFileSync,
-  writeFileSync,
-  renameSync,
-  mkdirSync,
+  statSync,
 } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
 
-const execFileP = promisify(execFile);
 const HOME = homedir();
-const STATE_FILE = join(HOME, '.config', 'bizar', 'skills-state.json');
 
-// Atomic JSON write: serialize to a sibling temp file, then rename into
-// place. `rename` is atomic on POSIX (same filesystem), so a crash
-// between write and rename never leaves a half-written / corrupt file.
-function atomicWriteJson(filePath, data) {
-  const tmp = `${filePath}.tmp.${process.pid}`;
-  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', 'utf8');
-  renameSync(tmp, filePath);
+/** Project root is injected at construction time. */
+let PROJECT_ROOT = process.cwd();
+
+export function setProjectRoot(p) { PROJECT_ROOT = p; }
+
+// -- Source directories --------------------------------------------------------
+
+/** All SKILL.md scan roots in priority order (first wins for conflicts). */
+function sourceRoots() {
+  return [
+    { dir: join(HOME, '.opencode', 'skills'),   source: 'user'    },
+    { dir: join(HOME, '.agents', 'skills'),     source: 'user'    },
+    { dir: join(PROJECT_ROOT, 'bizar-dash', 'skills'), source: 'shipped' },
+    { dir: join(PROJECT_ROOT, '.agents', 'skills'),   source: 'project' },
+    { dir: join(PROJECT_ROOT, '.opencode', 'skills'), source: 'project' },
+  ];
 }
 
+// -- Frontmatter parser (no external deps) ------------------------------------
+
 /**
- * Categories surfaced in the Skills view. Matched against the
- * `category` field returned by `skills list --json`. The CLI's actual
- * output is loosely categorized, so we accept any string.
+ * Parse YAML frontmatter from a SKILL.md string.
+ * Returns { description, name, ...rest } from frontmatter, plus the body.
  */
-export const CATEGORIES = [
-  { id: 'all', label: 'All', icon: 'sparkles' },
-  { id: 'languages', label: 'Programming Languages', icon: 'code' },
-  { id: 'frameworks', label: 'Frameworks', icon: 'layers' },
-  { id: 'tools', label: 'Tools', icon: 'wrench' },
-  { id: 'testing', label: 'Testing', icon: 'flask' },
-  { id: 'design', label: 'Design', icon: 'palette' },
-  { id: 'reasoning', label: 'Reasoning', icon: 'brain' },
-  { id: 'planning', label: 'Planning', icon: 'map' },
-  { id: 'gitops', label: 'GitOps', icon: 'git-branch' },
-  { id: 'docs', label: 'Docs', icon: 'book' },
-];
+function parseFrontmatter(raw) {
+  const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!fmMatch) return { description: '', name: '', body: raw };
 
-function loadState() {
-  try {
-    if (!existsSync(STATE_FILE)) return {};
-    return JSON.parse(readFileSync(STATE_FILE, 'utf8')) || {};
-  } catch {
-    return {};
+  const fmStr = fmMatch[1];
+  const body  = fmMatch[2];
+  const fm    = {};
+
+  // Very simple YAML key: value parser (values only - no nested structures)
+  for (const line of fmStr.split('\n')) {
+    const colonIdx = line.indexOf(':');
+    if (colonIdx < 0) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const val = line.slice(colonIdx + 1).trim().replace(/^['"]|['"]$/g, '');
+    fm[key] = val;
   }
+
+  return {
+    description: fm.description || '',
+    name:        fm.name        || '',
+    body,
+    ...fm,
+  };
 }
 
-function saveState(state) {
+/**
+ * Extract display name from body: first # Heading or ## Heading.
+ * Returns null if none found.
+ */
+function extractHeading(body) {
+  const m = body.match(/^#{1,2}\s+(.+)$/m);
+  return m ? m[1].trim() : null;
+}
+
+// -- Core scanner -------------------------------------------------------------
+
+/**
+ * Scan one directory for SKILL.md files.
+ * Returns an array of parsed skill objects.
+ */
+function scanDir(dir, source) {
+  if (!existsSync(dir)) return [];
+  const out = [];
   try {
-    mkdirSync(dirname(STATE_FILE), { recursive: true });
-    atomicWriteJson(STATE_FILE, state);
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const mdPath = join(dir, entry.name, 'SKILL.md');
+      if (!existsSync(mdPath)) continue;
+      let raw;
+      try {
+        raw = readFileSync(mdPath, 'utf8');
+      } catch {
+        continue;
+      }
+      const { description, name: fmName, body } = parseFrontmatter(raw);
+      const displayName = fmName || extractHeading(body) || entry.name;
+      const relPath = mdPath; // absolute path to the file
+
+      out.push({
+        name:        displayName,
+        description: description.slice(0, 200),
+        source,
+        path:        relPath,
+        body,        // full body for detail view
+      });
+    }
   } catch {
-    /* best effort */
+    // Directory unreadable - skip
   }
+  return out;
 }
 
-function safeExec(args, { timeoutMs = 8000 } = {}) {
-  return execFileP('skills', args, { timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024 })
-    .then((r) => r.stdout)
-    .catch((err) => {
-      // Don't throw — return empty so the UI can fall back to a mock.
-      // eslint-disable-next-line no-console
-      console.warn('[skills] command failed:', err.message);
-      return '';
-    });
+/** In-memory cache with manual invalidation. */
+let _cache    = null;
+let _cacheAge = 0;
+const CACHE_TTL_MS = 30_000;
+
+function getCache() {
+  if (_cache && Date.now() - _cacheAge < CACHE_TTL_MS) return _cache;
+  const skills = [];
+  for (const { dir, source } of sourceRoots()) {
+    skills.push(...scanDir(dir, source));
+  }
+  _cache    = skills;
+  _cacheAge = Date.now();
+  return skills;
 }
 
-/** Local mock used as a fallback if the CLI isn't installed. */
-function mockCatalog() {
-  return [
-    {
-      id: 'anthropics/skills',
-      name: 'Anthropic Skills',
-      description: 'Curated skill set from Anthropic — Claude prompt patterns, agents, evals.',
-      category: 'reasoning',
-      source: 'anthropics/skills',
-      tags: ['reasoning', 'agents'],
-      version: '1.0.0',
-      installCmd: 'skills add anthropics/skills',
-    },
-    {
-      id: 'vercel-labs/agent-skills',
-      name: 'Vercel Agent Skills',
-      description: 'Vercel-Labs agent skill set — React, Next.js, frontend performance.',
-      category: 'frameworks',
-      source: 'vercel-labs/agent-skills',
-      tags: ['react', 'nextjs', 'frontend'],
-      version: '1.0.0',
-      installCmd: 'skills add vercel-labs/agent-skills',
-    },
-    {
-      id: 'supabase/agent-skills',
-      name: 'Supabase Agent Skills',
-      description: 'Supabase agent skill set — Postgres, Auth, Edge Functions.',
-      category: 'tools',
-      source: 'supabase/agent-skills',
-      tags: ['postgres', 'auth'],
-      version: '1.0.0',
-      installCmd: 'skills add supabase/agent-skills',
-    },
-    {
-      id: 'mattpocock/skills',
-      name: 'Matt Pocock Skills',
-      description: 'TypeScript, TDD, testing patterns from Matt Pocock.',
-      category: 'testing',
-      source: 'mattpocock/skills',
-      tags: ['typescript', 'tdd'],
-      version: '1.0.0',
-      installCmd: 'skills add mattpocock/skills',
-    },
-    {
-      id: 'cloudflare/skills',
-      name: 'Cloudflare Skills',
-      description: 'Cloudflare Workers, Durable Objects, Agents SDK.',
-      category: 'tools',
-      source: 'cloudflare/skills',
-      tags: ['cloudflare', 'workers'],
-      version: '1.0.0',
-      installCmd: 'skills add cloudflare/skills',
-    },
-    {
-      id: 'anthropics/claude-code-skills',
-      name: 'Claude Code Skills',
-      description: 'Skills for Claude Code — prompt patterns and tool usage.',
-      category: 'reasoning',
-      source: 'anthropics/claude-code-skills',
-      tags: ['claude', 'code'],
-      version: '1.0.0',
-      installCmd: 'skills add anthropics/claude-code-skills',
-    },
-  ];
+export function invalidateCache() {
+  _cache    = null;
+  _cacheAge = 0;
 }
 
-function inferCategoryFromTags(tags = []) {
-  const lower = tags.map((t) => t.toLowerCase());
-  if (lower.some((t) => /react|next|vue|svelte|frontend|tailwind/.test(t))) return 'frameworks';
-  if (lower.some((t) => /tdd|test|jest|vitest|playwright|pytest/.test(t))) return 'testing';
-  if (lower.some((t) => /postgres|auth|cloudflare|supabase|kubernetes|docker/.test(t))) return 'tools';
-  if (lower.some((t) => /design|ui|ux|figma|tailwind|theme/.test(t))) return 'design';
-  if (lower.some((t) => /reasoning|agent|claude|gpt|llm|chat/.test(t))) return 'reasoning';
-  if (lower.some((t) => /plan|roadmap|architecture/.test(t))) return 'planning';
-  if (lower.some((t) => /git|github|gh|ci|deploy/.test(t))) return 'gitops';
-  if (lower.some((t) => /doc|readme|wiki|changelog/.test(t))) return 'docs';
-  if (lower.some((t) => /python|js|ts|rust|go|kotlin|swift|c\+\+|ruby|java|php/.test(t))) return 'languages';
-  return 'tools';
+// -- Fuzzy search (simple includes-based, no external deps) --------------------
+
+function fuzzyMatch(skill, q) {
+  const hay = `${skill.name} ${skill.description}`.toLowerCase();
+  const terms = q.toLowerCase().split(/\s+/);
+  return terms.every((t) => hay.includes(t));
 }
 
-export const skillsStore = {
-  STATE_FILE,
-  CATEGORIES,
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}
+
+// -- Public API ----------------------------------------------------------------
 
-  /** List installed skills. */
+export const skillsStore = {
+  /** List all skills grouped by source. */
   async list() {
-    const state = loadState();
-    const out = await safeExec(['list', '--json']);
-    let items = [];
-    if (out && out.trim().startsWith('[')) {
-      try {
-        items = JSON.parse(out);
-      } catch {
-        items = [];
-      }
-    } else if (out && out.trim().startsWith('{')) {
-      // Some versions return { skills: [...] }
-      try {
-        const parsed = JSON.parse(out);
-        items = parsed.skills || parsed.items || [];
-      } catch {
-        items = [];
-      }
-    }
-    // If the CLI is not installed or returned nothing, fall back to a
-    // minimal local mock so the UI is still useful in dev.
-    if (items.length === 0) {
-      items = mockCatalog().map((m) => ({ ...m, installed: true, mock: true }));
-    }
-    return items.map((it) => {
-      const id = it.id || it.name || it.source || it.path || 'unknown';
-      const name = it.name || id.split('/').pop() || id;
-      const tags = Array.isArray(it.tags) ? it.tags : [];
-      const category = it.category || inferCategoryFromTags(tags);
-      const enabled = state[id]?.enabled !== false; // default enabled
-      return {
-        id,
-        name,
-        description: it.description || '',
-        category,
-        tags,
-        version: it.version || '0.0.0',
-        source: it.source || id,
-        path: it.path || null,
-        installed: true,
-        enabled,
-        mock: !!it.mock,
-      };
-    });
+    return getCache();
   },
 
-  /** Search the registry. Falls back to a mock local index. */
+  /**
+   * Fuzzy search by name + description.
+   * Returns plain objects - NO ANSI codes, NO formatted terminal output.
+   */
   async search(query) {
-    const trimmed = (query || '').trim();
-    let items = [];
-    if (trimmed) {
-      const out = await safeExec(['search', trimmed]);
-      if (out) {
-        try {
-          const parsed = JSON.parse(out);
-          items = Array.isArray(parsed) ? parsed : parsed.results || parsed.items || [];
-        } catch {
-          // Fall through to text-mode parse.
-          items = out
-            .split(/\r?\n/)
-            .filter((l) => l.trim())
-            .map((l) => ({ name: l.trim(), id: l.trim(), source: l.trim() }));
-        }
-      }
-    }
-    if (items.length === 0) {
-      // Mock fallback: filter the mock catalog by query.
-      const q = trimmed.toLowerCase();
-      items = mockCatalog().filter((m) =>
-        !q ||
-        m.name.toLowerCase().includes(q) ||
-        m.description.toLowerCase().includes(q) ||
-        m.tags.some((t) => t.toLowerCase().includes(q)),
-      );
-      if (items.length === 0 && !q) items = mockCatalog();
-    }
-    return items.map((it) => {
-      const id = it.id || it.name || it.source || 'unknown';
-      const name = it.name || id.split('/').pop() || id;
-      const tags = Array.isArray(it.tags) ? it.tags : [];
-      return {
-        id,
-        name,
-        description: it.description || '',
-        category: it.category || inferCategoryFromTags(tags),
-        tags,
-        version: it.version || '0.0.0',
-        source: it.source || id,
-        installCmd: it.installCmd || `skills add ${id}`,
-      };
-    });
-  },
-
-  /** Install a skill by name/source. */
-  async install(name, source) {
-    const target = source || name;
-    try {
-      const { stdout, stderr } = await execFileP('skills', ['add', target], {
-        timeout: 60_000,
-        maxBuffer: 4 * 1024 * 1024,
-      });
-      return {
-        ok: true,
-        name: target,
-        output: [stdout, stderr].filter(Boolean).join('\n').trim(),
-      };
-    } catch (err) {
-      return {
-        ok: false,
-        name: target,
-        error: err instanceof Error ? err.message : String(err),
-      };
-    }
+    const q = (query || '').trim();
+    const all = getCache();
+    if (!q) return all;
+    return all.filter((s) => fuzzyMatch(s, q));
   },
 
-  /** Disable a skill (kept on disk, not loaded). */
-  disable(id) {
-    const state = loadState();
-    state[id] = { ...(state[id] || {}), enabled: false, disabledAt: Date.now() };
-    saveState(state);
-    return { ok: true, enabled: false };
+  /**
+   * Return a single skill by source + name.
+   */
+  async get(source, name) {
+    const all = getCache();
+    return all.find(
+      (s) => s.source === source && (s.name === name || s.path.endsWith(`/${name}/SKILL.md`)),
+    ) || null;
   },
 
-  enable(id) {
-    const state = loadState();
-    state[id] = { ...(state[id] || {}), enabled: true, enabledAt: Date.now() };
-    saveState(state);
-    return { ok: true, enabled: true };
+  /** Force a cache refresh. */
+  refresh() {
+    invalidateCache();
+    return getCache();
   },
 };