mover-os 4.7.7 → 4.7.9

package/src/dashboard/lib/session-log-parser.js

@@ -0,0 +1,145 @@
+"use strict";
+
+// session-log-parser.js — Mover memory engine, curated tier.
+// Parses the Daily Note "## Session Log" section that daily-note-resolver.js ignores.
+// This is the HIGHEST-signal curated record: /log already distilled each session into
+// timestamped arcs ("#### ~04:20 - Found PII leak"), commit hashes, and **Flag:** lines.
+// One doc per sub-arc = the natural recall unit ("when did I fix X").
+
+const fs = require("fs");
+const path = require("path");
+const { dailiesDir } = require("./paths");
+
+const DAILY_RE = /^Daily - (\d{4})-(\d{2})-(\d{2})\.md$/;
+const COMMIT_HASH = /`([0-9a-f]{7,40})`/g;
+const PROJECT_TAG = /\[([^\]]+)\]/g;
+
+function listDailyNotes(vault) {
+  const root = dailiesDir(vault);
+  const out = [];
+  let months;
+  try { months = fs.readdirSync(root, { withFileTypes: true }); } catch { return out; }
+  for (const m of months) {
+    if (!m.isDirectory()) continue;
+    const mdir = path.join(root, m.name);
+    let files;
+    try { files = fs.readdirSync(mdir); } catch { continue; }
+    for (const f of files) {
+      const mm = f.match(DAILY_RE);
+      if (mm) out.push({ date: `${mm[1]}-${mm[2]}-${mm[3]}`, file: path.join(mdir, f) });
+    }
+  }
+  // Also support flat (no month subfolder) layout.
+  try {
+    for (const f of fs.readdirSync(root)) {
+      const mm = f.match(DAILY_RE);
+      if (mm) out.push({ date: `${mm[1]}-${mm[2]}-${mm[3]}`, file: path.join(root, f) });
+    }
+  } catch {}
+  out.sort((a, b) => (a.date < b.date ? 1 : -1)); // newest first
+  return out;
+}
+
+function extractCommits(text) {
+  const out = new Set();
+  let m;
+  COMMIT_HASH.lastIndex = 0;
+  while ((m = COMMIT_HASH.exec(text)) !== null) {
+    // commit hashes are 7-40 hex; skip obvious non-hashes (all digits, e.g. line refs)
+    if (/[a-f]/.test(m[1]) && m[1].length >= 7) out.add(m[1].slice(0, 10));
+  }
+  return [...out].slice(0, 12);
+}
+
+// Pull the project label out of a "### Session Log [ATTENDED] … [Mover OS Bundle] …" header.
+function projectFromHeader(headerLine) {
+  let m, project = null;
+  PROJECT_TAG.lastIndex = 0;
+  while ((m = PROJECT_TAG.exec(headerLine)) !== null) {
+    const tag = m[1].trim();
+    if (/^(ATTENDED|UNATTENDED|COMPACTED|Claude Code|Antigravity|Gemini|Cursor|Codex|Background Agent)$/i.test(tag)) continue;
+    if (/^~?\d/.test(tag)) continue; // timestamps
+    project = tag; // last non-meta tag wins (it's usually the project)
+  }
+  return project;
+}
+
+// Parse one Daily Note's "## Session Log" into arc docs.
+function parseNote(note) {
+  let raw;
+  try { raw = fs.readFileSync(note.file, "utf8"); } catch { return []; }
+  const idx = raw.search(/^##\s+Session Log\s*$/m);
+  if (idx < 0) return [];
+  // Section = from "## Session Log" to next top-level "## " (or EOF).
+  let section = raw.slice(idx);
+  const nextTop = section.slice(3).search(/^##\s+(?!#)/m);
+  if (nextTop >= 0) section = section.slice(0, nextTop + 3);
+
+  let curProject = null;
+  const docs = [];
+
+  // Split into blocks on "#### " arc headers; track the nearest "### " session header for project.
+  const lines = section.split(/\r?\n/);
+  let arc = null;
+  const flush = () => {
+    if (!arc) return;
+    const body = arc.bodyLines.join("\n").trim();
+    const text = (arc.title + "\n" + body).trim();
+    if (text.length > 8) {
+      docs.push({
+        id: `slog:${note.date}#${arc.time || docs.length}`,
+        type: "sessionlog",
+        date: note.date,
+        time: arc.time,
+        title: arc.title,
+        project: curProject,
+        commits: extractCommits(text),
+        text,
+      });
+    }
+    arc = null;
+  };
+
+  for (const line of lines) {
+    const sess = line.match(/^###\s+(.*)$/);
+    if (sess && !line.startsWith("####")) {
+      const p = projectFromHeader(sess[1]);
+      if (p) curProject = p;
+      continue;
+    }
+    const arcHead = line.match(/^####\s+(.*)$/);
+    if (arcHead) {
+      flush();
+      const titleRaw = arcHead[1].trim();
+      const tm = titleRaw.match(/~?(\d{1,2}:\d{2})/);
+      arc = { time: tm ? tm[1] : null, title: titleRaw.replace(/^~?\d{1,2}:\d{2}\s*-?\s*/, "").trim() || titleRaw, bodyLines: [] };
+      continue;
+    }
+    if (arc) arc.bodyLines.push(line);
+  }
+  flush();
+  return docs;
+}
+
+// Parse all Daily Note session logs → curated arc docs.
+function parseSessionLogs(vault, opts = {}) {
+  const notes = listDailyNotes(vault);
+  const limited = opts.limit ? notes.slice(0, opts.limit) : notes;
+  const docs = [];
+  for (const note of limited) {
+    for (const d of parseNote(note)) docs.push(d);
+  }
+  return { docs, noteCount: limited.length, arcCount: docs.length };
+}
+
+module.exports = { parseSessionLogs, listDailyNotes };
+
+// ── CLI ──
+if (require.main === module) {
+  const vault = process.argv[2] || require("./paths").resolveVault();
+  const r = parseSessionLogs(vault, { limit: Number(process.argv[3]) || 0 });
+  console.log(`${r.noteCount} daily notes → ${r.arcCount} session-log arcs`);
+  for (const d of r.docs.slice(0, 10)) {
+    console.log(`  ${d.date} ${d.time || "  -  "}  [${d.project || "?"}]  ${d.title.slice(0, 60)}  ${d.commits.length ? "commits:" + d.commits.join(",") : ""}`);
+  }
+}

package/src/dashboard/lib/session-time-parser.js

@@ -0,0 +1,158 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { dailiesDir } = require("./paths");
+const { localDateKey } = require("./date-utils");
+
+// session-time-parser.js — REAL tracked time from the daily-note Session Log
+// headers. This is the honest core of "said vs did hours": every attended
+// session header carries a start-end clock range, e.g.
+//   ### Session Log [ATTENDED] — ~13:51-16:31 [Claude Code] [Mover OS Bundle]
+// from which a genuine DURATION is computable. We aggregate those durations
+// into real totals (today / 7d / 30d) and a best-effort by-project split.
+//
+// What this is NOT: time per DOMAIN (Work/Vitality/Faith). Session headers
+// tag a [project], never a domain — so a domain split would be fabricated and
+// is deliberately not produced here (the Evidence Covenant says so honestly).
+//
+// Honesty rules:
+//  - Only sessions with BOTH a start AND an end contribute minutes. A header
+//    with only a start (an open/auto-stub session) is counted as `untimed`,
+//    never given a guessed duration.
+//  - A session whose end is earlier than its start is treated as crossing
+//    midnight (+24h) ONLY if the result is a sane length; otherwise it is
+//    dropped to `untimed` rather than inventing a number.
+//  - Sessions longer than SANE_CAP_MIN are treated as a parse artefact and
+//    dropped to `untimed` (never a fabricated multi-day block).
+//
+// Returns: {
+//   available, daysScanned,
+//   today:  { minutes, sessions },
+//   last7d: { minutes, sessions, untimed },
+//   last30d:{ minutes, sessions, untimed },
+//   byProject7d: [{ project, minutes, sessions }],  // best-effort, desc
+//   longest: { minutes, date, project } | null,
+//   src: "Dailies session-log start-end ranges"
+// }
+
+const SANE_CAP_MIN = 20 * 60; // 20h: a real long session is plausible; beyond is a parse artefact
+
+// tokens that appear in session-header brackets but are NOT the project name
+const NON_PROJECT = /^(claude code|claude-code|antigravity|gemini|cursor|cline|codex|background agent|attended|auto-stub|unattended|compacted|cross-midnight|delta|checkpoint|[0-9a-f]{6,}|[a-z]{3}\s+\d{1,2})$/i;
+
+function cleanProject(brackets) {
+  for (const b of brackets) {
+    const t = (b || "").trim();
+    if (!t) continue;
+    if (NON_PROJECT.test(t)) continue;
+    if (/^\d{1,2}:\d{2}/.test(t)) continue; // a stray time
+    return t;
+  }
+  return "unlabelled";
+}
+
+function compute({ vault, daysLookback = 30 } = {}) {
+  const empty = {
+    available: false, daysScanned: 0,
+    today: { minutes: 0, sessions: 0 },
+    last7d: { minutes: 0, sessions: 0, untimed: 0 },
+    last30d: { minutes: 0, sessions: 0, untimed: 0 },
+    byProject7d: [], longest: null,
+    src: "Dailies session-log start-end ranges",
+  };
+  if (!vault) return empty;
+  const dDir = dailiesDir(vault);
+  if (!fs.existsSync(dDir)) return empty;
+
+  let monthDirs;
+  try { monthDirs = fs.readdirSync(dDir).filter((d) => /^\d{4}-\d{2}$/.test(d)).sort().reverse(); }
+  catch (_) { return empty; }
+
+  const todayKey = localDateKey();
+  const cutoff = Date.now() - daysLookback * 24 * 3600 * 1000;
+  const sevenAgo = Date.now() - 7 * 24 * 3600 * 1000;
+
+  const today = { minutes: 0, sessions: 0 };
+  const last7d = { minutes: 0, sessions: 0, untimed: 0 };
+  const last30d = { minutes: 0, sessions: 0, untimed: 0 };
+  const proj7d = new Map();
+  let longest = null;
+  let scanned = 0;
+
+  // capture the session header start/end + the trailing bracket tokens
+  const reSession = /^###\s+Session Log\s+\[[^\]]+\]\s+—\s+~?(\d{1,2}):(\d{2})(?:\s*[-–]\s*(\d{1,2}):(\d{2}))?\s*(\[[^\]]*\][^\n]*)?$/gm;
+
+  outer: for (const mDir of monthDirs) {
+    if (scanned >= daysLookback) break;
+    const monthPath = path.join(dDir, mDir);
+    let files;
+    try { files = fs.readdirSync(monthPath).filter((f) => /^Daily - \d{4}-\d{2}-\d{2}\.md$/.test(f)).sort().reverse(); }
+    catch (_) { continue; }
+    for (const f of files) {
+      if (scanned >= daysLookback) break outer;
+      const m = f.match(/(\d{4})-(\d{2})-(\d{2})/);
+      if (!m) continue;
+      const dayKey = `${m[1]}-${m[2]}-${m[3]}`;
+      const dayTs = Date.parse(dayKey);
+      if (!Number.isFinite(dayTs) || dayTs < cutoff) continue;
+      const isToday = dayKey === todayKey;
+      const inLast7 = dayTs >= sevenAgo - 24 * 3600 * 1000; // day-granularity 7d window
+      scanned++;
+
+      let text;
+      try { text = fs.readFileSync(path.join(monthPath, f), "utf8"); }
+      catch (_) { continue; }
+
+      let slMatch = text.match(/^##\s+Session Log/m) || text.match(/^###\s+Session Log/m);
+      if (!slMatch || typeof slMatch.index !== "number") continue;
+      const section = text.slice(slMatch.index);
+
+      let mm;
+      reSession.lastIndex = 0;
+      while ((mm = reSession.exec(section)) !== null) {
+        const sh = parseInt(mm[1], 10), sm = parseInt(mm[2], 10);
+        if (!Number.isFinite(sh) || sh < 0 || sh > 23) continue;
+        const hasEnd = mm[3] != null;
+        const brackets = mm[5] ? (mm[5].match(/\[([^\]]*)\]/g) || []).map((b) => b.slice(1, -1)) : [];
+        const project = cleanProject(brackets);
+
+        // count every session toward 7d/30d session COUNT
+        last30d.sessions++;
+        if (inLast7) last7d.sessions++;
+        if (isToday) today.sessions++;
+
+        if (!hasEnd) { last30d.untimed++; if (inLast7) last7d.untimed++; continue; }
+
+        const eh = parseInt(mm[3], 10), em = parseInt(mm[4], 10);
+        if (!Number.isFinite(eh) || eh < 0 || eh > 23) { last30d.untimed++; if (inLast7) last7d.untimed++; continue; }
+        let mins = (eh * 60 + em) - (sh * 60 + sm);
+        if (mins < 0) mins += 24 * 60; // crossed midnight
+        if (mins <= 0 || mins > SANE_CAP_MIN) { last30d.untimed++; if (inLast7) last7d.untimed++; continue; }
+
+        last30d.minutes += mins;
+        if (inLast7) {
+          last7d.minutes += mins;
+          proj7d.set(project, (proj7d.get(project) || { minutes: 0, sessions: 0 }));
+          const p = proj7d.get(project); p.minutes += mins; p.sessions++;
+        }
+        if (isToday) today.minutes += mins;
+        if (!longest || mins > longest.minutes) longest = { minutes: mins, date: dayKey, project };
+      }
+    }
+  }
+
+  const byProject7d = Array.from(proj7d.entries())
+    .map(([project, v]) => ({ project, minutes: v.minutes, sessions: v.sessions }))
+    .sort((a, b) => b.minutes - a.minutes)
+    .slice(0, 5);
+
+  return {
+    available: scanned > 0 && (last30d.minutes > 0 || last30d.untimed > 0),
+    daysScanned: scanned,
+    today, last7d, last30d, byProject7d, longest,
+    src: "Dailies session-log start-end ranges",
+  };
+}
+
+module.exports = { compute };

package/src/dashboard/lib/skill-index.js

@@ -0,0 +1,171 @@
+"use strict";
+// skill-index.js — zero-dep index over SKILL.md descriptions so a UserPromptSubmit hook can
+// DETERMINISTICALLY surface the right skill. Claude Code's own skill auto-activation is pure
+// model judgment over descriptions, so topic-specific skills rarely fire. This mirrors the
+// memory-index/recall pattern: build a trigger index, match the prompt, inject a factual notice.
+//
+// Surfaceable set = skills that rely on the model noticing: alwaysApply:false, not
+// disable_model_invocation, not glob/path-scoped (those load deterministically via `paths:`).
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { tokenize } = require("./memory-text");
+
+let moverDir;
+try { ({ moverDir } = require("./paths")); } catch { moverDir = () => path.join(os.homedir(), ".mover"); }
+
+const IDX_DIR = process.env.MOVER_SKILL_INDEX_DIR || moverDir();
+const IDX_FILE = path.join(IDX_DIR, "skill-index.json");
+
+// Small synonym map (group key + members) so a prompt verb matches a description phrased
+// differently ("draft"/"copy" ↔ "write"). Expansion is applied to the SKILL triggers at build
+// time (one-sided) — the prompt is only stemmed at query time, which keeps precision higher.
+const SYN = {
+  write: ["draft", "compose", "copy", "post", "tweet", "article", "content", "blog", "email", "publish", "thread"],
+  search: ["recall", "history", "past", "previous", "find", "remember", "session"],
+  plan: ["roadmap", "phase", "milestone", "task"],
+  test: ["tdd", "spec", "coverage"],
+  research: ["investigate", "competitor", "explore", "market"],
+  debug: ["fix", "error", "broken", "bug", "failing", "crash"],
+  review: ["check", "inspect", "critique", "audit"],
+};
+const SYN_INDEX = (() => {
+  const m = Object.create(null);
+  for (const key in SYN) {
+    const group = [key, ...SYN[key]];
+    for (const w of group) { (m[w] || (m[w] = new Set([w]))); for (const g of group) m[w].add(g); }
+  }
+  return m;
+})();
+
+// Crude stemmer — plural/gerund normalization only. Keeps min length so short roots survive.
+function stem(w) {
+  w = String(w || "").toLowerCase();
+  if (w.length > 5 && w.endsWith("ing")) return w.slice(0, -3);
+  if (w.length > 4 && w.endsWith("ed")) return w.slice(0, -2);
+  if (w.length > 4 && w.endsWith("es")) return w.slice(0, -2);
+  if (w.length > 3 && w.endsWith("s") && !w.endsWith("ss")) return w.slice(0, -1);
+  return w;
+}
+
+// Build a skill's trigger set from its description: tokenize → stem → synonym-expand.
+function triggerSet(description) {
+  const out = new Set();
+  for (const tok of tokenize(description)) {
+    const s = stem(tok);
+    out.add(s);
+    const grp = SYN_INDEX[tok] || SYN_INDEX[s];
+    if (grp) for (const g of grp) out.add(stem(g));
+  }
+  return [...out];
+}
+
+// Parse a SKILL.md YAML-ish frontmatter (line-based; no YAML dep). Single-line values only,
+// which matches Mover's SKILL.md convention.
+function parseFrontmatter(md) {
+  const fm = { name: "", description: "", alwaysApply: false, disabled: false, globs: [] };
+  const m = String(md || "").match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!m) return fm;
+  for (const line of m[1].split("\n")) {
+    const mm = line.match(/^([a-zA-Z_-]+):\s*(.*)$/);
+    if (!mm) continue;
+    const key = mm[1];
+    let val = mm[2].trim().replace(/^["']|["']$/g, "");
+    if (key === "name") fm.name = val;
+    else if (key === "description") fm.description = val;
+    else if (key === "alwaysApply") fm.alwaysApply = /^true$/i.test(val);
+    else if (key === "disable_model_invocation") fm.disabled = /^true$/i.test(val);
+    else if (key === "globs") fm.globs = val ? val.split(/[,\s]+/).filter(Boolean) : [];
+  }
+  return fm;
+}
+
+function discoverSkillMd(dirs) {
+  const files = [];
+  const walk = (d) => {
+    let ents; try { ents = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
+    for (const e of ents) {
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.name === "SKILL.md") files.push(p);
+    }
+  };
+  for (const d of dirs) walk(d);
+  return files;
+}
+
+function defaultSkillDirs() {
+  return [path.join(os.homedir(), ".claude", "skills")];
+}
+
+function ensureDir(d) { try { fs.mkdirSync(d, { recursive: true }); } catch {} }
+function atomicWrite(file, data, isText) {
+  const tmp = file + ".tmp";
+  fs.writeFileSync(tmp, isText ? data : JSON.stringify(data));
+  fs.renameSync(tmp, file);
+}
+
+function buildSkillIndex(dirs) {
+  dirs = dirs && dirs.length ? dirs : defaultSkillDirs();
+  const files = discoverSkillMd(dirs);
+  const skills = [];
+  const seenNames = new Set();
+  const df = Object.create(null);
+  for (const file of files) {
+    let md; try { md = fs.readFileSync(file, "utf8"); } catch { continue; }
+    const fm = parseFrontmatter(md);
+    if (!fm.name || !fm.description) continue;
+    if (fm.alwaysApply || fm.disabled) continue;      // already loads every session / manual-only
+    if (fm.globs && fm.globs.length) continue;         // path-scoped → handled by `paths:` natively
+    if (seenNames.has(fm.name)) continue;              // dedupe (personal + bundle copies)
+    const triggers = triggerSet(fm.description);
+    if (!triggers.length) continue;
+    seenNames.add(fm.name);
+    const oneLine = fm.description.replace(/\s+/g, " ").trim().slice(0, 140);
+    skills.push({ name: fm.name, oneLine, triggers });
+    for (const t of new Set(triggers)) df[t] = (df[t] || 0) + 1;
+  }
+  // Distinctive triggers for the stage-1 bash gate: words present in <= half the skills, len>=4.
+  const half = Math.max(1, Math.ceil(skills.length / 2));
+  const triggers = Object.keys(df).filter((w) => w.length >= 4 && df[w] <= half).sort();
+  const idx = { builtAt: Date.now(), count: skills.length, skills, triggers };
+  // Never overwrite a populated index with an empty one (protects a real index from a misconfigured
+  // run / CI with no installed skills).
+  if (skills.length === 0 && loadSkillIndex()) return idx;
+  ensureDir(IDX_DIR);
+  atomicWrite(IDX_FILE, idx);
+  atomicWrite(path.join(IDX_DIR, "skill-triggers.txt"), triggers.join("\n") + "\n", true);
+  return idx;
+}
+
+function loadSkillIndex() {
+  try { return JSON.parse(fs.readFileSync(IDX_FILE, "utf8")); } catch { return null; }
+}
+
+// Score each skill by how many distinct (stemmed) prompt tokens hit its expanded trigger set.
+function querySkills(prompt, idx) {
+  if (!idx || !idx.skills) return [];
+  const ptoks = new Set(tokenize(prompt).map(stem));
+  const hits = [];
+  for (const s of idx.skills) {
+    const tset = new Set(s.triggers);
+    let score = 0;
+    for (const w of ptoks) if (tset.has(w)) score++;
+    if (score > 0) hits.push({ name: s.name, oneLine: s.oneLine, score });
+  }
+  hits.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+  return hits;
+}
+
+module.exports = {
+  parseFrontmatter, stem, triggerSet, buildSkillIndex, loadSkillIndex, querySkills,
+  discoverSkillMd, defaultSkillDirs, IDX_DIR, IDX_FILE,
+};
+
+// ── CLI: build the index from installed skills (or explicit dirs). Run at install/update. ──
+if (require.main === module) {
+  const dirs = process.argv.slice(2).filter((a) => !a.startsWith("--"));
+  const r = buildSkillIndex(dirs.length ? dirs : defaultSkillDirs());
+  console.log(`skill-index: ${r.count} skills indexed, ${r.triggers.length} triggers → ${IDX_FILE}`);
+}

package/src/dashboard/lib/skill-indexer.js

@@ -0,0 +1,118 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { safeListDir, safeRead, safeStat } = require("./paths");
+
+// Enumerate ~/.claude/skills/*/SKILL.md files, parse YAML frontmatter,
+// and return a categorized inventory for the Library route's Skills sub-tab.
+//
+// Frontmatter shape (varies by skill):
+//   name: <slug>
+//   description: <one-liner trigger condition or blurb>
+//   model: sonnet | haiku | opus
+//   alwaysApply: false   (optional)
+//
+// We also dedup across ~/.claude/skills, ~/.cursor/skills, ~/.gemini/skills
+// — only the canonical Claude location is read (the others are mirrors).
+
+// System skills that are always-on intelligence rather than domain skills
+const SYSTEM_SKILLS = new Set([
+  "friction-enforcer",
+  "pattern-detector",
+  "plan-md-guardian",
+  "mover-os-context",
+  "workflow-router",
+  "strategic-compact",
+  "verification-before-completion",
+  "parallel-agents",
+  "daily-note-writer",
+  "skill-snapshot",
+  "find-skills",
+]);
+
+function claudeSkillsDir() {
+  return path.join(os.homedir(), ".claude", "skills");
+}
+
+function parseFrontmatter(content) {
+  if (!content) return null;
+  const m = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+  if (!m) return null;
+  const body = m[1];
+  const out = {};
+  // Parse simple key: value pairs. Quotes optional.
+  body.split(/\r?\n/).forEach(line => {
+    const km = line.match(/^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$/);
+    if (km) {
+      const key = km[1].trim();
+      let val = km[2].trim();
+      // Strip wrapping quotes
+      if ((val.startsWith('"') && val.endsWith('"')) ||
+          (val.startsWith("'") && val.endsWith("'"))) {
+        val = val.slice(1, -1);
+      }
+      // Coerce booleans
+      if (val === "true") val = true;
+      else if (val === "false") val = false;
+      out[key] = val;
+    }
+  });
+  return out;
+}
+
+function categorize(slug, frontmatter) {
+  if (SYSTEM_SKILLS.has(slug)) return "system";
+  if (slug.startsWith("agent-")) return "specialist";
+  return "domain";
+}
+
+function indexSkills() {
+  const dir = claudeSkillsDir();
+  if (!safeStat(dir)) {
+    return { available: false, count: 0, byCategory: { system: [], specialist: [], domain: [] }, all: [] };
+  }
+
+  const skillDirs = safeListDir(dir, { dirsOnly: true });
+  const all = [];
+
+  for (const sd of skillDirs) {
+    if (sd.name.startsWith("_") || sd.name.startsWith(".") || sd.name.endsWith("-workspace")) continue;
+    const skillFile = path.join(sd.path, "SKILL.md");
+    const content = safeRead(skillFile);
+    if (!content) continue;
+    const fm = parseFrontmatter(content) || {};
+    const stat = safeStat(skillFile);
+
+    const slug = fm.name || sd.name;
+    const category = categorize(slug, fm);
+
+    all.push({
+      slug,
+      name: fm.name || sd.name,
+      description: fm.description || "",
+      model: fm.model || null,
+      alwaysApply: fm.alwaysApply === true || fm.alwaysApply === "true",
+      category,
+      path: skillFile,
+      mtime: stat ? stat.mtime.getTime() : null,
+    });
+  }
+
+  all.sort((a, b) => a.name.localeCompare(b.name));
+
+  const byCategory = { system: [], specialist: [], domain: [] };
+  for (const skill of all) {
+    byCategory[skill.category].push(skill);
+  }
+
+  return {
+    available: true,
+    count: all.length,
+    byCategory,
+    all,
+  };
+}
+
+module.exports = { indexSkills };