@polymorphism-tech/morph-spec 7.5.0 → 7.7.0

package/src/commands/project/doctor.js

@@ -12,7 +12,7 @@ import {
   getInstalledCLIVersion
 } from '../../utils/version-checker.js';
 import { resetMorphSettings } from '../../utils/claude-settings-manager.js';
-import { checkMissingAgents } from '../../utils/agents-installer.js';
+import { checkMissingAgents, checkAgentsDrift } from '../../utils/agents-installer.js';
 import { getProjectTags } from '../../lib/stack-filter.js';
 
 const isWindows = platform() === 'win32';
@@ -186,6 +186,41 @@ async function doctorFullCommand(frameworkRoot) {
     } catch { /* ignore parse errors — already caught above */ }
   }
 
+  // ── 6b. Generated personas drift (.claude/agents ↔ agents.json) ─────────
+  // agents.json is the single source of truth; the .claude/agents/morph-*.md
+  // files are derived artifacts (ADR-001). Missing = broken dispatch (error);
+  // stale/hand-edited or orphan = drift (warning).
+  if (await pathExists(agentsPath)) {
+    console.log(chalk.cyan('\n  .claude/agents/ — Generated personas (drift vs agents.json)'));
+    try {
+      let projectTags = [];
+      const cfgPath = join(frameworkRoot, '.morph/config/config.json');
+      if (await pathExists(cfgPath)) {
+        try { projectTags = getProjectTags(JSON.parse(await fs.readFile(cfgPath, 'utf8'))); } catch { /* no tags */ }
+      }
+      const drift = checkAgentsDrift(frameworkRoot, join(frameworkRoot, '.morph/framework'), projectTags);
+      check(`Personas installed (${drift.expected - drift.missing.length}/${drift.expected})`,
+        drift.missing.length === 0, false,
+        drift.missing.length > 0 ? `missing: ${drift.missing.join(', ')} — run 'morph-spec setup-infra --reinstall'` : '');
+      check('Personas up-to-date (no drift)', drift.stale.length === 0, true,
+        drift.stale.length > 0 ? `stale/hand-edited: ${drift.stale.join(', ')} — regenerate via 'morph-spec setup-infra --reinstall'` : '');
+      check('No orphan morph-* agents', drift.orphans.length === 0, true,
+        drift.orphans.length > 0 ? `orphans: ${drift.orphans.join(', ')}` : '');
+    } catch {
+      check('personas drift check', false, true, 'failed to compute');
+    }
+  }
+
+  // ── 6c. GitHub tooling — gh CLI (canonical; morph-spec does not use a GitHub MCP) ──
+  console.log(chalk.cyan('\n  Tooling — GitHub via gh CLI'));
+  try {
+    execSync('gh --version', { stdio: 'pipe', timeout: 5000 });
+    check('gh CLI available', true);
+  } catch {
+    check('gh CLI available', false, true,
+      "GitHub ops (issues/PRs/releases) usam o gh CLI — instale https://cli.github.com e rode 'gh auth login'");
+  }
+
   // ── 7. state.json schema version ────────────────────────────────────────
   console.log(chalk.cyan('\n  .morph/state.json — Schema Version'));
   const statePath = join(frameworkRoot, '.morph/state.json');

package/src/commands/state/approve.js

@@ -1,6 +1,8 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { getFeature, setApprovalGate, getApprovalGate, getApprovalHistory } from '../../core/state/state-manager.js';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getFeature, setApprovalGate, getApprovalGate, getApprovalHistory, derivePhase } from '../../core/state/state-manager.js';
 
 /**
  * Unapprove action function - Revoke a previously approved gate
@@ -158,12 +160,23 @@ export async function approvalStatusCommand(featureName, options = {}) {
       process.exit(1);
     }
 
+    // v5 removed the stored feature.phase — derive it from the filesystem +
+    // approved gates (same as `morph-spec status`), never print "unknown".
+    const featurePath = join(process.cwd(), '.morph', 'features', featureName);
+    const phase = feature.phase || derivePhase(featurePath);
+
+    // The uiux branch is optional: a feature that never took it has no
+    // 1-design/ folder and no uiux approval — that is "n/a", not "rejected".
+    const uiuxGate = getApprovalGate(featureName, 'uiux');
+    const uiuxTaken = uiuxGate?.approved === true || existsSync(join(featurePath, '1-design'));
+
     // JSON output
     if (options.json) {
       const status = {
         feature: featureName,
-        phase: feature.phase,
+        phase,
         status: feature.status,
+        uiuxTaken,
         gates: {}
       };
 
@@ -179,7 +192,7 @@ export async function approvalStatusCommand(featureName, options = {}) {
     console.log('━'.repeat(60));
 
     // Show current phase
-    console.log(chalk.cyan(`\nCurrent Phase: ${feature.phase || 'unknown'}`));
+    console.log(chalk.cyan(`\nCurrent Phase: ${phase}`));
     console.log(chalk.gray(`Feature Status: ${feature.status || 'unknown'}\n`));
 
     // Show each gate
@@ -193,6 +206,11 @@ export async function approvalStatusCommand(featureName, options = {}) {
         continue;
       }
 
+      if (gateName === 'uiux' && !uiuxTaken) {
+        console.log(`  ${chalk.gray('—')} ${gateName}: ${chalk.gray('n/a (ramo de design não tomado)')}`);
+        continue;
+      }
+
       if (gateStatus.approved) {
         console.log(`  ${chalk.green('✓')} ${gateName}: ${chalk.green('Approved')}`);
         if (gateStatus.timestamp) {
@@ -202,7 +220,14 @@ export async function approvalStatusCommand(featureName, options = {}) {
           console.log(chalk.gray(`      Approved by: ${gateStatus.approvedBy}`));
         }
       } else {
-        console.log(`  ${chalk.red('✗')} ${gateName}: ${chalk.red('Rejected / Not Approved')}`);
+        // Distinguish "never evaluated" (initialized approved:false, no
+        // timestamp) from an explicit rejection/revocation (has timestamp).
+        const neverEvaluated = !gateStatus.timestamp && !gateStatus.rejectedAt && !gateStatus.revokedAt;
+        if (neverEvaluated) {
+          console.log(`  ${chalk.gray('○')} ${gateName}: ${chalk.gray('Pending (not yet evaluated)')}`);
+          continue;
+        }
+        console.log(`  ${chalk.red('✗')} ${gateName}: ${chalk.red('Rejected / Revoked')}`);
         if (gateStatus.reason) {
           console.log(chalk.gray(`      Reason: ${gateStatus.reason}`));
         }

package/src/commands/state/score.js

@@ -0,0 +1,88 @@
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { getFeature, updateFeature } from '../../core/state/state-manager.js';
+
+/** Fixed --dims order: a,c,q,t (mirrors the morph-eval dimension weights). */
+const DIM_KEYS = ['architecture', 'contracts', 'codeQuality', 'testCoverage'];
+
+function parseScoreValue(raw, label) {
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value < 0 || value > 10) {
+    console.error(chalk.red(`\n❌ Invalid ${label}: "${raw}" — expected a number between 0 and 10\n`));
+    process.exit(1);
+  }
+  return value;
+}
+
+/**
+ * `morph-spec score <feature> <task> <score> [--dims a,c,q,t]` — record a
+ * task eval score under `taskScores` in the authoritative feature.json.
+ *
+ * The timestamp is stamped server-side (`updatedAt`), the write is atomic
+ * (state-manager), attempts auto-increment and bestScore is kept — this
+ * replaces the fragile manual Edit of feature.json from the skills.
+ */
+export async function scoreCommand(featureName, taskId, scoreArg, options = {}) {
+  try {
+    const score = parseScoreValue(scoreArg, 'score');
+
+    const feature = getFeature(featureName);
+    if (!feature) {
+      console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
+      process.exit(1);
+    }
+
+    let dimensions;
+    if (options.dims) {
+      const parts = String(options.dims).split(',').map(s => s.trim());
+      if (parts.length !== DIM_KEYS.length) {
+        console.error(chalk.red(`\n❌ --dims expects ${DIM_KEYS.length} comma-separated values in order a,c,q,t (architecture,contracts,code-quality,test-coverage)\n`));
+        process.exit(1);
+      }
+      dimensions = {};
+      DIM_KEYS.forEach((key, i) => {
+        dimensions[key] = parseScoreValue(parts[i], `--dims ${key}`);
+      });
+    }
+
+    // Non-fatal sanity check: warn when the task id is unknown to tasks.json.
+    const tasksPath = join(process.cwd(), '.morph', 'features', featureName, '2-plan', 'tasks.json');
+    if (existsSync(tasksPath)) {
+      try {
+        const tasks = JSON.parse(readFileSync(tasksPath, 'utf8')).tasks || [];
+        if (!tasks.some(t => t.id === taskId)) {
+          console.error(chalk.yellow(`⚠️  Task "${taskId}" not found in tasks.json — recording anyway`));
+        }
+      } catch {
+        // unreadable tasks.json — the score is still worth recording
+      }
+    }
+
+    const prev = feature.taskScores?.[taskId];
+    const entry = {
+      lastScore: score,
+      bestScore: prev?.bestScore != null ? Math.max(prev.bestScore, score) : score,
+      attempts: (prev?.attempts ?? 0) + 1,
+      ...(dimensions ? { dimensions } : {}),
+      updatedAt: new Date().toISOString(),
+    };
+
+    await updateFeature(featureName, `taskScores.${taskId}`, entry);
+
+    if (options.json) {
+      console.log(JSON.stringify({ feature: featureName, task: taskId, ...entry }, null, 2));
+      return;
+    }
+
+    console.log(chalk.green(`\n✅ Score recorded: ${featureName}/${taskId} → ${entry.lastScore}`));
+    console.log(chalk.gray(`   best: ${entry.bestScore} | attempts: ${entry.attempts} | updatedAt: ${entry.updatedAt}`));
+    if (dimensions) {
+      console.log(chalk.gray(`   dims: arch=${dimensions.architecture} contracts=${dimensions.contracts} quality=${dimensions.codeQuality} tests=${dimensions.testCoverage}`));
+    }
+    console.log('');
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Error recording score: ${error.message}\n`));
+    process.exit(1);
+  }
+}

package/src/commands/tasks/dag.js

@@ -0,0 +1,68 @@
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { parseTasksJson } from '../../lib/tasks/tasks-json-parser.js';
+import { planDispatch } from '../../lib/tasks/dispatch-planner.js';
+
+/**
+ * `morph-spec dag <feature>` — analyze the tasks.json DAG and print the
+ * sequential vs parallel dispatch decision, weighted by effort.
+ *
+ * This is the command morph-apply §2 runs instead of re-deriving the rules
+ * (and instead of the old inline JS snippets the LLM could not execute).
+ */
+export async function dagCommand(featureName, options = {}) {
+  try {
+    const tasksPath = join(process.cwd(), '.morph', 'features', featureName, '2-plan', 'tasks.json');
+    if (!existsSync(tasksPath)) {
+      console.error(chalk.red(`\n❌ tasks.json not found for feature "${featureName}"`));
+      console.error(chalk.gray(`Expected at: .morph/features/${featureName}/2-plan/tasks.json\n`));
+      process.exit(1);
+    }
+
+    // parseTasksJson validates the schema and throws with the error list.
+    const data = await parseTasksJson(tasksPath);
+    const plan = planDispatch(data);
+
+    if (options.json) {
+      console.log(JSON.stringify(plan, null, 2));
+      return;
+    }
+
+    console.log(chalk.bold(`\n📊 DAG — ${featureName}`));
+    console.log('━'.repeat(60));
+
+    const { stats } = plan;
+    console.log(`\nTasks: ${stats.total} total, ${stats.pending} pendente(s)`);
+    const groupLine = Object.keys(stats.groups)
+      .map(g => `${g}:${stats.groups[g]} (peso ${stats.weights[g]})`)
+      .join(' | ');
+    if (groupLine) console.log(chalk.gray(`Grupos pendentes: ${groupLine}`));
+
+    const modeLabel = {
+      'sequential': 'SEQUENCIAL (auto-advance)',
+      'parallel-flows': 'PARALELO por fluxo de domínio',
+      'parallel-roots': 'PARALELO por raízes independentes',
+    }[plan.mode];
+    console.log(chalk.cyan(`\nDecisão: ${modeLabel}`));
+    console.log(`  → ${plan.reason}`);
+
+    for (const flow of plan.flows) {
+      console.log(`  ${chalk.green('▶')} Fluxo ${chalk.bold(flow.group)} (peso ${flow.weight}): ${flow.taskIds.join(', ')}`);
+    }
+    if (plan.batch.length > 0) {
+      console.log(`  ${chalk.green('▶')} Batch paralelo: ${plan.batch.join(', ')}`);
+    }
+    if (plan.inline.length > 0) {
+      console.log(`  ${chalk.yellow('○')} Inline (sem dispatch próprio): ${plan.inline.join(', ')}`);
+    }
+    if (plan.sequentialRemainder.length > 0) {
+      console.log(`  ${chalk.gray('→')} Sequencial: ${plan.sequentialRemainder.join(', ')}`);
+    }
+
+    console.log('\n' + '━'.repeat(60) + '\n');
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Error analyzing DAG: ${error.message}\n`));
+    process.exit(1);
+  }
+}

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

@@ -7,6 +7,6 @@ export function scanRubrics(frameworkDir) {
   return readdirSync(dir).filter(f => f.endsWith('.json')).map(f => {
     const d = JSON.parse(readFileSync(join(dir, f), 'utf8'));
     return { id: d.id, version: d.version || '1.0.0', description: d.description || '',
-      categories: d.categories || {}, thresholds: d.thresholds || { approve: 8.0, retry: 6.0 } };
+      categories: d.categories || {}, thresholds: d.thresholds || { approve: 9.0, retry: 6.0 } };
   });
 }

package/src/lib/generators/recap-generator.js

@@ -183,7 +183,7 @@ function buildRecapMarkdown(data) {
     const scores = validationResult.scores;
     md += `### Quality Score: ${scores.score}/10\n\n`;
     md += `| Category | Score | Weight | Status |\n|----------|-------|--------|--------|\n`;
-    const approveThreshold = scores.approveThreshold ?? 8.0;
+    const approveThreshold = scores.approveThreshold ?? 9.0;
     for (const [category, data] of Object.entries(scores.breakdown)) {
       if (category === '_unmapped') continue;
       const pct = Math.round(data.weight * 100);

package/src/lib/tasks/dispatch-planner.js

@@ -0,0 +1,201 @@
+/**
+ * dispatch-planner.js — effort-weighted sequential vs parallel decision for a
+ * feature's tasks.json DAG.
+ *
+ * Encodes the dispatch rules from morph-apply §2 ("Análise de DAG") so the
+ * decision is deterministic and CLI-driven (`morph-spec dag <feature>`)
+ * instead of re-derived by the LLM each session:
+ *
+ *   1. <= 3 tasks total → sequential (dispatch overhead beats the work).
+ *   2. >= 2 independent group flows with enough weight → one agent per flow.
+ *   3. >= 3 independent roots with effort M or heavier → parallel root batch.
+ *   4. otherwise → sequential with auto-advance.
+ *
+ * Effort weighting: S=1, M=2, L=4, XL=8. S-only roots and light flows never
+ * earn their own agent — they are returned as `inline` (the orchestrator runs
+ * them in the sequential lane, or folds them into a single grouped agent), so
+ * dispatch overhead never exceeds the work being dispatched.
+ *
+ * Pure module — operates on a parsed tasks.json document, no I/O.
+ */
+
+export const EFFORT_WEIGHT = { S: 1, M: 2, L: 4, XL: 8 };
+
+/** A root must weigh at least this (effort M) to earn its own agent. */
+export const ROOT_DISPATCH_MIN_WEIGHT = 2;
+
+/** A flow must weigh at least this (an L, or 2×M…) to earn its own agent. */
+export const FLOW_DISPATCH_MIN_WEIGHT = 4;
+
+/** Mirror of the morph-apply cap on simultaneous agents. */
+export const MAX_PARALLEL_AGENTS = 4;
+
+function weightOf(task) {
+  return EFFORT_WEIGHT[task.effort] ?? EFFORT_WEIGHT.M;
+}
+
+function groupOf(task) {
+  // Same fallback as groupTasks() in tasks-json-parser.js
+  return task.group || 'backend';
+}
+
+/**
+ * Ids of tasks whose dependency chain crosses group boundaries — integration
+ * tasks and everything downstream of them. These never belong to a flow: they
+ * run in the sequential lane after the parallel batch converges.
+ */
+function crossGroupTaskIds(tasks) {
+  const byId = new Map(tasks.map(t => [t.id, t]));
+  const cross = new Set();
+
+  for (const task of tasks) {
+    for (const dep of task.dependencies) {
+      const depTask = byId.get(dep);
+      if (depTask && groupOf(depTask) !== groupOf(task)) {
+        cross.add(task.id);
+        break;
+      }
+    }
+  }
+
+  // Propagate downstream: a task depending (transitively) on a cross-group
+  // task cannot run inside a single-group flow either.
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const task of tasks) {
+      if (cross.has(task.id)) continue;
+      if (task.dependencies.some(dep => cross.has(dep))) {
+        cross.add(task.id);
+        changed = true;
+      }
+    }
+  }
+
+  return cross;
+}
+
+function buildStats(tasks, pending) {
+  const groups = {};
+  const weights = {};
+  for (const task of pending) {
+    const g = groupOf(task);
+    groups[g] = (groups[g] || 0) + 1;
+    weights[g] = (weights[g] || 0) + weightOf(task);
+  }
+  return { total: tasks.length, pending: pending.length, groups, weights };
+}
+
+/**
+ * Decide how to execute the remaining tasks of a parsed tasks.json document.
+ *
+ * @param {object} data - parsed tasks.json ({ version, feature, tasks[] })
+ * @returns {{
+ *   mode: 'sequential' | 'parallel-flows' | 'parallel-roots',
+ *   reason: string,
+ *   stats: { total: number, pending: number, groups: object, weights: object },
+ *   flows: Array<{ group: string, taskIds: string[], weight: number }>,
+ *   batch: string[],
+ *   inline: string[],
+ *   sequentialRemainder: string[]
+ * }}
+ */
+export function planDispatch(data) {
+  const tasks = Array.isArray(data?.tasks) ? data.tasks : [];
+  const pending = tasks.filter(t => t.status === 'pending');
+  const stats = buildStats(tasks, pending);
+  const empty = { flows: [], batch: [], inline: [] };
+
+  if (pending.length === 0) {
+    return {
+      mode: 'sequential',
+      reason: 'nenhuma task pendente — nada a despachar',
+      stats, ...empty, sequentialRemainder: [],
+    };
+  }
+
+  // Rule 1 — tiny plans never pay for dispatch.
+  if (tasks.length <= 3) {
+    return {
+      mode: 'sequential',
+      reason: `${tasks.length} task(s) no total (<= 3) — overhead de Agent dispatch não compensa`,
+      stats, ...empty, sequentialRemainder: pending.map(t => t.id),
+    };
+  }
+
+  // Rule 2 — independent domain flows (backend ‖ frontend …).
+  const cross = crossGroupTaskIds(tasks);
+  const flowsMap = new Map();
+  for (const task of pending) {
+    if (cross.has(task.id)) continue;
+    const g = groupOf(task);
+    if (!flowsMap.has(g)) flowsMap.set(g, { group: g, taskIds: [], weight: 0 });
+    const flow = flowsMap.get(g);
+    flow.taskIds.push(task.id);
+    flow.weight += weightOf(task);
+  }
+  const allFlows = [...flowsMap.values()];
+  const worthyFlows = allFlows
+    .filter(f => f.weight >= FLOW_DISPATCH_MIN_WEIGHT)
+    .sort((a, b) => b.weight - a.weight);
+  const lightFlows = allFlows.filter(f => f.weight < FLOW_DISPATCH_MIN_WEIGHT);
+
+  if (worthyFlows.length >= 2) {
+    const flows = worthyFlows.slice(0, MAX_PARALLEL_AGENTS);
+    const overflow = worthyFlows.slice(MAX_PARALLEL_AGENTS);
+    const inline = [
+      ...lightFlows.flatMap(f => f.taskIds),
+      ...overflow.flatMap(f => f.taskIds),
+    ];
+    const sequentialRemainder = pending
+      .filter(t => cross.has(t.id))
+      .map(t => t.id);
+
+    const flowDesc = flows.map(f => `${f.group}:${f.taskIds.length} (peso ${f.weight})`).join(' ‖ ');
+    return {
+      mode: 'parallel-flows',
+      reason:
+        `${flows.length} fluxos de domínio independentes com peso suficiente — ${flowDesc} → ` +
+        `1 agente por fluxo` +
+        (inline.length ? `; ${inline.length} task(s) leve(s) inline (sem dispatch próprio)` : '') +
+        (sequentialRemainder.length ? `; integração cross-group sequencial no fim (${sequentialRemainder.join(', ')})` : ''),
+      stats, flows, batch: [], inline, sequentialRemainder,
+    };
+  }
+
+  // Rule 3 — root fan-out, weighted by effort (S roots never earn an agent).
+  const roots = pending.filter(t => t.dependencies.length === 0);
+  const weightedRoots = roots
+    .filter(t => weightOf(t) >= ROOT_DISPATCH_MIN_WEIGHT)
+    .sort((a, b) => weightOf(b) - weightOf(a));
+  const sRoots = roots.filter(t => weightOf(t) < ROOT_DISPATCH_MIN_WEIGHT);
+
+  if (weightedRoots.length >= 3) {
+    const batch = weightedRoots.slice(0, MAX_PARALLEL_AGENTS).map(t => t.id);
+    const inline = sRoots.map(t => t.id);
+    const sequentialRemainder = pending
+      .filter(t => !batch.includes(t.id) && !inline.includes(t.id))
+      .map(t => t.id);
+
+    return {
+      mode: 'parallel-roots',
+      reason:
+        `${weightedRoots.length} raízes independentes com effort M+ → batch paralelo (${batch.join(', ')})` +
+        (inline.length ? `; raízes S inline — não ganham dispatch próprio (${inline.join(', ')})` : '') +
+        `; restante sequencial`,
+      stats, flows: [], batch, inline, sequentialRemainder,
+    };
+  }
+
+  // Rule 4 — sequential.
+  const reason = roots.length >= 3
+    ? `${roots.length} raízes independentes, mas apenas ${weightedRoots.length} com effort M+ ` +
+      `(raízes S não ganham dispatch próprio — overhead > trabalho) → sequencial com auto-advance`
+    : 'sem fluxos ou raízes independentes suficientes → sequencial com auto-advance';
+
+  return {
+    mode: 'sequential',
+    reason,
+    stats, ...empty, sequentialRemainder: pending.map(t => t.id),
+  };
+}

package/src/lib/validators/score-aggregator.js

@@ -24,7 +24,7 @@ const FALLBACK_RUBRIC = {
       description: 'All validators (fallback — no rubric configured)'
     }
   },
-  thresholds: { approve: 8.0, retry: 6.0 }
+  thresholds: { approve: 9.0, retry: 6.0 }
 };
 
 /**
@@ -176,7 +176,7 @@ export function aggregateScores(validationResult, rubric, configOverrides = {})
   const score = Math.round(weightedScore * 10) / 10;
 
   // Determine action
-  const approveThreshold = configOverrides.approve ?? rubric.thresholds?.approve ?? 8.0;
+  const approveThreshold = configOverrides.approve ?? rubric.thresholds?.approve ?? 9.0;
   const retryThreshold = configOverrides.retry ?? rubric.thresholds?.retry ?? 6.0;
 
   let action;
@@ -210,7 +210,7 @@ export function aggregateScores(validationResult, rubric, configOverrides = {})
  * @param {number} [approveThreshold] - For display
  * @returns {string}
  */
-export function formatScoreBreakdown(scoreResult, approveThreshold = 8.0) {
+export function formatScoreBreakdown(scoreResult, approveThreshold = 9.0) {
   const lines = [];
 
   lines.push(`Score: ${scoreResult.score}/10 (threshold: ${approveThreshold})`);

package/src/scripts/setup-infra.js

@@ -118,6 +118,33 @@ async function installStackAwareAssets(targetPath, log) {
   return { agentCounts, domainCounts, projectTags };
 }
 
+/**
+ * Rewrite the managed personas block in .claude/CLAUDE.md with the agents
+ * ACTUALLY installed (derived list — never a hand-written promise).
+ * No markers / no file → no-op (fail-open).
+ *
+ * @param {string} claudeMdPath - Absolute path to the installed .claude/CLAUDE.md
+ * @param {Array<{ name: string, title: string, domains: string[] }>} agents
+ */
+async function updateClaudeMdAgentsBlock(claudeMdPath, agents = []) {
+  if (!(await pathExists(claudeMdPath))) return;
+  const START = '<!-- morph-agents:start -->';
+  const END = '<!-- morph-agents:end -->';
+  const content = readFileSync(claudeMdPath, 'utf-8');
+  if (!content.includes(START) || !content.includes(END)) return;
+
+  const list = agents.length > 0
+    ? agents.map(a => `- \`${a.name}\` — ${a.title}${a.domains?.length ? ` (${a.domains.join(', ')})` : ''}`).join('\n')
+    : '_Nenhuma persona instalada — configure `project.stack` em `.morph/config/config.json` e rode `morph-spec setup-infra --reinstall`._';
+
+  const block = `${START}\n**Personas instaladas neste projeto** (derivado de agents.json na última instalação):\n\n${list}\n${END}`;
+  const updated = content.replace(
+    new RegExp(`${START}[\\s\\S]*?${END}`),
+    block
+  );
+  await writeFile(claudeMdPath, updated);
+}
+
 /**
  * Installs MORPH-SPEC infrastructure into the target project directory.
  * Headless — no prompts, no spinner (suppressed when MORPH_QUIET=1), no stack detection.
@@ -138,6 +165,9 @@ export async function setupInfra(targetPath, { _exec = execSync, reinstall = fal
   if (reinstall) {
     log('setup-infra (reinstall): re-installing stack-aware assets...');
     const { agentCounts, domainCounts } = await installStackAwareAssets(targetPath, log);
+    // Keep the derived personas list in .claude/CLAUDE.md in sync with what
+    // was actually (re)installed.
+    await updateClaudeMdAgentsBlock(join(targetPath, '.claude', 'CLAUDE.md'), agentCounts?.agents ?? []);
     log('setup-infra (reinstall): complete.');
     return {
       agents: {
@@ -236,6 +266,16 @@ export async function setupInfra(targetPath, { _exec = execSync, reinstall = fal
     await copyDirectory(rubricsSrc, rubricsDest);
   }
 
+  // --- 7c. Copy framework/evals → .morph/framework/evals ---
+  // Rubricas .md (bandas 0-10) + trace-schema.md — referenciadas por
+  // morph-eval/morph-review/agents.json via .morph/framework/evals/.
+  log('Step 7c: Copying evals (rubrics .md + trace schema)...');
+  const evalsSrc = join(FRAMEWORK_DIR, 'evals');
+  const evalsDest = join(frameworkDestDir, 'evals');
+  if (await pathExists(evalsSrc)) {
+    await copyDirectory(evalsSrc, evalsDest);
+  }
+
   // --- 8. Copy framework/agents.json → .morph/framework/agents.json ---
   log('Step 8: Copying agents.json...');
   const agentsSrc = join(FRAMEWORK_DIR, 'agents.json');
@@ -286,6 +326,8 @@ export async function setupInfra(targetPath, { _exec = execSync, reinstall = fal
   const runtimeClaudeMdDest = join(claudeDest, 'CLAUDE.md');
   if (await pathExists(claudeMdSrc)) {
     await copyFile(claudeMdSrc, runtimeClaudeMdDest);
+    // Derive the personas section from what step 10-13 actually installed.
+    await updateClaudeMdAgentsBlock(runtimeClaudeMdDest, agentCounts?.agents ?? []);
   }
 
   // --- 15. installGlobalStatusline (non-critical) ---