@polymorphism-tech/morph-spec 8.38.0 → 8.41.0

package/src/dashboard/scanner/portfolio.js

@@ -0,0 +1,153 @@
+/**
+ * Many projects in one dashboard. Each project keeps its own live API
+ * (project-api.js: features, activity, files), created on first use; this
+ * module lists the projects, routes `/p/:id/…` to the right one, and answers
+ * which project a changed file belongs to.
+ *
+ * The list is the registry (src/lib/projects/registry.js) plus the project the
+ * dashboard was launched from, which is always shown even if it cannot be
+ * registered. Projects found next to the registered ones are offered, never
+ * added on their own.
+ *
+ * A cold project can take seconds to read (a 100k-event log). The portfolio
+ * never waits for one: `summary` is served only for projects already in
+ * memory, and the rest are read in the background (`warmNext`).
+ */
+
+import { dirname, basename } from 'path';
+import { createProjectApi } from './project-api.js';
+import * as registryModule from '../../lib/projects/registry.js';
+
+function slug(text) {
+  return String(text).toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '')
+    .replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'projeto';
+}
+
+const lower = (p) => (process.platform === 'win32' ? p.toLowerCase() : p);
+
+/**
+ * @param {{ launchDir: string, registry?: object, createApi?: Function }} opts
+ *   `registry` and `createApi` are test seams.
+ */
+export function createPortfolio({ launchDir, registry = registryModule, createApi = createProjectApi }) {
+  const launchKey = registry.projectKey(launchDir);
+  const apis = new Map(); // dir key -> project api
+  // The last summary served per project: while a changed project is read
+  // again, the portfolio keeps showing it instead of going back to "reading".
+  const lastSummary = new Map(); // dir key -> summary
+
+  /** The projects shown, with stable ids derived from the folder name. */
+  function list() {
+    const dirs = registry.readRegistry().projects.map((p) => ({ dir: p.dir, name: p.name, source: p.source }));
+    if (!dirs.some((p) => lower(p.dir) === lower(launchKey))) {
+      dirs.unshift({ dir: launchKey, name: basename(launchKey), source: 'launch' });
+    }
+    const used = new Map();
+    return dirs.map((p) => {
+      const base = slug(basename(p.dir));
+      const n = (used.get(base) || 0) + 1;
+      used.set(base, n);
+      return { ...p, id: n === 1 ? base : `${base}-${n}`, launch: lower(p.dir) === lower(launchKey) };
+    });
+  }
+
+  function apiFor(dir) {
+    const key = lower(dir);
+    if (!apis.has(key)) apis.set(key, createApi(dir));
+    return apis.get(key);
+  }
+
+  function byId(id) {
+    return list().find((p) => p.id === id) || null;
+  }
+
+  /** The project a changed path belongs to — the deepest registered folder containing it. */
+  function ownerOf(path) {
+    const p = lower(String(path).replace(/\\/g, '/'));
+    let best = null;
+    for (const proj of list()) {
+      const d = lower(proj.dir);
+      if ((p === d || p.startsWith(`${d}/`)) && (!best || d.length > best.dir.length)) best = { ...proj, dir: d };
+    }
+    return best ? list().find((x) => x.id === best.id) : null;
+  }
+
+  function suggestions() {
+    const projects = list();
+    const roots = [...new Set(projects.map((p) => dirname(p.dir)))];
+    return registry.discoverProjects(roots).filter((s) => !projects.some((p) => lower(p.dir) === lower(s.dir)));
+  }
+
+  /** Read the next project that is not in memory yet. @returns {object|null} the project warmed */
+  function warmNext() {
+    const next = list().find((p) => !apiFor(p.dir).ready());
+    if (!next) return null;
+    apiFor(next.dir).warm();
+    return next;
+  }
+
+  function projectsBody() {
+    return {
+      launch: list().find((p) => p.launch)?.id || null,
+      projects: list().map((p) => {
+        const api = apiFor(p.dir);
+        let summary = lastSummary.get(lower(p.dir)) || null;
+        if (api.ready()) {
+          try {
+            summary = api.summary();
+            lastSummary.set(lower(p.dir), summary);
+          } catch { /* keep the last one */ }
+        }
+        return { id: p.id, dir: p.dir, name: summary?.name || p.name, launch: p.launch, source: p.source, summary };
+      }),
+      suggestions: suggestions(),
+    };
+  }
+
+  const json = (status, body) => ({ status, body });
+
+  /**
+   * @param {string} method
+   * @param {string} url - relative to `/api/morph`
+   * @param {object|null} [body] - parsed JSON of a POST
+   */
+  function handle(method, url, body = null) {
+    const u = new URL(url, 'http://local');
+    const parts = u.pathname.split('/').filter(Boolean);
+    try {
+      if (parts[0] === 'projects' && parts.length === 1) {
+        if (method === 'GET') return json(200, projectsBody());
+        if (method === 'POST') {
+          const dir = body?.dir;
+          if (typeof dir !== 'string' || !dir) return json(400, { error: 'informe o caminho do projeto' });
+          if (!registry.isMorphProject(dir)) return json(400, { error: 'esta pasta não tem .morph/config/config.json: rode morph-spec init nela primeiro' });
+          return registry.registerProject(dir, 'manual')
+            ? json(200, projectsBody())
+            : json(400, { error: 'não foi possível registrar esta pasta' });
+        }
+        if (method === 'DELETE') {
+          const dir = u.searchParams.get('dir') || '';
+          registry.unregisterProject(dir);
+          lastSummary.delete(lower(registry.projectKey(dir)));
+          return json(200, projectsBody());
+        }
+        return json(405, { error: 'método não suportado' });
+      }
+      if (parts[0] === 'p' && parts.length >= 2) {
+        const project = byId(decodeURIComponent(parts[1]));
+        if (!project) return json(404, { error: `projeto "${parts[1]}" não está no portfólio` });
+        const rest = `/${parts.slice(2).join('/')}${u.search}`;
+        return apiFor(project.dir).handle(rest);
+      }
+      return json(404, { error: 'rota desconhecida' });
+    } catch (err) {
+      return json(500, { error: err?.message || String(err) });
+    }
+  }
+
+  function invalidate(project, scope, path, event) {
+    apiFor(project.dir).invalidate(scope, path, event);
+  }
+
+  return { list, byId, ownerOf, handle, invalidate, warmNext, suggestions };
+}

package/src/dashboard/scanner/project-api.js

@@ -0,0 +1,195 @@
+/**
+ * The live half of the dashboard: the project's features and activity, served
+ * as JSON by the Vite dev server (`/api/morph/*`) and refreshed when `.morph/`
+ * changes on disk. The framework knowledge stays in the static virtual module.
+ *
+ * Two caches with two lifetimes. A running agent appends to `events.jsonl` on
+ * every tool call, so a log change drops only the event cache — rescanning the
+ * features (git calls for the active ones) on each tool call would be waste.
+ */
+
+import { join } from 'path';
+import { existsSync, readdirSync } from 'fs';
+import { scanFeatures, readFeatureDetail, readFeatureFile } from './features-scanner.js';
+import { createEventStore, buildFeed, lastActivityByFeature, ALL_KINDS, DEFAULT_KINDS } from './activity-scanner.js';
+import { WORKTREE_DIR_NAMES } from '../../lib/worktree/dirs.js';
+import { isFinished } from './feature-status.js';
+import { resolveFeatureTree } from '../../lib/worktree/feature-truth.js';
+
+/** How long a remembered "which tree owns this feature" answer is trusted without a structural change. */
+const TREE_TTL_MS = 60_000;
+
+/**
+ * Which cache a changed path invalidates, or null when it is none of ours.
+ * `.morph/framework/` is the installed framework copy (often a junction), and
+ * it never changes what this API returns.
+ *
+ * @param {string} path
+ * @returns {'activity'|'features'|null}
+ */
+export function classifyChange(path) {
+  const p = String(path).replace(/\\/g, '/');
+  if (!p.includes('/.morph/') && !p.endsWith('/.morph')) return null;
+  if (p.includes('/.morph/framework/') || p.endsWith('/.morph/framework')) return null;
+  if (p.includes('/.morph/logs/')) return 'activity';
+  if (/\/\.morph\/(features|archive|config)(\/|$)/.test(p) || p.endsWith('/.morph/state.json')) return 'features';
+  return null;
+}
+
+/**
+ * A full-page reload Vite would send for a file under a project's `.morph/`
+ * (an agent writing a design .html). The dashboard's own code never lives
+ * there, so such a reload is never needed.
+ */
+export function isMorphDataReload(path) {
+  return typeof path === 'string' && path.replace(/\\/g, '/').includes('/.morph/');
+}
+
+/**
+ * The directories worth watching: the root's and each worktree's feature,
+ * archive, log and config folders — never a whole worktree (its node_modules).
+ */
+export function watchTargets(projectDir) {
+  const morphDirs = [join(projectDir, '.morph')];
+  for (const name of WORKTREE_DIR_NAMES) {
+    let entries = [];
+    try { entries = readdirSync(join(projectDir, name), { withFileTypes: true }); } catch { continue; }
+    for (const e of entries) {
+      if (e.isDirectory()) morphDirs.push(join(projectDir, name, e.name, '.morph'));
+    }
+  }
+  const targets = [];
+  for (const dir of morphDirs) {
+    for (const sub of ['features', 'archive', 'logs', 'config', 'state.json']) {
+      const p = join(dir, sub);
+      if (existsSync(p)) targets.push(p);
+    }
+  }
+  return targets;
+}
+
+function json(status, body) {
+  return { status, body };
+}
+
+/**
+ * @param {string} projectDir
+ * @param {{ scanFeatures?: Function, readFeatureDetail?: Function,
+ *   readFeatureFile?: Function, loadEvents?: Function, resolveTree?: Function,
+ *   now?: () => number }} [deps] - test seams
+ */
+export function createProjectApi(projectDir, deps = {}) {
+  const scan = deps.scanFeatures || scanFeatures;
+  const detail = deps.readFeatureDetail || readFeatureDetail;
+  const file = deps.readFeatureFile || readFeatureFile;
+  const store = createEventStore(projectDir, deps.loadEvents
+    ? { loadTrees: () => [{ tree: 'root', path: projectDir, events: deps.loadEvents(projectDir) }] }
+    : {});
+  const cache = { features: null };
+
+  // Which tree owns a feature costs a few git calls (~0.3 s each on Windows)
+  // and only changes when a file or folder appears or disappears — never when
+  // an agent rewrites feature.json or tasks.json, which is what happens all
+  // the time. Remembered per feature; a structural change or TTL_MS forgets it.
+  const resolveTree = deps.resolveTree || resolveFeatureTree;
+  const now = deps.now || Date.now;
+  const trees = new Map();
+  const rememberedTree = (name, dir) => {
+    const hit = trees.get(name);
+    if (hit && now() - hit.at < TREE_TTL_MS) return hit.value;
+    const value = resolveTree(name, dir);
+    trees.set(name, { value, at: now() });
+    return value;
+  };
+
+  const features = () => (cache.features ||= scan(projectDir, { resolveTree: rememberedTree }));
+  const events = () => store.events();
+  // Where the list scan found each feature: opening one reuses it instead of
+  // asking git again.
+  const known = (name) => features().features?.find((f) => f.name === name) || undefined;
+
+  /**
+   * @param {'features'|'activity'|'all'} scope
+   * @param {string} [path] - the file that changed; a live log is then tailed
+   *   instead of reloading every log
+   * @param {string} [event] - the watcher event; anything but 'change' (a file
+   *   or folder added or removed) may move a feature to another tree
+   */
+  function invalidate(scope, path, event) {
+    if (scope === 'features' || scope === 'all') cache.features = null;
+    if (scope === 'all' || (scope === 'features' && event !== 'change')) trees.clear();
+    if (scope === 'all') store.reset();
+    else if (scope === 'activity') store.changed(path);
+  }
+
+  /**
+   * @param {string} url - path + query, relative to `/api/morph`
+   * @returns {{ status: number, body: object }}
+   */
+  function handle(url) {
+    const u = new URL(url, 'http://local');
+    const parts = u.pathname.split('/').filter(Boolean).map(decodeURIComponent);
+    try {
+      if (parts[0] === 'features' && parts.length === 1) {
+        const scan = features();
+        const last = lastActivityByFeature(events());
+        return json(200, { ...scan, features: scan.features.map((f) => ({ ...f, lastActivity: last[f.name] || null })) });
+      }
+      if (parts[0] === 'features' && parts.length === 2) {
+        const d = detail(projectDir, parts[1], { known: known(parts[1]), resolveTree: rememberedTree });
+        return d ? json(200, d) : json(404, { error: `feature "${parts[1]}" não encontrada` });
+      }
+      if (parts[0] === 'file' && parts.length === 1) {
+        const name = u.searchParams.get('feature') || '';
+        const r = file(projectDir, name, u.searchParams.get('path') || '', { known: known(name), resolveTree: rememberedTree });
+        return r.error ? json(r.status, { error: r.error }) : json(200, r);
+      }
+      if (parts[0] === 'activity' && parts.length === 1) {
+        const feature = u.searchParams.get('feature') || undefined;
+        const kindsParam = u.searchParams.get('kinds');
+        const kinds = kindsParam ? kindsParam.split(',').filter((k) => ALL_KINDS.includes(k)) : DEFAULT_KINDS;
+        const limit = Math.min(Number(u.searchParams.get('limit')) || 100, 500);
+        const all = events();
+        const feed = buildFeed(all, { feature, kinds, before: u.searchParams.get('before') || undefined, limit });
+        return json(200, { ...feed, kinds, cost: feature ? store.cost(feature) : null });
+      }
+      return json(404, { error: 'rota desconhecida' });
+    } catch (err) {
+      return json(500, { error: err?.message || String(err) });
+    }
+  }
+
+  /** Load everything once, so the first page a person opens does not pay for it. */
+  function warm() {
+    try { features(); events(); } catch { /* the first request will report it */ }
+  }
+
+  /** Cheap to answer now: the list and the events are both in memory. */
+  function ready() {
+    return cache.features !== null && store.ready();
+  }
+
+  /**
+   * What the portfolio shows of this project: counts, the active features with
+   * their last activity, and when anything last happened.
+   */
+  function summary() {
+    const scan = features();
+    const last = lastActivityByFeature(events());
+    const active = scan.features.filter((f) => !isFinished(f)).map((f) => ({ ...f, lastActivity: last[f.name] || null }));
+    const lastTs = Object.values(last).reduce((m, a) => (a.ts > m ? a.ts : m), '');
+    return {
+      name: scan.project.name,
+      stack: scan.project.stack,
+      trust: scan.project.trust,
+      legacyStateOnly: scan.project.legacyStateOnly,
+      total: scan.features.length,
+      active: active.length,
+      awaiting: active.filter((f) => f.awaiting).length,
+      activeFeatures: active,
+      lastActivityTs: lastTs || null,
+    };
+  }
+
+  return { handle, invalidate, warm, ready, summary };
+}

package/src/dashboard/scanner/rules-scanner.js

@@ -1,37 +1,42 @@
-import { readFileSync, readdirSync, existsSync } from 'fs';
-import { join, basename } from 'path';
-
-function parseFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!match) return { paths: [], stacks: [] };
-  const yaml = match[1];
-  const paths = []; const stacks = []; let currentList = null;
-  for (const line of yaml.split('\n')) {
-    if (line.startsWith('paths:')) { currentList = paths; continue; }
-    if (line.startsWith('stacks:')) { currentList = stacks; continue; }
-    if (line.match(/^\w/)) { currentList = null; continue; }
-    if (currentList !== null) {
-      const m = line.match(/^\s+-\s+"?(.+?)"?\s*$/);
-      if (m) currentList.push(m[1]);
-    }
-  }
-  return { paths, stacks };
-}
-
-function extractStandardRefs(content) {
-  const refs = [];
-  const regex = /@\.morph\/framework\/standards\/(.+\.md)/g;
-  let m;
-  while ((m = regex.exec(content)) !== null) refs.push(m[1]);
-  return refs;
-}
-
-export function scanRules(frameworkDir) {
-  const dir = join(frameworkDir, 'rules');
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir).filter(f => f.endsWith('.md')).map(f => {
-    const content = readFileSync(join(dir, f), 'utf8');
-    const { paths, stacks } = parseFrontmatter(content);
-    return { name: basename(f, '.md'), filename: f, paths, stacks, content, standardRefs: extractStandardRefs(content) };
-  });
-}
+import { readFileSync, readdirSync, existsSync } from 'fs';
+import { join, basename } from 'path';
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return { paths: [], stacks: [] };
+  const yaml = match[1];
+  const paths = []; const stacks = []; let currentList = null;
+  for (const line of yaml.split('\n')) {
+    if (line.startsWith('paths:')) { currentList = paths; continue; }
+    if (line.startsWith('stacks:')) { currentList = stacks; continue; }
+    if (line.match(/^\w/)) { currentList = null; continue; }
+    if (currentList !== null) {
+      const m = line.match(/^\s+-\s+"?(.+?)"?\s*$/);
+      if (m) currentList.push(m[1]);
+    }
+  }
+  return { paths, stacks };
+}
+
+/**
+ * Standards a rule imports, each once. RulesMap keys an edge per ref, so a
+ * rule that imports the same standard twice (infrastructure-standards.md did,
+ * up to 8.38.0) drew two edges under one React key.
+ */
+export function extractStandardRefs(content) {
+  const refs = new Set();
+  const regex = /@\.morph\/framework\/standards\/(.+\.md)/g;
+  let m;
+  while ((m = regex.exec(content)) !== null) refs.add(m[1]);
+  return [...refs];
+}
+
+export function scanRules(frameworkDir) {
+  const dir = join(frameworkDir, 'rules');
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter(f => f.endsWith('.md')).map(f => {
+    const content = readFileSync(join(dir, f), 'utf8');
+    const { paths, stacks } = parseFrontmatter(content);
+    return { name: basename(f, '.md'), filename: f, paths, stacks, content, standardRefs: extractStandardRefs(content) };
+  });
+}

package/src/dashboard/scanner/skills-scanner.js

@@ -1,43 +1,105 @@
-import { readFileSync, readdirSync, existsSync } from 'fs';
-import { join } from 'path';
-
-function parseYamlFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!match) return {};
-  const yaml = {};
-  for (const line of match[1].split('\n')) {
-    const colonIdx = line.indexOf(':');
-    if (colonIdx === -1) continue;
-    const key = line.slice(0, colonIdx).trim();
-    let value = line.slice(colonIdx + 1).trim();
-    if (value === 'true') value = true;
-    else if (value === 'false') value = false;
-    yaml[key] = value;
-  }
-  return yaml;
-}
-
-export function scanSkills(frameworkDir) {
-  const skillsDir = join(frameworkDir, 'skills');
-  if (!existsSync(skillsDir)) return [];
-  const skills = [];
-  for (const levelDir of readdirSync(skillsDir, { withFileTypes: true })) {
-    if (!levelDir.isDirectory()) continue;
-    const levelPath = join(skillsDir, levelDir.name);
-    for (const skillDir of readdirSync(levelPath, { withFileTypes: true })) {
-      if (!skillDir.isDirectory()) continue;
-      const skillPath = join(levelPath, skillDir.name, 'SKILL.md');
-      if (!existsSync(skillPath)) continue;
-      const content = readFileSync(skillPath, 'utf8');
-      const fm = parseYamlFrontmatter(content);
-      skills.push({
-        id: skillDir.name, name: fm.name || skillDir.name,
-        description: fm.description || '', level: levelDir.name,
-        userInvocable: fm['user-invocable'] === true || fm['user-invocable'] === 'true',
-        allowedTools: typeof fm['allowed-tools'] === 'string' ? fm['allowed-tools'].split(',').map(t => t.trim()) : [],
-        content,
-      });
-    }
-  }
-  return skills;
-}
+import { readFileSync, readdirSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/** One-line `key: value` frontmatter. CRLF-safe: a checkout with autocrlf is still read. */
+export function parseFrontmatter(content) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+  if (!match) return {};
+  const out = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const idx = line.indexOf(':');
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    let value = line.slice(idx + 1).trim().replace(/^["']|["']$/g, '');
+    if (value === 'true') value = true;
+    else if (value === 'false') value = false;
+    out[key] = value;
+  }
+  return out;
+}
+
+const FENCE = /^(\s*)```/;
+const DISPATCH_HINT = /dispatch|despach|subagent_type|Template do prompt/i;
+const PERSONA_REF = /morph-(\{id\}|\{task\.agent\}|[a-z][a-z-]*[a-z])/g;
+/** Words after `morph-` that are skills or CLI verbs, never personas. */
+/** Claude Code's own sub-agents: dispatched by skills, but not personas of agents.json. */
+const BUILTIN_AGENT = /`(Explore|general-purpose|Plan)`/g;
+const NOT_PERSONA = /^(spec|proposal|brainstorming|stack-scan|uiux|plan|implement|apply|review|eval|hotfix|standards|media|task)$/;
+
+/**
+ * The prompts a skill tells the orchestrator to send to a sub-agent: fenced
+ * blocks that are either written as a dispatch (`dispatch Agent (…)`) or sit
+ * right under a line about dispatching. Each carries the personas it names —
+ * `generic` when the template is `morph-{id}` (any implementer).
+ *
+ * @returns {Array<{ index: number, personas: string[], generic: boolean, builtin: string[], context: string, text: string }>}
+ */
+export function extractDispatchPrompts(content) {
+  const lines = content.split(/\r?\n/);
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const open = FENCE.exec(lines[i]);
+    if (!open) continue;
+    let j = i + 1;
+    while (j < lines.length && !FENCE.test(lines[j])) j++;
+    const body = lines.slice(i + 1, j);
+    const text = body.map((l) => l.slice(Math.min(open[1].length, l.length - l.trimStart().length))).join('\n');
+    // Only the sentence that introduces the block counts: a paragraph further up
+    // that mentions a dispatch (morph-apply's DAG example) is not this block's.
+    let k = i - 1;
+    while (k >= 0 && lines[k].trim() === '') k--;
+    const before = k >= 0 && i - k <= 2 ? lines[k] : '';
+    const builtin = [...before.matchAll(BUILTIN_AGENT)].map((m) => m[1]);
+    const isDispatch = /^\s*dispatch\s+Agent/i.test(body[0] || '')
+      || (DISPATCH_HINT.test(before) && (/morph-/.test(before + text) || builtin.length > 0));
+    if (isDispatch) {
+      const refsIn = (str) => [...str.matchAll(PERSONA_REF)].map((m) => m[1]);
+      const personasOf = (refs) => [...new Set(refs.filter((r) => !r.startsWith('{') && !NOT_PERSONA.test(r)))];
+      const refs = refsIn(`${before}\n${text}`);
+      const generic = refs.some((r) => r.startsWith('{'));
+      let personas = personasOf(refs);
+      // "Template do prompt:" names no one; the step that introduces it does.
+      if (!generic && personas.length === 0 && builtin.length === 0) {
+        personas = personasOf(refsIn(lines.slice(Math.max(0, k - 8), k).join('\n')));
+      }
+      const others = !generic && personas.length === 0 ? [...new Set(builtin)] : [];
+      out.push({ index: out.length, personas, generic, builtin: others, context: before.trim().slice(0, 240), text });
+    }
+    i = j;
+  }
+  return out;
+}
+
+export function scanSkills(frameworkDir, phases = []) {
+  const skillsDir = join(frameworkDir, 'skills');
+  if (!existsSync(skillsDir)) return [];
+  const phaseOf = new Map(phases.filter((p) => p.skill).map((p) => [p.skill, p.id]));
+  const skills = [];
+  for (const levelDir of readdirSync(skillsDir, { withFileTypes: true })) {
+    if (!levelDir.isDirectory()) continue;
+    const levelPath = join(skillsDir, levelDir.name);
+    for (const skillDir of readdirSync(levelPath, { withFileTypes: true })) {
+      if (!skillDir.isDirectory()) continue;
+      const skillPath = join(levelPath, skillDir.name, 'SKILL.md');
+      if (!existsSync(skillPath)) continue;
+      const content = readFileSync(skillPath, 'utf8');
+      const fm = parseFrontmatter(content);
+      // The framework spells it `user-invokable`; the Claude Code docs say `user-invocable`.
+      const invocable = fm['user-invokable'] ?? fm['user-invocable'];
+      skills.push({
+        id: skillDir.name,
+        name: fm.name || skillDir.name,
+        description: fm.description || '',
+        whenToInvoke: fm['when-to-invoke'] || '',
+        level: levelDir.name,
+        userInvocable: invocable === true || invocable === 'true',
+        stacks: typeof fm.stacks === 'string' ? fm.stacks.replace(/[[\]]/g, '').split(',').map((s) => s.trim()).filter(Boolean) : [],
+        allowedTools: typeof fm['allowed-tools'] === 'string' ? fm['allowed-tools'].split(',').map((t) => t.trim()) : [],
+        phase: phaseOf.get(skillDir.name) || null,
+        dispatches: extractDispatchPrompts(content),
+        content,
+      });
+    }
+  }
+  return skills.sort((a, b) => a.id.localeCompare(b.id));
+}

package/src/dashboard/scanner/standards-scanner.js

@@ -31,6 +31,8 @@ export function scanStandards(frameworkDir, agents) {
       id: std.id, name: std.name, path: std.path, category: std.category,
       subcategory: std.subcategory || null, tags: std.tags || [],
       digest: std.digest || '', stacks: std.stacks || [],
+      aliases: std.aliases || [], anchors: std.anchors || {},
+      provedBy: std.provedBy || [], verifiedAgainst: std.verifiedAgainst || null,
       content: existsSync(mdPath) ? readFileSync(mdPath, 'utf8') : '',
       referencedBy: refMap[std.id] || [],
     };