@polymorphism-tech/morph-spec 8.46.0 → 9.0.0

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

@@ -15,10 +15,10 @@ import { loadTelemetryAllTrees, aggregateCost, dedupeEvents } from '../../lib/te
 import { isFailedToolCall } from '../../../framework/hooks/shared/telemetry-logger.js';
 
 /** Kinds a person follows by default; the rest are one click away. */
-export const DEFAULT_KINDS = ['prompt', 'question', 'skill', 'dispatch', 'handback', 'task', 'verify', 'gate', 'failure'];
+export const DEFAULT_KINDS = ['prompt', 'question', 'skill', 'dispatch', 'handback', 'verify', 'gate', 'failure'];
 export const ALL_KINDS = [...DEFAULT_KINDS, 'write', 'read', 'command', 'tool'];
 
-const GATE_COMMAND = /\bmorph-spec\s+(approve|gate-check|gate-decision|advance|score|finish)\b/;
+const GATE_COMMAND = /\bmorph-spec\s+(approve|gate-check|gate-decision|advance|finish)\b/;
 const MORPH_PERSONA = /^morph-(.+)$/;
 const SHELL_TOOLS = new Set(['Bash', 'PowerShell']);
 const SILENT_EVENTS = new Set(['ToolBatch', 'SessionUsage', 'AgentUsage']);
@@ -50,14 +50,14 @@ function nodesSummary(nodes) {
  * @returns {null | {
  *   id: string, ts: string, feature: string|null, phase: string|null,
  *   kind: string, title: string, detail: string|null, status: 'ok'|'fail'|null,
- *   refs: { persona?: string, skill?: string, task?: string, path?: string },
+ *   refs: { persona?: string, skill?: string, path?: string },
  *   nodes?: Array<{name: string, status: string|null}>
  * }}
  */
 export function describeEvent(e) {
   if (!e || typeof e !== 'object' || SILENT_EVENTS.has(e.event)) return null;
   const base = {
-    id: e.eventId || `${e.ts}:${e.event}:${e.tool || ''}:${e.task || ''}`,
+    id: e.eventId || `${e.ts}:${e.event}:${e.tool || ''}`,
     ts: e.ts || null,
     feature: e.feature || null,
     phase: e.phase || null,
@@ -78,18 +78,10 @@ export function describeEvent(e) {
     if (text.startsWith('<')) return null;
     return line('prompt', 'Você escreveu', { detail: clip(text) });
   }
-  if (e.event === 'TaskStart') return line('task', `${e.task} começou`, { refs: { task: e.task } });
-  if (e.event === 'TaskEnd') {
-    const done = e.status === 'done';
-    return line('task', done ? `${e.task} concluída` : `${e.task} terminou (${e.status ?? 'sem status'})`, {
-      status: done ? 'ok' : null, refs: { task: e.task },
-    });
-  }
   if (e.event === 'Verify') {
     const ok = e.status === 'pass';
-    const scope = e.task ? e.task : 'feature inteira';
-    return line('verify', `verify ${scope} ${ok ? 'passou' : 'falhou'}`, {
-      status: ok ? 'ok' : 'fail', nodes: nodesSummary(e.nodes), refs: e.task ? { task: e.task } : {},
+    return line('verify', `verify ${ok ? 'passou' : 'falhou'}`, {
+      status: ok ? 'ok' : 'fail', nodes: nodesSummary(e.nodes),
       detail: e.persisted === false && e.reason ? `não carimbou: ${e.reason}` : null,
     });
   }
@@ -344,8 +336,6 @@ export function featureCost(events, feature) {
     dispatches: c.dispatches,
     bytesTotal: c.bytesTotal,
     bytesByKind: c.bytesByKind,
-    taskDurationSeconds: c.taskDurationSeconds,
-    tasks: c.tasks,
     events: c.total,
   };
 }

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

@@ -13,7 +13,7 @@ const GENERIC_DISPATCH = 'morph-{id}';
  *
  * 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).
+ * (morph-uiux → ui-designer, morph-plan → scout, morph-review → verifier, reviewer, security).
  * A skill that dispatches the generic `morph-{id}` runs every implementer —
  * the same `isImplementer` the validator and the installer use.
  *

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

@@ -1,9 +1,9 @@
 /**
  * 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.
+ * instructions, the CLI reference and the Gate 3 review checklist — for the
+ * dashboard's Guide page.
  */
-import { readFileSync, readdirSync, existsSync } from 'fs';
+import { readFileSync } from 'fs';
 import { join } from 'path';
 
 function read(path) {
@@ -23,26 +23,11 @@ export function headingsOf(content) {
   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.' },
+  { id: 'review-checklist', path: 'evals/review-checklist.md', title: 'Checklist do Gate 3', summary: 'O que verificador, revisor e segurança procuram antes do ship: veredito SHIP/FIX e bloqueador com evidência.' },
 ];
 
 export function scanDocs(frameworkDir) {
@@ -51,8 +36,5 @@ export function scanDocs(frameworkDir) {
     return { ...g, content, headings: headingsOf(content).filter((h) => h.depth <= 3) };
   }).filter((g) => g.content);
 
-  return {
-    guide,
-    rubrics: mdDir(join(frameworkDir, 'evals')).filter((d) => d.id === 'review-checklist'),
-  };
+  return { guide };
 }

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

@@ -6,9 +6,9 @@
  *   - 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)
+ *   - the review verdict         → `reviewReportsFromDir` (review-reports.js)
  *   - path confinement           → `canonicalPath`/`isInside` (test-runner.js)
- *   - tasks.json validity        → `validateTasksJson` (tasks-json-parser.js)
+ *   - slice progress             → `sliceProgress` (slice-progress.js)
  *
  * Three places a feature can live: the root `.morph/features/{f}`, a worktree
  * `{worktrees}/{wt}/.morph/features/{f}`, and `.morph/archive/{f}` once
@@ -21,10 +21,12 @@
 
 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 { derivePhaseFrom, diskArtifactProbe, 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 { sliceProgress, checksPath } from '../../../framework/hooks/shared/slice-progress.js';
+import {
+  reviewReportsFromDir, requiredReviewRoles, combinedVerdict, allBlockers, checksCoverage, reviewFileName, REVIEW_ROLES,
+} from '../../lib/review-reports.js';
 import { resolveFeatureTree } from '../../lib/worktree/feature-truth.js';
 import { containerDirs } from '../../../framework/hooks/shared/worktree-root.js';
 import { canonicalPath, isInside, readMorphConfig } from '../../lib/tasks/test-runner.js';
@@ -33,7 +35,6 @@ 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;
 
@@ -141,31 +142,26 @@ function resolveLocation(projectDir, name, loc, resolveTree) {
 }
 
 /**
- * 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.
+ * The plan's slices with the status their reports give, plus the fields the
+ * extraction carries for the card. `null` when the plan has not been checked yet.
  */
-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 };
+export function readSlices(dir) {
+  const progress = sliceProgress(dir);
+  if (!progress) return null;
+  const extracted = new Map((readJson(checksPath(dir))?.slices || []).filter((x) => x && x.id).map((x) => [x.id, x]));
+  const list = progress.slices.map((sl) => {
+    const x = extracted.get(sl.id) || {};
+    return {
+      ...sl,
+      persona: x.persona ?? null,
+      files: Array.isArray(x.files) ? x.files : [],
+      covers: Array.isArray(x.covers) ? x.covers : [],
+    };
+  });
+  return { counts: { total: progress.total, done: progress.done, partial: progress.partial, pending: progress.pending }, list };
 }
 
-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;
-}
+const NO_SLICES = { total: 0, done: 0, partial: 0, pending: 0 };
 
 function gatesOf(feature) {
   const skipped = new Set(feature.skippedPhases || []);
@@ -185,20 +181,67 @@ function gatesOf(feature) {
   });
 }
 
-function evaluatorVerdict(dir) {
-  const path = join(dir, ...EVALUATOR_REPORT.split('/'));
-  if (!existsSync(path)) return null;
-  try { return evaluatorVerdictFromText(readFileSync(path, 'utf8')); } catch { return null; }
+// Security counts only when its report exists: deciding it is required takes git.
+function reviewVerdict(dir, workType, reports = reviewReportsFromDir(dir)) {
+  const present = Object.values(reports).some((r) => r.status !== 'missing');
+  if (!present) return null;
+  const required = requiredReviewRoles({ workType, securityRequired: reports.security.status !== 'missing' });
+  return { verdict: combinedVerdict(reports, required), blockers: allBlockers(reports) };
+}
+
+/**
+ * One row per review report the feature asks for or already has: status,
+ * verdict, blockers and the SHA it reviewed.
+ */
+export function reviewRows(reports, workType) {
+  const required = requiredReviewRoles({ workType, securityRequired: reports.security.status !== 'missing' });
+  return Object.keys(REVIEW_ROLES)
+    .filter((role) => required.includes(role) || reports[role].status !== 'missing')
+    .map((role) => {
+      const r = reports[role];
+      return {
+        role,
+        path: `4-review/${reviewFileName(role)}`,
+        status: r.status,
+        verdict: r.verdict ?? null,
+        blockers: r.blockers?.length ?? 0,
+        reviewedSha: r.reviewedSha ?? null,
+      };
+    });
+}
+
+/**
+ * The plan's scenarios, each with the verifier's row for it. `coverage` is
+ * `null` until a verifier report exists; only PROVADO covers.
+ */
+export function readChecks(dir, verifier) {
+  const checks = readJson(checksPath(dir))?.checks;
+  if (!Array.isArray(checks)) return null;
+  const list = checks.filter((c) => c && c.id);
+  const rows = verifier?.checks ?? null;
+  const byId = new Map((rows ?? []).map((r) => [r.id, r]));
+  const coverage = verifier && verifier.status !== 'missing'
+    ? { total: list.length, ...checksCoverage(list.map((c) => c.id), rows) }
+    : null;
+  return {
+    coverage,
+    list: list.map((c) => ({
+      id: c.id,
+      text: c.text ?? '',
+      proof: c.proof ?? null,
+      status: byId.get(c.id)?.status ?? null,
+      evidence: byId.get(c.id)?.evidence ?? 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 slices = readSlices(dir);
+  const verdict = reviewVerdict(dir, feature.workType);
   const status = feature.status || (location === 'archive' ? 'completed' : 'draft');
   const finished = isFinished({ status, location });
   return {
@@ -210,19 +253,19 @@ function summarize(name, resolved) {
     dir,
     ownerTree,
     rootStale,
-    phase: derivePhaseFrom(feature, has),
-    inEvaluation: has(EVALUATOR_REPORT) && !reviewApproved,
+    phase: derivePhaseFrom(feature, diskArtifactProbe(dir)),
+    inEvaluation: verdict !== null && !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
+    slices: slices?.counts ?? NO_SLICES,
+    // Titles of an active feature's slices, 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' })),
+    sliceIndex: finished || !slices ? [] : slices.list.map((sl) => ({ id: sl.id, title: sl.title, status: sl.status })),
     verification: feature.verification
-      ? { status: feature.verification.status ?? null, scope: feature.verification.scope ?? null, ts: feature.verification.ts ?? null }
+      ? { status: feature.verification.status ?? null, ts: feature.verification.ts ?? null }
       : null,
     verdict: verdict?.verdict ?? null,
-    blockers: verdict?.verdict ? verdict.blockers.length : null,
+    blockers: verdict ? verdict.blockers.length : null,
     createdAt: feature.createdAt || null,
     updatedAt: feature.updatedAt || feature.archivedAt || feature.createdAt || null,
     archivedAt: feature.archivedAt || null,
@@ -309,24 +352,21 @@ export function scanFeatures(projectDir, { resolveTree = resolveFeatureTree } =
   };
 }
 
-/**
- * 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);
+  const slices = readSlices(resolved.dir);
+  const reports = reviewReportsFromDir(resolved.dir);
+  const verdict = reviewVerdict(resolved.dir, feature.workType, reports);
+  const checks = readChecks(resolved.dir, reports.verifier);
   return {
     ...summary,
-    tasksList: tasks.list.map((t) => ({
-      ...t,
-      verification: feature.taskVerifications?.[t.id] || null,
-    })),
-    tasksErrors: tasks.errors,
+    slicesList: slices?.list ?? [],
+    checksList: checks?.list ?? [],
+    checksCoverage: checks?.coverage ?? null,
+    reviews: reviewRows(reports, feature.workType),
     gateDecisions: feature.gateDecisions || {},
     verificationNodes: feature.verification?.nodes || null,
     featureVerification: feature.verifications?.feature || null,
@@ -336,13 +376,8 @@ export function readFeatureDetail(projectDir, name, { resolveTree = resolveFeatu
   };
 }
 
-/**
- * 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 }}
- */
+// Junctions and win32 case are resolved by `canonicalPath` before the check,
+// so `..`, an absolute path or a link that leaves the feature folder are refused.
 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 };

package/src/dashboard/scanner/index.js

@@ -4,7 +4,6 @@ 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 { scanRubrics } from './rubrics-scanner.js';
 import { scanDocs } from './docs-scanner.js';
 
 /**
@@ -21,7 +20,6 @@ export function scanAll(frameworkDir) {
     skills: scanSkills(frameworkDir, phases.list),
     standards: scanStandards(frameworkDir, agents.list),
     rules: scanRules(frameworkDir),
-    rubrics: scanRubrics(frameworkDir),
     docs: scanDocs(frameworkDir),
   };
 }

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

@@ -89,7 +89,7 @@ export function createProjectApi(projectDir, deps = {}) {
 
   // 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
+  // an agent rewrites feature.json or a slice report, 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;

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

@@ -18,17 +18,22 @@ function parseFrontmatter(content) {
   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.
- */
+const ROUTE_LINE = /^- \*\*([a-z0-9-]+)\*\* \(`([^`]+\.md)`\)/;
+
+// Bullet form: - **<id>** (`<path under standards/>`) — <digest>. An `@path`
+// import inside .claude/rules resolves relative to the rule file and never loads.
+export function parseStandardRoutes(content) {
+  const routes = [];
+  for (const line of content.split(/\r?\n/)) {
+    const m = ROUTE_LINE.exec(line);
+    if (m) routes.push({ id: m[1], path: m[2] });
+  }
+  return routes;
+}
+
+// RulesMap keys one edge per ref, so a repeated path would collide.
 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];
+  return [...new Set(parseStandardRoutes(content).map((r) => r.path))];
 }
 
 export function scanRules(frameworkDir) {

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

@@ -84,13 +84,12 @@ export function scanSkills(frameworkDir, phases = []) {
       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'];
+      const invocable = fm['user-invocable'];
       skills.push({
         id: skillDir.name,
         name: fm.name || skillDir.name,
         description: fm.description || '',
-        whenToInvoke: fm['when-to-invoke'] || '',
+        whenToUse: fm.when_to_use || '',
         level: levelDir.name,
         userInvocable: invocable === true || invocable === 'true',
         stacks: typeof fm.stacks === 'string' ? fm.stacks.replace(/[[\]]/g, '').split(',').map((s) => s.trim()).filter(Boolean) : [],

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

@@ -1,11 +1,12 @@
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { personaStandardIds } from '../../utils/agents-installer.js';
+import { loadStandardsRegistry } from '../../lib/standards/registry.js';
 
 export function scanStandards(frameworkDir, agents) {
   const standardsJsonPath = join(frameworkDir, 'standards', 'STANDARDS.json');
   if (!existsSync(standardsJsonPath)) return { version: 'unknown', list: [] };
-  const sJson = JSON.parse(readFileSync(standardsJsonPath, 'utf8'));
+  const sJson = loadStandardsRegistry(standardsJsonPath);
   const refMap = {};
   for (const agent of agents) {
     for (const std of personaStandardIds(agent)) {

package/src/lib/ci/ci-verify.js

@@ -18,7 +18,7 @@ export class CiUsageError extends Error {}
 const NODE_KEYS = ['build', 'tests', 'validators', 'e2e'];
 
 function isVerifyResult(result) {
-  return Boolean(result) && ['pass', 'fail'].includes(result.status) && result.scope === 'feature'
+  return Boolean(result) && ['pass', 'fail'].includes(result.status)
     && NODE_KEYS.every((k) => typeof result.nodes?.[k]?.status === 'string');
 }
 
@@ -47,6 +47,22 @@ function dispatchWorkflow(root, workflow, branch) {
   }
 }
 
+/**
+ * When CI falls back to local, the last green feature stamp still proves the tree if nothing moved
+ * since it by the gate's own staleness rule and nothing is uncommitted (treeMovedSince sees only
+ * commits). A null sha or HEAD would read as "not moved", so both are required.
+ *
+ * @returns {object|null} the stamp to reuse, or null = run local
+ */
+export function reusableLocalStamp(root, stamp) {
+  if (stamp?.status !== 'pass' || !stamp.sha) return null;
+  const head = getHeadSha(root);
+  if (!head) return null;
+  const dirty = uncommittedCode(root);
+  if (dirty === null || dirty.length > 0) return null;
+  return treeMovedSince(root, stamp.sha, head) ? null : stamp;
+}
+
 /**
  * `verify {f} --ci`: the feature-scope proof, run by the project's CI over the pushed commit.
  * Every way CI cannot answer is `mode: 'local'` with the reason, and the caller runs the local

package/src/lib/ci/github-ci.js

@@ -140,7 +140,7 @@ export function listRuns(root, branch, workflow) {
 
 /**
  * The newest run over the same code as HEAD. `isCurrent` is a tree comparison, not SHA equality:
- * the evaluator and the archive commit only `.morph/`, and the workflow does not re-run for them.
+ * the review agents and the archive commit only `.morph/`, and the workflow does not re-run for them.
  */
 export function pickRun(runs, isCurrent) {
   return (runs || []).find((run) => !(run.status === 'completed' && NO_VERDICT.has(run.conclusion))

package/src/lib/detectors/index.js

@@ -10,14 +10,9 @@
 import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
 
-/**
- * Common monorepo locations for a frontend `package.json`, root included.
- *
- * Exported so `discoverFrontendPackages()` (src/lib/tasks/test-nodes.js, #87
- * PR B) scans the SAME candidate list this detector already uses — one
- * spelling of "where a frontend package might live", not two that drift.
- */
-export const PACKAGE_LOCATIONS = ['.', 'src/frontend', 'src/web', 'frontend', 'apps/web', 'packages/app'];
+import { PACKAGE_LOCATIONS } from '../../../framework/hooks/shared/frontend-locations.js';
+
+export { PACKAGE_LOCATIONS };
 
 /**
  * Detect project structure from filesystem evidence.