@polymorphism-tech/morph-spec 8.38.0 → 8.40.0

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

@@ -1,6 +1,50 @@
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
-import { personaStandardIds } from '../../utils/agents-installer.js';
+import { personaStandardIds, isImplementer, renderAgentMd, loadKnownMcpIds } from '../../utils/agents-installer.js';
+
+/** A line of a phase skill that dispatches a sub-agent. */
+const DISPATCH_LINE = /despach|dispatch|subagent_type/i;
+
+/** The generic dispatch token: "the implementer of the task's domain". */
+const GENERIC_DISPATCH = 'morph-{id}';
+
+/**
+ * Which phases each persona works in, read from the phase skills themselves.
+ *
+ * v5 has no phase list on the persona: a phase dispatches a persona when its
+ * skill (`phases.json → skill`) names `morph-{personaId}` on a dispatch line
+ * (morph-uiux → ui-designer, morph-plan → scout, morph-review → evaluator).
+ * A skill that dispatches the generic `morph-{id}` runs every implementer —
+ * the same `isImplementer` the validator and the installer use.
+ *
+ * Only dispatch lines count: morph-plan cites `morph-dotnet-senior` as a
+ * spelling example of the `agent` field, which dispatches nobody.
+ *
+ * @param {string} frameworkDir
+ * @param {Record<string, object>} agents - agents.json `agents` map
+ * @returns {Map<string, string[]>} personaId → phase ids, in phase order
+ */
+export function personaPhases(frameworkDir, agents) {
+  const result = new Map(Object.keys(agents).map((id) => [id, []]));
+  const phasesJsonPath = join(frameworkDir, 'phases.json');
+  if (!existsSync(phasesJsonPath)) return result;
+
+  const phases = Object.values(JSON.parse(readFileSync(phasesJsonPath, 'utf8')).phases || {})
+    .sort((a, b) => a.index - b.index);
+  for (const phase of phases) {
+    const skillPath = join(frameworkDir, 'skills', 'core', phase.skill || '', 'SKILL.md');
+    if (!phase.skill || !existsSync(skillPath)) continue;
+    const dispatchLines = readFileSync(skillPath, 'utf8').split(/\r?\n/).filter((l) => DISPATCH_LINE.test(l));
+    const generic = dispatchLines.some((l) => l.includes(GENERIC_DISPATCH));
+    for (const [id, agent] of Object.entries(agents)) {
+      const named = new RegExp(`morph-${id}(?![\\w-])`);
+      if ((generic && isImplementer(agent)) || dispatchLines.some((l) => named.test(l))) {
+        result.get(id).push(phase.id);
+      }
+    }
+  }
+  return result;
+}
 
 /**
  * Scan agents.json (v5) — flat domain personas, no tiers.
@@ -12,6 +56,14 @@ export function scanAgents(frameworkDir) {
     return { version: 'unknown', total: 0, list: [] };
   }
   const agentsJson = JSON.parse(readFileSync(agentsJsonPath, 'utf8'));
+  const phasesOf = personaPhases(frameworkDir, agentsJson.agents);
+  const knownMcpIds = loadKnownMcpIds(frameworkDir);
+  // The exact `.claude/agents/morph-{id}.md` the installer writes: the system
+  // prompt the sub-agent actually runs with. A persona whose data the renderer
+  // refuses shows the refusal instead of hiding the persona.
+  const promptOf = (id, agent) => {
+    try { return renderAgentMd({ id, ...agent }, knownMcpIds); } catch (err) { return `<!-- não renderizou: ${err.message} -->`; }
+  };
   const list = Object.entries(agentsJson.agents).map(([id, agent]) => ({
     id,
     title: agent.title,
@@ -24,7 +76,13 @@ export function scanAgents(frameworkDir) {
     standards: personaStandardIds(agent),
     surfaces: agent.surfaces || null,
     stack: agent.stack || ['*'],
+    activePhases: phasesOf.get(id),
     persona: agent.persona || '',
+    model: agent.model || null,
+    maxTurns: agent.maxTurns ?? null,
+    tools: agent.tools || null,
+    mcp: agent.mcp || [],
+    prompt: promptOf(id, agent),
   }));
   return {
     version: agentsJson.version,

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

@@ -0,0 +1,59 @@
+/**
+ * The reading material of the framework — the charter, the runtime
+ * instructions, the CLI reference and the rubrics the evaluator scores with —
+ * for the dashboard's Guide and Rubrics pages.
+ */
+import { readFileSync, readdirSync, existsSync } from 'fs';
+import { join } from 'path';
+
+function read(path) {
+  try { return readFileSync(path, 'utf8'); } catch { return null; }
+}
+
+/** `## Heading` lines, the table of contents a long document is read by. */
+export function headingsOf(content) {
+  const out = [];
+  let inFence = false;
+  for (const line of String(content).split(/\r?\n/)) {
+    if (/^\s*```/.test(line)) { inFence = !inFence; continue; }
+    if (inFence) continue;
+    const m = /^(#{1,3})\s+(.+?)\s*#*\s*$/.exec(line);
+    if (m) out.push({ depth: m[1].length, text: m[2].replace(/[`*_]/g, '') });
+  }
+  return out;
+}
+
+function titleOf(content, fallback) {
+  const h = headingsOf(content || '').find((x) => x.depth === 1);
+  return h?.text || fallback;
+}
+
+function mdDir(dir) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((f) => f.endsWith('.md'))
+    .sort()
+    .map((f) => {
+      const content = read(join(dir, f)) || '';
+      return { id: f.replace(/\.md$/, ''), file: f, title: titleOf(content, f.replace(/\.md$/, '')), content };
+    });
+}
+
+const GUIDE = [
+  { id: 'morph', path: 'MORPH.md', title: 'Carta do harness (MORPH.md)', summary: 'Como o Claude trabalha: papéis, fases, gates, sub-agents. É a fonte única do comportamento.' },
+  { id: 'runtime', path: 'CLAUDE.md', title: 'Instruções de runtime (CLAUDE.md)', summary: 'O que é injetado no CLAUDE.md do projeto: como começar cada sessão, regras críticas, comandos.' },
+  { id: 'cli', path: 'docs/CLI.md', title: 'Referência do CLI', summary: 'Todos os comandos morph-spec: gates, verify, worktrees, grafo, telemetria.' },
+];
+
+export function scanDocs(frameworkDir) {
+  const guide = GUIDE.map((g) => {
+    const content = read(join(frameworkDir, ...g.path.split('/'))) || '';
+    return { ...g, content, headings: headingsOf(content).filter((h) => h.depth <= 3) };
+  }).filter((g) => g.content);
+
+  return {
+    guide,
+    rubrics: mdDir(join(frameworkDir, 'evals', 'rubrics')),
+    proofRubrics: mdDir(join(frameworkDir, 'evals', 'proof-rubrics')),
+  };
+}

package/src/dashboard/scanner/feature-status.js

@@ -0,0 +1,10 @@
+/**
+ * When a feature counts as finished — the one rule the portfolio (server) and
+ * the feature list (client) share. Pure, no node imports: the client bundles it.
+ *
+ * A feature in `.morph/archive/` is closed whatever its status says: legacy
+ * archives keep `draft` or `in_progress` from before `finish` set the status.
+ */
+export function isFinished(f) {
+  return f?.status === 'completed' || f?.status === 'abandoned' || f?.location === 'archive';
+}

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

@@ -0,0 +1,360 @@
+/**
+ * The dashboard's view of the target project's features — the ONLY scanner
+ * that reads the project rather than the framework package.
+ *
+ * Every rule here is borrowed, never re-encoded:
+ *   - which tree owns a feature  → `resolveFeatureTree` (feature-truth.js)
+ *   - the current phase          → `derivePhaseFrom` (state-reader.js)
+ *   - gate order                 → `GATE_PREREQ` (gate-order.js)
+ *   - the evaluator's verdict    → `evaluatorVerdictFromText` (evaluator-report.js)
+ *   - path confinement           → `canonicalPath`/`isInside` (test-runner.js)
+ *   - tasks.json validity        → `validateTasksJson` (tasks-json-parser.js)
+ *
+ * Three places a feature can live: the root `.morph/features/{f}`, a worktree
+ * `{worktrees}/{wt}/.morph/features/{f}`, and `.morph/archive/{f}` once
+ * `finish` ran. The root copy of a feature built in a worktree is its
+ * birth-instant skeleton and never changes again, so for an active feature the
+ * owner tree wins. Only active features pay for that question — it spawns git.
+ *
+ * Read-only and fail-open: a corrupt file degrades one feature, never the scan.
+ */
+
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join, basename, isAbsolute } from 'path';
+import { derivePhaseFrom, PHASE_ARTIFACTS } from '../../../framework/hooks/shared/state-reader.js';
+import { GATE_PREREQ } from '../../core/state/gate-order.js';
+import { validateTasksJson } from '../../lib/tasks/tasks-json-parser.js';
+import { evaluatorVerdictFromText } from '../../lib/evaluator-report.js';
+import { resolveFeatureTree } from '../../lib/worktree/feature-truth.js';
+import { WORKTREE_DIR_NAMES } from '../../lib/worktree/dirs.js';
+import { canonicalPath, isInside, readMorphConfig } from '../../lib/tasks/test-runner.js';
+import { isFinished } from './feature-status.js';
+
+export const GATES = Object.keys(GATE_PREREQ);
+const FINISHED = new Set(['completed', 'abandoned']);
+const FOLDER_PHASE = Object.fromEntries(PHASE_ARTIFACTS.map(([folder, phase]) => [folder, phase]));
+const EVALUATOR_REPORT = '4-review/evaluator-report.md';
+const MAX_FILE_BYTES = 2 * 1024 * 1024;
+const MAX_DEPTH = 4;
+
+function readJson(path) {
+  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
+}
+
+function subdirs(dir) {
+  try {
+    return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch { return []; }
+}
+
+/**
+ * Old feature.json files stamped a gate as a bare `true` (MORPH_OS). Lifting it
+ * to `{approved: true}` is what lets the shared rules read them unchanged.
+ */
+export function normalizeGates(gates) {
+  const out = {};
+  for (const [name, value] of Object.entries(gates || {})) {
+    out[name] = value === true ? { approved: true } : (value && typeof value === 'object' ? value : { approved: false });
+  }
+  return out;
+}
+
+function normalizeFeature(fj) {
+  const f = fj && typeof fj === 'object' ? fj : {};
+  return { ...f, approvalGates: normalizeGates(f.approvalGates || f.approvals) };
+}
+
+/**
+ * Every place a feature lives, before deciding which one tells the truth.
+ * @returns {Map<string, {root?: string, worktrees: string[], archive?: string}>}
+ */
+function collectLocations(projectDir) {
+  const found = new Map();
+  const slot = (name) => {
+    if (!found.has(name)) found.set(name, { worktrees: [] });
+    return found.get(name);
+  };
+
+  const rootFeatures = join(projectDir, '.morph', 'features');
+  for (const name of subdirs(rootFeatures)) {
+    if (existsSync(join(rootFeatures, name, 'feature.json'))) slot(name).root = join(rootFeatures, name);
+  }
+  for (const wtDirName of WORKTREE_DIR_NAMES) {
+    for (const wt of subdirs(join(projectDir, wtDirName))) {
+      const wtFeatures = join(projectDir, wtDirName, wt, '.morph', 'features');
+      for (const name of subdirs(wtFeatures)) {
+        if (existsSync(join(wtFeatures, name, 'feature.json'))) slot(name).worktrees.push(join(wtFeatures, name));
+      }
+    }
+  }
+  const archive = join(projectDir, '.morph', 'archive');
+  for (const name of subdirs(archive)) slot(name).archive = join(archive, name);
+  return found;
+}
+
+/**
+ * Decide which directory is this feature's truth.
+ *
+ * @returns {{ location: 'root'|'worktree'|'archive', dir: string, feature: object,
+ *   ownerTree: string|null, rootStale: boolean }}
+ */
+function resolveLocation(projectDir, name, loc, resolveTree) {
+  const rootFj = loc.root ? readJson(join(loc.root, 'feature.json')) : null;
+
+  // Archived: `finish` moved the artifacts. An old root copy may linger (MORPH_OS
+  // keeps a feature.json per finished feature) — the archive holds the files.
+  const rootFinished = rootFj && (FINISHED.has(rootFj.status) || rootFj.archivedAt);
+  if (loc.archive && (!rootFj || rootFinished)) {
+    const archFj = readJson(join(loc.archive, 'feature.json'));
+    return {
+      location: 'archive',
+      dir: loc.archive,
+      feature: archFj || rootFj || { status: 'completed' },
+      ownerTree: null,
+      rootStale: false,
+    };
+  }
+
+  if (rootFj && !FINISHED.has(rootFj.status)) {
+    const truth = resolveTree(name, projectDir);
+    const tree = truth?.tree;
+    if (tree && canonicalPath(tree) !== canonicalPath(projectDir)) {
+      const wtDir = join(tree, '.morph', 'features', name);
+      const wtFj = readJson(join(wtDir, 'feature.json'));
+      if (wtFj) return { location: 'worktree', dir: wtDir, feature: wtFj, ownerTree: tree, rootStale: false };
+      // The owner tree exists but carries no copy of the feature: all we have is
+      // the root skeleton, and the UI has to say so.
+      return { location: 'root', dir: loc.root, feature: rootFj, ownerTree: tree, rootStale: true };
+    }
+  }
+
+  if (rootFj) return { location: 'root', dir: loc.root, feature: rootFj, ownerTree: null, rootStale: false };
+
+  const wtDir = loc.worktrees[0];
+  return {
+    location: 'worktree',
+    dir: wtDir,
+    feature: readJson(join(wtDir, 'feature.json')) || {},
+    ownerTree: join(wtDir, '..', '..', '..'),
+    rootStale: false,
+  };
+}
+
+/**
+ * tasks.json as the dashboard needs it: the list even when the file breaks the
+ * schema (a read-only viewer shows what is there), with the errors alongside.
+ */
+export function readTasks(dir) {
+  const path = join(dir, '2-plan', 'tasks.json');
+  if (!existsSync(path)) return { list: [], errors: [], present: false };
+  const data = readJson(path);
+  if (!data) return { list: [], errors: ['tasks.json não é JSON válido'], present: true };
+  const { valid, errors } = validateTasksJson(data);
+  const list = Array.isArray(data.tasks) ? data.tasks.filter((t) => t && typeof t === 'object') : [];
+  return { list, errors: valid ? [] : errors, present: true };
+}
+
+function taskCounts(list) {
+  const counts = { total: list.length, done: 0, inProgress: 0, blocked: 0, pending: 0, skipped: 0 };
+  for (const t of list) {
+    // `completed` is the pre-schema spelling of `done` (MORPH_OS archives carry both).
+    if (t.status === 'done' || t.status === 'completed') counts.done += 1;
+    else if (t.status === 'in_progress') counts.inProgress += 1;
+    else if (t.status === 'blocked') counts.blocked += 1;
+    else if (t.status === 'skipped') counts.skipped += 1;
+    else counts.pending += 1;
+  }
+  return counts;
+}
+
+function gatesOf(feature) {
+  const skipped = new Set(feature.skippedPhases || []);
+  return GATES.map((gate) => {
+    const g = feature.approvalGates[gate] || { approved: false };
+    const decision = feature.gateDecisions?.[gate] || null;
+    const approved = g.approved === true;
+    return {
+      gate,
+      approved,
+      approvedBy: g.approvedBy ?? (g.auto ? 'auto' : null),
+      at: g.approvedAt || g.timestamp || null,
+      paused: !approved && decision?.pause === true,
+      skipped: skipped.has(gate),
+      reason: decision?.reason ?? null,
+    };
+  });
+}
+
+function evaluatorVerdict(dir) {
+  const path = join(dir, ...EVALUATOR_REPORT.split('/'));
+  if (!existsSync(path)) return null;
+  try { return evaluatorVerdictFromText(readFileSync(path, 'utf8')); } catch { return null; }
+}
+
+function summarize(name, resolved) {
+  const { location, dir, ownerTree, rootStale } = resolved;
+  const feature = normalizeFeature(resolved.feature);
+  const has = (rel) => existsSync(join(dir, ...rel.split('/')));
+  const gates = gatesOf(feature);
+  const reviewApproved = gates.find((g) => g.gate === 'review')?.approved === true;
+  const tasks = readTasks(dir);
+  const verdict = evaluatorVerdict(dir);
+  const status = feature.status || (location === 'archive' ? 'completed' : 'draft');
+  const finished = isFinished({ status, location });
+  return {
+    name,
+    description: feature.description || null,
+    status,
+    workType: feature.workType || null,
+    location,
+    dir,
+    ownerTree,
+    rootStale,
+    phase: derivePhaseFrom(feature, has),
+    inEvaluation: has(EVALUATOR_REPORT) && !reviewApproved,
+    gates,
+    awaiting: !finished && gates.some((g) => g.paused),
+    tasks: taskCounts(tasks.list),
+    // Titles of an active feature's tasks, for the global search. Finished
+    // features leave them out: 170 archived plans would bloat every list reply.
+    taskIndex: finished ? [] : tasks.list.map((t) => ({ id: t.id, title: t.title || '', status: t.status || 'pending' })),
+    verification: feature.verification
+      ? { status: feature.verification.status ?? null, scope: feature.verification.scope ?? null, ts: feature.verification.ts ?? null }
+      : null,
+    score: verdict?.score ?? null,
+    legacyScore: typeof feature.reviewScore === 'number' ? feature.reviewScore : null,
+    createdAt: feature.createdAt || null,
+    updatedAt: feature.updatedAt || feature.archivedAt || feature.createdAt || null,
+    archivedAt: feature.archivedAt || null,
+  };
+}
+
+/**
+ * Files of a feature, grouped by the phase their top folder belongs to.
+ * @returns {Array<{path: string, phase: string|null, size: number, mtime: string}>}
+ */
+export function listDocuments(dir) {
+  const out = [];
+  const walk = (abs, rel, depth) => {
+    let entries;
+    try { entries = readdirSync(abs, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      // A stray `.morph/` under a phase folder is a hook's misplaced log, not a document.
+      if (e.name.startsWith('.')) continue;
+      const childRel = rel ? `${rel}/${e.name}` : e.name;
+      const childAbs = join(abs, e.name);
+      if (e.isDirectory()) {
+        if (depth < MAX_DEPTH) walk(childAbs, childRel, depth + 1);
+        continue;
+      }
+      let st;
+      try { st = statSync(childAbs); } catch { continue; }
+      out.push({
+        path: childRel,
+        phase: FOLDER_PHASE[childRel.split('/')[0]] || null,
+        size: st.size,
+        mtime: st.mtime.toISOString(),
+      });
+    }
+  };
+  walk(dir, '', 0);
+  return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+
+/**
+ * Resolve one feature. `known` is where a previous scan already found it: the
+ * list scan paid for the git calls, and opening a feature or one of its files
+ * must not pay again. It is only trusted while its feature.json still reads.
+ */
+function resolveOne(projectDir, name, resolveTree, known) {
+  if (known?.dir) {
+    const fj = readJson(join(known.dir, 'feature.json'));
+    if (fj) return { location: known.location, dir: known.dir, feature: fj, ownerTree: known.ownerTree ?? null, rootStale: Boolean(known.rootStale) };
+  }
+  const loc = collectLocations(projectDir).get(name);
+  if (!loc) return null;
+  return resolveLocation(projectDir, name, loc, resolveTree);
+}
+
+/**
+ * The feature list of a project.
+ *
+ * @param {string} projectDir
+ * @param {{ resolveTree?: Function }} [opts] - seam for tests; defaults to
+ *   `resolveFeatureTree`
+ */
+export function scanFeatures(projectDir, { resolveTree = resolveFeatureTree } = {}) {
+  const config = readMorphConfig(projectDir);
+  const features = [];
+  for (const [name, loc] of collectLocations(projectDir)) {
+    try {
+      features.push(summarize(name, resolveLocation(projectDir, name, loc, resolveTree)));
+    } catch { /* one unreadable feature never hides the rest */ }
+  }
+  features.sort((a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || ''));
+
+  const hasState = existsSync(join(projectDir, '.morph', 'state.json'));
+  return {
+    project: {
+      name: config?.project?.name || basename(projectDir),
+      stack: config?.project?.stack || null,
+      trust: config?.trust || null,
+      dir: projectDir,
+      initialized: existsSync(join(projectDir, '.morph')),
+      // A project that has state.json but no feature.json anywhere predates the
+      // per-feature state model — the dashboard says so instead of showing "empty".
+      legacyStateOnly: hasState && features.length === 0,
+    },
+    features,
+  };
+}
+
+/**
+ * One feature in full: summary + tasks with their verify/score, the gate
+ * decisions, the verify nodes and the document tree.
+ */
+export function readFeatureDetail(projectDir, name, { resolveTree = resolveFeatureTree, known } = {}) {
+  const resolved = resolveOne(projectDir, name, resolveTree, known);
+  if (!resolved) return null;
+  const summary = summarize(name, resolved);
+  const feature = normalizeFeature(resolved.feature);
+  const tasks = readTasks(resolved.dir);
+  const verdict = evaluatorVerdict(resolved.dir);
+  return {
+    ...summary,
+    tasksList: tasks.list.map((t) => ({
+      ...t,
+      verification: feature.taskVerifications?.[t.id] || null,
+      score: feature.taskScores?.[t.id] || null,
+    })),
+    tasksErrors: tasks.errors,
+    gateDecisions: feature.gateDecisions || {},
+    verificationNodes: feature.verification?.nodes || null,
+    featureVerification: feature.verifications?.feature || null,
+    proofScores: verdict?.proofScores ?? null,
+    documents: listDocuments(resolved.dir),
+    raw: resolved.feature,
+  };
+}
+
+/**
+ * The content of one file of a feature, confined to the feature's directory.
+ * Junctions and win32 case are resolved by `canonicalPath` before the check,
+ * so `..`, an absolute path or a link that leaves the folder are all refused.
+ *
+ * @returns {{ path: string, content: string, mtime: string } | { error: string, status: number }}
+ */
+export function readFeatureFile(projectDir, name, relPath, { resolveTree = resolveFeatureTree, known } = {}) {
+  if (typeof relPath !== 'string' || relPath === '') return { error: 'path ausente', status: 400 };
+  if (isAbsolute(relPath) || /^[a-zA-Z]:/.test(relPath)) return { error: 'path fora da feature', status: 403 };
+  const resolved = resolveOne(projectDir, name, resolveTree, known);
+  if (!resolved) return { error: `feature "${name}" não encontrada`, status: 404 };
+  const base = canonicalPath(resolved.dir);
+  const target = canonicalPath(join(resolved.dir, ...relPath.split(/[\\/]/)));
+  if (!isInside(target, base) || target === base) return { error: 'path fora da feature', status: 403 };
+  let st;
+  try { st = statSync(target); } catch { return { error: 'arquivo não encontrado', status: 404 }; }
+  if (!st.isFile()) return { error: 'não é um arquivo', status: 400 };
+  if (st.size > MAX_FILE_BYTES) return { error: 'arquivo grande demais para exibir', status: 413 };
+  return { path: relPath, content: readFileSync(target, 'utf8'), mtime: st.mtime.toISOString() };
+}

package/src/dashboard/scanner/index.js

@@ -4,17 +4,24 @@ import { scanHooks } from './hooks-scanner.js';
 import { scanSkills } from './skills-scanner.js';
 import { scanStandards } from './standards-scanner.js';
 import { scanRules } from './rules-scanner.js';
-import { scanSquads } from './squads-scanner.js';
 import { scanRubrics } from './rubrics-scanner.js';
-import { scanState } from './state-scanner.js';
+import { scanDocs } from './docs-scanner.js';
 
-export function scanAll(frameworkDir, projectDir) {
+/**
+ * The framework's knowledge, for the static virtual module. The project's
+ * state (features, activity) is served live by project-api.js instead.
+ */
+export function scanAll(frameworkDir) {
   const agents = scanAgents(frameworkDir);
+  const phases = scanPhases(frameworkDir);
   return {
-    agents, phases: scanPhases(frameworkDir), hooks: scanHooks(frameworkDir),
-    skills: scanSkills(frameworkDir), standards: scanStandards(frameworkDir, agents.list),
+    agents,
+    phases,
+    hooks: scanHooks(frameworkDir),
+    skills: scanSkills(frameworkDir, phases.list),
+    standards: scanStandards(frameworkDir, agents.list),
     rules: scanRules(frameworkDir),
-    squads: scanSquads(frameworkDir), rubrics: scanRubrics(frameworkDir),
-    liveState: scanState(projectDir || process.cwd()),
+    rubrics: scanRubrics(frameworkDir),
+    docs: scanDocs(frameworkDir),
   };
 }

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

@@ -1,15 +1,14 @@
-import { readFileSync } from 'fs';
-import { join } from 'path';
-
-export function scanPhases(frameworkDir) {
-  const phasesJson = JSON.parse(readFileSync(join(frameworkDir, 'phases.json'), 'utf8'));
-  const list = Object.values(phasesJson.phases).map((p) => ({
-    id: p.id, index: p.index, folder: p.folder || null, displayName: p.displayName,
-    optional: p.optional || false, goals: p.goals || [], requiredOutputs: p.requiredOutputs || [],
-    optionalOutputs: p.optionalOutputs || [], recommendedMCPs: p.recommendedMCPs || [],
-    pausePoints: p.pausePoints || [], agentTiers: p.agentTiers || [],
-    requiredSkills: p.requiredSkills || [],
-  }));
-  list.sort((a, b) => a.index - b.index);
-  return { version: phasesJson.version, list };
-}
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+export function scanPhases(frameworkDir) {
+  const phasesJson = JSON.parse(readFileSync(join(frameworkDir, 'phases.json'), 'utf8'));
+  const list = Object.values(phasesJson.phases).map((p) => ({
+    id: p.id, index: p.index, folder: p.folder || null, displayName: p.displayName,
+    optional: p.optional || false, goals: p.goals || [], requiredOutputs: p.requiredOutputs || [],
+    optionalOutputs: p.optionalOutputs || [], recommendedMCPs: p.recommendedMCPs || [],
+    pausePoints: p.pausePoints || [], skill: p.skill || null,
+  }));
+  list.sort((a, b) => a.index - b.index);
+  return { version: phasesJson.version, list };
+}