@polymorphism-tech/morph-spec 8.46.0 → 9.0.0

package/src/commands/observability/cost.js

@@ -1,10 +1,8 @@
 /**
- * `morph-spec cost [feature] [--by task|phase] [--all-trees] [--metrics [--top n]] [--json]`
+ * `morph-spec cost [feature] [--by phase] [--all-trees] [--metrics [--top n]] [--json]`
  *
  * A cost-facing view over the same harness event stream `telemetry` reads
- * (.morph/logs/events.jsonl): how much wall-clock time was spent inside
- * measured tasks (TaskStart→TaskEnd), how many context bytes were
- * re-ingested (grouped by kind: rubric/standard/skill/agents/plan-artifact/
+ * (.morph/logs/events.jsonl): how many context bytes were re-ingested (grouped by kind: rubric/standard/skill/agents/plan-artifact/
  * code), and how many sub-agent dispatches happened (with total prompt
  * chars). When the stream has `SessionUsage` events (real, hook-observed
  * token counts), those are summed and shown too — see the sessionUsage
@@ -22,7 +20,7 @@
  *
  * `--metrics` measures the loop instead: turns, tool calls by orchestrator and
  * sub-agent, time per command class, identical reruns and why, rereads, how
- * many feature-scope verifies each feature ran, git calls per task and whether
+ * many verifies each feature ran, git calls and whether
  * the reuse validator ran in root and worktree (see lib/telemetry/metrics.js).
  *
  * Read-only, always exits 0 on a normal (even empty) run — fail-open, an
@@ -37,7 +35,7 @@ import { computeMetrics } from '../../lib/telemetry/metrics.js';
 const BYTES_CAVEAT =
   'Bytes re-ingeridos são um PROXY determinístico de custo (o que as ferramentas leram do disco) — NÃO são tokens reais. Hooks não enxergam o uso real de tokens do modelo.';
 
-const BY_MODES = ['task', 'phase'];
+const BY_MODES = ['phase'];
 
 function fmtBytes(n) {
   if (!n) return '0 B';
@@ -65,21 +63,6 @@ function printBytesByKind(bytesByKind) {
   }
 }
 
-function printTasks(tasks) {
-  if (!tasks.length) {
-    console.log(chalk.gray('\nNenhuma task com TaskStart/TaskEnd capturada.'));
-    return;
-  }
-  for (const t of tasks) {
-    const status = t.open ? chalk.yellow('[em aberto]') : (t.status || '-');
-    console.log('\n' + chalk.white.bold(`Task ${t.task}`) + chalk.gray(` · ${t.feature ?? '(sem feature)'}`) + ` · ${status}`);
-    console.log(`  duração: ${fmtDuration(t.durationSeconds)}`);
-    console.log(`  dispatches: ${t.dispatches.count} (${t.dispatches.promptChars} chars de prompt)`);
-    console.log('  bytes re-ingeridos por kind:');
-    printBytesByKind(t.bytesByKind);
-  }
-}
-
 function printPhases(phases) {
   if (!phases.length) {
     console.log(chalk.gray('\nNenhum byte de Read com phase capturado.'));
@@ -118,8 +101,7 @@ function printSessionUsage(summary) {
 }
 
 function printSummary(summary) {
-  console.log(`\n  duração dentro de tasks medidas: ${fmtDuration(summary.taskDurationSeconds)}`);
-  console.log(`  dispatches: ${summary.dispatches.count} (${summary.dispatches.promptChars} chars de prompt)`);
+  console.log(`\n  dispatches: ${summary.dispatches.count} (${summary.dispatches.promptChars} chars de prompt)`);
 
   console.log('\n' + chalk.white.bold('Bytes re-ingeridos por kind') + ` (${fmtBytes(summary.bytesTotal)} total)`);
   printBytesByKind(summary.bytesByKind);
@@ -140,7 +122,7 @@ function split(counts) {
   return `${counts.total} (orq ${counts.orchestrator} · sub ${counts.subagent}${counts.unknown ? ` · sem agente ${counts.unknown}` : ''})`;
 }
 
-function printMetricsBody(m, { by }) {
+function printMetricsBody(m) {
   const legacyShare = m.window.events ? m.coverage.legacy / m.window.events : 0;
   console.log(chalk.gray(`janela: ${m.window.from ?? '-'} → ${m.window.to ?? '-'} · ${m.window.events} eventos`
     + ` · ${pct(1 - legacyShare)} no esquema v2`));
@@ -149,16 +131,8 @@ function printMetricsBody(m, { by }) {
   }
 
   console.log('\n' + chalk.white.bold('Turnos e chamadas'));
-  console.log(`  turnos: ${m.turns ? split(m.turns) : 'desconhecido (nenhum PostToolBatch na janela)'}`
-    + (m.turnsPerTaskMedian !== null ? chalk.gray(` · mediana por task ${m.turnsPerTaskMedian}`) : ''));
+  console.log(`  turnos: ${m.turns ? split(m.turns) : 'desconhecido (nenhum PostToolBatch na janela)'}`);
   console.log(`  chamadas de ferramenta: ${split(m.toolCalls)}`);
-  const perTask = m.perTaskByFeature;
-  if (perTask.toolCalls !== null) {
-    console.log(`  por task (total da feature ÷ tasks dela, mediana): ${perTask.toolCalls} chamadas`
-      + (perTask.turns !== null ? ` · ${perTask.turns} turnos` : '') + ` · ${perTask.git} git status+diff`
-      + chalk.gray(` · as janelas TaskStart→TaskEnd têm ${pct(m.taskWindowCoverage)} das chamadas`));
-  }
-
   console.log('\n' + chalk.white.bold('Tempo por classe de comando'));
   for (const [klass, t] of Object.entries(m.timeByClass).sort((a, b) => b[1].measuredMs - a[1].measuredMs)) {
     const unmeasured = t.unmeasured ? chalk.gray(` (${t.unmeasured} sem duração)`) : '';
@@ -183,9 +157,9 @@ function printMetricsBody(m, { by }) {
   }
 
   console.log('\n' + chalk.white.bold('verify, git e reuso'));
-  const perFeature = Object.entries(m.verify.byFeature).sort((a, b) => b[1].feature - a[1].feature);
-  console.log(`  verify de feature por feature: mediana ${m.verify.featureScopeMedian ?? '-'}`
-    + (perFeature.length ? chalk.gray(` (${perFeature.slice(0, 5).map(([f, v]) => `${f} ${v.feature}`).join(', ')})`) : ''));
+  const perFeature = Object.entries(m.verify.byFeature).sort((a, b) => b[1] - a[1]);
+  console.log(`  verify por feature: mediana ${m.verify.median ?? '-'}`
+    + (perFeature.length ? chalk.gray(` (${perFeature.slice(0, 5).map(([f, n]) => `${f} ${n}`).join(', ')})`) : ''));
   const repeats = Object.entries(m.verify.unchangedRepeats);
   if (repeats.length) {
     console.log(`  verify de feature sobre a mesma árvore do anterior: ${repeats.reduce((n, [, v]) => n + v, 0)}`
@@ -196,24 +170,12 @@ function printMetricsBody(m, { by }) {
     console.log(`  suíte .NET inteira que recompila (sem --no-build): ${m.dotnetFullSuite.withBuild}/${m.dotnetFullSuite.runs}`
       + chalk.gray(` (${phases})`));
   }
-  console.log(`  git status / diff por task: mediana ${m.gitPerTaskMedian.status ?? '-'} / ${m.gitPerTaskMedian.diff ?? '-'}`
-    + chalk.gray(` · total ${m.git.status} / ${m.git.diff}`));
+  console.log(`  git status / diff: ${m.git.status} / ${m.git.diff}`);
   const trees = Object.entries(m.reuse.byTree);
   console.log(`  reuse-validator: ${trees.length
     ? trees.map(([tree, s]) => `${tree} rodou ${s.ran}, pulou ${s.skipped}`).join(' · ')
     : 'nenhum evento Verify na janela'}`);
   for (const [reason, n] of Object.entries(m.reuse.skipReasons)) console.log(chalk.gray(`    pulou ${n}×: ${reason}`));
-
-  if (by === 'task') {
-    for (const t of m.tasks) {
-      const status = t.open ? chalk.yellow('[em aberto]') : (t.status || '-');
-      console.log('\n' + chalk.white.bold(`Task ${t.task}`) + chalk.gray(` · ${t.feature ?? '(sem feature)'}`) + ` · ${status}`);
-      console.log(`  turnos ${t.turns ? split(t.turns) : '-'} · chamadas ${split(t.toolCalls)}`);
-      const time = Object.entries(t.timeByClass).map(([k, v]) => `${k} ${fmtDuration(v.measuredMs / 1000)}`).join(' · ');
-      if (time) console.log(`  tempo: ${time}`);
-      console.log(`  rerun ${pct(t.reruns.rate)} (${t.reruns.reruns}/${t.reruns.runs}) · releitura ${pct(t.rereads.rate)} · git status/diff ${t.git.status}/${t.git.diff}`);
-    }
-  }
 }
 
 /**
@@ -237,17 +199,17 @@ function printMetrics(feature, options, cwd) {
   }
   const scope = feature ? chalk.cyan(` · feature ${feature}`) : '';
   console.log(chalk.white.bold(`Medições do loop${options.allTrees ? ' — todas as árvores + finish-backup' : ''}`) + scope);
-  printMetricsBody(metrics, options);
+  printMetricsBody(metrics);
 }
 
 /**
  * `--all-trees` rendering: a short line per tree (so a fleet operator can
  * spot which tree is expensive) followed by the COMBINED aggregate — full
- * detail (task/phase breakdown honors `--by` here too, same as the
+ * detail (the phase breakdown honors `--by` here too, same as the
  * single-tree path; a typeable flag combination is never a silent no-op).
  *
  * @param {string} [feature]
- * @param {{ json?: boolean, by?: 'task'|'phase' }} options
+ * @param {{ json?: boolean, by?: 'phase' }} options
  * @param {string} cwd
  */
 function printAllTrees(feature, options, cwd) {
@@ -277,7 +239,7 @@ function printAllTrees(feature, options, cwd) {
 
   for (const t of perTree) {
     console.log('\n' + chalk.cyan.bold(`── Árvore: ${t.tree}`) + chalk.gray(` — ${t.path}`));
-    console.log(`   ${t.total} eventos · duração em tasks: ${fmtDuration(t.taskDurationSeconds)} · `
+    console.log(`   ${t.total} eventos · `
       + `bytes: ${fmtBytes(t.bytesTotal)} · dispatches: ${t.dispatches.count}`);
   }
 
@@ -285,9 +247,7 @@ function printAllTrees(feature, options, cwd) {
   if (combined.features.length) {
     console.log(chalk.gray(`Features: ${combined.features.join(', ')}`));
   }
-  if (options.by === 'task') {
-    printTasks(combined.tasks);
-  } else if (options.by === 'phase') {
+  if (options.by === 'phase') {
     printPhases(combined.phases);
   } else {
     printSummary(combined);
@@ -296,7 +256,7 @@ function printAllTrees(feature, options, cwd) {
 
 /**
  * @param {string} [feature] - narrow to a single feature
- * @param {{ json?: boolean, by?: 'task'|'phase', allTrees?: boolean, cwd?: string }} [options]
+ * @param {{ json?: boolean, by?: 'phase', allTrees?: boolean, cwd?: string }} [options]
  */
 export function costCommand(feature, options = {}) {
   if (options.by && !BY_MODES.includes(options.by)) {
@@ -345,9 +305,7 @@ export function costCommand(feature, options = {}) {
     console.log(chalk.gray(`Features: ${summary.features.join(', ')}`));
   }
 
-  if (options.by === 'task') {
-    printTasks(summary.tasks);
-  } else if (options.by === 'phase') {
+  if (options.by === 'phase') {
     printPhases(summary.phases);
   } else {
     printSummary(summary);

package/src/commands/observability/telemetry.js

@@ -12,12 +12,10 @@
 import chalk from 'chalk';
 import { loadTelemetry, aggregateTelemetry } from '../../lib/telemetry/telemetry-reader.js';
 
-// The knowledge-base count reflects EXPLICIT reads only. The core standards
-// load via @-refs in rules (Layer 0/1 auto-load) — those are injected by
-// Claude Code's rules system, not via the Read tool, so no hook ever sees them.
-// A low count here means "few on-demand reads", NOT "standards barely used".
+// A rule injects its standards' digests through Claude Code's rules system,
+// not the Read tool, so no hook sees them: a low count means "few full-text reads".
 const STANDARDS_CAVEAT =
-  'Só reads explícitos (via Read) são observáveis; standards auto-carregados por @-ref nas rules (Layer 0/1) não passam por tool call e ficam invisíveis aqui.';
+  'Só reads explícitos (via Read) são observáveis; o resumo que uma rule injeta ao tocar arquivo casado por `paths:` não passa por tool call: não observável aqui.';
 
 function section(title, rows, fmt) {
   if (!rows.length) return;

package/src/commands/project/doctor-procs.js

@@ -134,7 +134,7 @@ export async function doctorProcsCommand(targetPath, options = {}) {
     const { afterHeavyRun } = await import('../../lib/heavy/cleanup.js');
     report.prune = report.procs.status === 'ok' ? pruneOrphans(report.procs.rows, options.pruneDeps) : [];
     report.buildServer = afterHeavyRun({
-      projectPath: targetPath, config: readHeavyConfig(targetPath), scope: 'prune', deps: options.cleanupDeps,
+      projectPath: targetPath, config: readHeavyConfig(targetPath), deps: options.cleanupDeps,
     });
   }
 

package/src/commands/project/doctor.js

@@ -242,10 +242,12 @@ const FRAMEWORK_STANDARDS = [
   'framework/standards/integration/mcp/mcp-tools.md'
 ];
 
-// required personas expected in agents.json (v5 — the universal, stack-agnostic
-// personas: evaluator (domain axis) and scout (stage axis))
+// required personas expected in agents.json — the universal, stack-agnostic
+// ones: the three review roles and scout (stage axis)
 const REQUIRED_AGENTS = [
-  'evaluator',
+  'verifier',
+  'reviewer',
+  'security',
   'scout'
 ];
 
@@ -1289,7 +1291,7 @@ export async function doctorCommand(options = {}) {
         // Check for missing agents based on stack tags. Empty tags (no config
         // yet) is NOT a skip: personas install-all by default, so with an
         // unknown stack ALL personas are expected (agentEligible semantics) —
-        // the exact field failure where only morph-evaluator landed and every
+        // the exact field failure where only morph-verifier landed and every
         // domain dispatch fell back to general-purpose.
         try {
           let projectTags = [];
@@ -1509,10 +1511,8 @@ export async function doctorCommand(options = {}) {
   // Check key templates exist (in framework package, not project copy)
   const frameworkTemplatesRoot = join(import.meta.dirname, '..', '..', '..', 'framework', 'templates');
   const keyTemplates = [
-    { name: 'proposal.md', path: join(frameworkTemplatesRoot, 'docs', 'proposal.md') },
-    { name: 'spec.md', path: join(frameworkTemplatesRoot, 'docs', 'spec.md') },
-    { name: 'tasks.template.json', path: join(frameworkTemplatesRoot, 'tasks.template.json') },
-    { name: 'decisions.md', path: join(frameworkTemplatesRoot, 'feature', 'decisions.md') }
+    { name: 'plan.md', path: join(frameworkTemplatesRoot, 'docs', 'plan.md') },
+    { name: 'ui-mockups.md', path: join(frameworkTemplatesRoot, 'docs', 'ui-mockups.md') }
   ];
   const missingTemplates = [];
   for (const template of keyTemplates) {
@@ -1560,7 +1560,7 @@ export async function doctorCommand(options = {}) {
   }
 
   // Per-feature detail for the lifecycle inconsistencies (item: doctor lists
-  // what's already wrong in the repo, e.g. plan approved with proposal pending).
+  // what's already wrong in the repo, e.g. review approved with plan pending).
   if (lifecycleIssues.length) {
     logger.blank();
     console.log(chalk.yellow('  Feature lifecycle inconsistencies:'));

package/src/commands/project/fleet.js

@@ -2,7 +2,7 @@
  * `morph-spec fleet [--json]` — the fleet view.
  *
  * One line per active feature across the primary root and every morph/*
- * worktree: phase, pending gates, task progress, port block, handoff
+ * worktree: phase, pending gates, slice progress, port block, handoff
  * freshness, last commit and dirtiness. This is the terminal surface the
  * operator scans between sessions ("what is each instance doing, what is
  * waiting on me") — `worktree list` remains the lean per-worktree view.
@@ -59,12 +59,12 @@ export function fleetCommand(options = {}) {
     // fleet-scanner.js) is 16 chars — 1 wider than the col width `list.js`
     // already uses (17) for the identical string. A narrower column here
     // would misalign every column after it just for that one row.
-    col('FEATURE', 20) + col('TYPE', 9) + col('PHASE', 18) + col('TASKS', 8)
+    col('FEATURE', 20) + col('TYPE', 9) + col('PHASE', 18) + col('FATIAS', 8)
     + col('GATES PEND.', 20) + col('WHERE', 24) + col('REMOTO', 16) + col('CLAIM', 16)
     + col('PORTS', 12) + col('HANDOFF', 9) + 'ATIVIDADE',
   ));
   for (const e of fleet.entries) {
-    const tasks = e.tasks ? `${e.tasks.done}/${e.tasks.total}` : '-';
+    const slices = e.slices ? `${e.slices.done}/${e.slices.total}` : '-';
     const gates = e.pendingGates.length ? e.pendingGates.join(',') : '-';
     // pr-pending has no worktree and isn't root-resident either — its branch
     // is the only place it exists, so show that instead of the misleading
@@ -80,7 +80,7 @@ export function fleetCommand(options = {}) {
     // length and append the padding by hand.
     const claimPlain = e.claim ? `${e.claim.live ? 'sessão' : 'morta'} (${claimAge(e.claim)})` : '-';
     console.log(
-      col(e.feature, 20) + col(e.workType || '-', 9) + col(e.phase, 18) + col(tasks, 8)
+      col(e.feature, 20) + col(e.workType || '-', 9) + col(e.phase, 18) + col(slices, 8)
       + col(gates, 20) + col(where, 24) + col(remoteCell(e.remote), 16)
       + claimCell(e.claim) + ' '.repeat(Math.max(1, 16 - claimPlain.length))
       + col(ports, 12) + col(handoff, 9) + activity,

package/src/commands/project/heavy.js

@@ -4,9 +4,9 @@ import { logger } from '../../utils/logger.js';
 import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js';
 import { createHeavyGate, HeavyBusyError } from '../../lib/heavy/gate.js';
 import { describeHolder, heavyDir, heavyStatus } from '../../../framework/hooks/shared/heavy-slots.js';
+import { resolveSpawn } from '../../../framework/hooks/shared/spawn-command.js';
 
 const EXIT_BUSY = 3;
-const NEEDS_CMD_SHIM = /^(npm|npx|pnpm|yarn)$/;
 
 export function heavyStatusCommand(options = {}) {
   const config = readHeavyConfig(process.cwd());
@@ -49,8 +49,8 @@ export function heavyRunCommand(command, options = {}) {
     process.exit(EXIT_BUSY);
   }
 
-  const exe = process.platform === 'win32' && NEEDS_CMD_SHIM.test(file) ? `${file}.cmd` : file;
-  const res = spawnSync(exe, args, { stdio: 'inherit', shell: exe.endsWith('.cmd') });
+  const spawn = resolveSpawn(file, args);
+  const res = spawnSync(spawn.file, spawn.args, { stdio: 'inherit', shell: spawn.shell });
   gate.release();
 
   if (res.error) {

package/src/commands/project/init.js

@@ -28,7 +28,7 @@ import {
   setupStitch,
   loadMcpRegistry
 } from '../../lib/installers/mcp-installer.js';
-import { setupInfra, installRulesForStack } from '../../scripts/setup-infra.js';
+import { setupInfra, installRulesForStack, installCommandsForStack } from '../../scripts/setup-infra.js';
 import { installSkills } from '../../utils/skills-installer.js';
 import { installAgents, installDomainAgents } from '../../utils/agents-installer.js';
 import { getProjectTags } from '../../lib/stack-filter.js';
@@ -111,6 +111,10 @@ export async function initCommand(options) {
     // ARE the primary root, or the caller explicitly passed --force), so it
     // must not be redundantly re-applied inside setupInfra().
     const infraResult = await setupInfra(targetPath, { force: true });
+    if (infraResult?.refused) {
+      process.exitCode = 1;
+      return infraResult;
+    }
     spinner.start('Continuing...');
 
     // Derive display variables from what setupInfra installed
@@ -263,6 +267,7 @@ export async function initCommand(options) {
             const rulesSrc = join(fwSrcDir, 'rules');
             const rulesDest = join(targetPath, '.claude', 'rules');
             installRulesForStack(rulesSrc, rulesDest, stackTags);
+            installCommandsForStack(join(fwSrcDir, 'commands'), join(targetPath, '.claude', 'commands'), stackTags);
 
             // Skills
             await installSkills(targetPath, { projectTags: stackTags });

package/src/commands/project/setup-infra-cmd.js

@@ -4,7 +4,8 @@ import { logger } from '../../utils/logger.js';
 export async function setupInfraCommand(options) {
   const targetPath = options.path || process.cwd();
   try {
-    await setupInfra(targetPath, { reinstall: options.reinstall ?? false });
+    const result = await setupInfra(targetPath, { reinstall: options.reinstall ?? false });
+    if (result?.refused) process.exitCode = 1;
   } catch (err) {
     logger.error(`setup-infra failed: ${err.message}`);
     process.exit(1);

package/src/commands/project/stack-scan.js

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { getFeatureDir } from '../../core/paths/output-schema.js';
+import { readMorphConfig } from '../../lib/tasks/test-runner.js';
+import { notAuditedReason, scanStack, renderStackScan } from '../../lib/stack/stack-scan.js';
+import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
+
+export const STACK_SCAN_FILE = 'stack-scan.md';
+
+/** Scan the tree at `cwd`; with a feature, write `2-plan/stack-scan.md`. */
+export function runStackScan(featureName, cwd = process.cwd()) {
+  const result = scanStack(cwd, readMorphConfig(cwd));
+  const markdown = renderStackScan(result, featureName ?? 'projeto');
+  if (!featureName) return { ...result, markdown, written: null, exit: 0 };
+
+  const featureDir = join(cwd, getFeatureDir(featureName));
+  if (!existsSync(featureDir)) return { ...result, markdown, written: null, exit: 2, error: 'feature-not-found' };
+  const planDir = join(featureDir, '2-plan');
+  mkdirSync(planDir, { recursive: true });
+  const written = join(planDir, STACK_SCAN_FILE);
+  writeFileSync(written, markdown, 'utf8');
+  return { ...result, markdown, written, exit: 0 };
+}
+
+export function stackScanCommand(featureName, options = {}) {
+  if (featureName) {
+    const owner = assertOwnerTree(featureName, process.cwd());
+    if (owner.blocked) {
+      for (const { tone, text } of ownerTreeRefusalLines(featureName, owner.tree, owner.branch, `morph-spec stack-scan ${featureName}`)) {
+        console.error(chalk[tone](text));
+      }
+      process.exit(1);
+    }
+  }
+
+  const result = runStackScan(featureName);
+  if (options.json) {
+    const { markdown, ...rest } = result;
+    console.log(JSON.stringify(rest, null, 2));
+    process.exit(result.exit);
+  }
+  if (result.error === 'feature-not-found') {
+    console.error(chalk.red(`stack-scan: a feature "${featureName}" não existe — rode morph-spec create ${featureName} antes`));
+    process.exit(2);
+  }
+  if (result.written) {
+    const high = result.deviations.filter((d) => d.severity === 'Bloqueante' || d.severity === 'Alto').length;
+    console.log(chalk.green(`✓ stack-scan: ${join(getFeatureDir(featureName), '2-plan', STACK_SCAN_FILE)} gravado`));
+    const summary = result.greenfield ? 'greenfield'
+      : !result.audited ? notAuditedReason(result)
+      : `${result.deviations.length} desvio(s), ${high} Bloqueante/Alto`;
+    console.log(chalk.gray(`  ${summary}`));
+  } else {
+    process.stdout.write(result.markdown);
+  }
+  process.exit(result.exit);
+}

package/src/commands/project/standards.js

@@ -1,26 +1,20 @@
 /**
- * `morph-spec standards --find "<query>" [--category <c>] [--tags <a,b>] [--json]`
+ * `morph-spec standards [--find "<query>"] [--show <id>[#<anchor>]] [--category <c>] [--tags <a,b>] [--json]`
  *
- * Server-side replacement for "read the whole STANDARDS.json to pick 1-3
- * standards" (R2 of the performance plan — token cut per task). Today
- * morph-implement loads the full 65 KB / 60-entry registry (with a `digest`
- * per entry) just to choose a couple of relevant standards: ~16k tokens per
- * task. This command searches server-side and returns only the TOP 3 hits —
- * `id · path · digest` — where the digest is the FULL text: it is what
- * substitutes for actually reading the standard's .md file.
+ * `--find` scores the registry server-side and returns the TOP 3 hits with
+ * digest and anchor keys, so nobody reads the whole registry to pick a
+ * standard. `--show <id>#<anchor>` prints only that section of the .md;
+ * `--show <id>` prints the digest and the anchors. Bare call: categories + counts.
  *
- * Without `--find` (a bare call): lists categories + counts — a cheap
- * orientation view, no scoring.
- *
- * A query with no hit exits 0 (this is advisory tooling, not a gate) with a
- * human-readable warning + category suggestions on stderr, and — under
- * `--json` — a stable `{ query, results: [], suggestion }` shape on stdout so
- * a JSON consumer never has to special-case "no results" as a parse error.
+ * A query with no hit exits 0 (advisory, not a gate); under `--json` the
+ * shape stays `{ query, results: [], suggestion }`.
  */
 
 import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
+import { dirname, join } from 'path';
 import chalk from 'chalk';
+import { loadStandardsRegistry } from '../../lib/standards/registry.js';
+import { markdownHeadings, sectionBySlug } from '../../lib/standards/sections.js';
 
 /**
  * Resolve STANDARDS.json the same way doctor.js resolves the standards root:
@@ -41,10 +35,67 @@ export function resolveStandardsJsonPath(targetPath) {
   return null;
 }
 
-/** Load + parse STANDARDS.json. Throws on missing/invalid file — caller decides how to report it. */
-function loadRegistry(standardsJsonPath) {
-  const raw = readFileSync(standardsJsonPath, 'utf8');
-  return JSON.parse(raw);
+/**
+ * The one section a `--show` target names. `anchor` is an anchor key of the
+ * registry entry (`regra`) or any heading slug of the .md (`#regra-principal`).
+ * @returns {{ status: 'ok', section: string, slug: string }
+ *   | { status: 'unknown-anchor', anchors: Record<string, string>, headings: string[] }
+ *   | { status: 'unreadable' }}
+ */
+export function resolveStandardSection(standard, mdText, anchor) {
+  if (mdText === null) return { status: 'unreadable' };
+  const anchors = standard.anchors || {};
+  const slug = String(anchors[anchor] ?? anchor).replace(/^#/, '');
+  const section = sectionBySlug(mdText, slug);
+  if (section) return { status: 'ok', section, slug };
+  return { status: 'unknown-anchor', anchors, headings: markdownHeadings(mdText).map((h) => h.slug) };
+}
+
+function readStandardMd(standardsJsonPath, standard) {
+  try {
+    return readFileSync(join(dirname(standardsJsonPath), standard.path), 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function showStandard(standards, standardsJsonPath, target, json) {
+  const hash = String(target).indexOf('#');
+  const id = hash === -1 ? String(target) : String(target).slice(0, hash);
+  const anchor = hash === -1 ? '' : String(target).slice(hash + 1).replace(/^#+/, '');
+  const standard = standards.find((s) => s.id === id);
+  if (!standard) {
+    const near = findStandards(standards, id.replace(/-/g, ' ')).map((s) => s.id);
+    if (json) console.log(JSON.stringify({ id, error: 'unknown-id', suggestions: near }));
+    else console.error(chalk.red(`\n❌ Standard "${id}" não existe.`) + (near.length ? chalk.gray(` Talvez: ${near.join(', ')}`) : '') + '\n');
+    process.exit(1);
+  }
+  const anchors = standard.anchors || {};
+
+  if (!anchor) {
+    if (json) {
+      console.log(JSON.stringify({ id: standard.id, path: standard.path, digest: standard.digest, anchors }));
+      process.exit(0);
+    }
+    console.log(chalk.cyan(`\n${standard.id}`) + chalk.gray(`  (${standard.path})`));
+    console.log(`\n${standard.digest || '(sem digest)'}\n`);
+    console.log(chalk.bold('Âncoras') + chalk.gray(` — morph-spec standards --show ${standard.id}#<âncora>`));
+    for (const [key, slug] of Object.entries(anchors)) console.log(`  ${key.padEnd(16)}${slug}`);
+    console.log('');
+    process.exit(0);
+  }
+
+  const result = resolveStandardSection(standard, readStandardMd(standardsJsonPath, standard), anchor);
+  if (result.status === 'ok') {
+    if (json) console.log(JSON.stringify({ id: standard.id, anchor, slug: result.slug, section: result.section }));
+    else process.stdout.write(result.section);
+    process.exit(0);
+  }
+  if (json) console.log(JSON.stringify({ id: standard.id, anchor, error: result.status, anchors }));
+  else if (result.status === 'unreadable') console.error(chalk.red(`\n❌ ${standard.path} não pôde ser lido.\n`));
+  else console.error(chalk.red(`\n❌ "${anchor}" não é âncora nem heading de ${standard.id}.`)
+    + chalk.gray(` Âncoras: ${Object.keys(anchors).join(', ') || '(nenhuma)'}\n`));
+  process.exit(1);
 }
 
 /**
@@ -145,7 +196,7 @@ function parseTagsOption(raw) {
 }
 
 /**
- * @param {{ find?: string, category?: string, tags?: string, json?: boolean, cwd?: string }} [options]
+ * @param {{ find?: string, show?: string, category?: string, tags?: string, json?: boolean, cwd?: string }} [options]
  */
 export function standardsCommand(options = {}) {
   const cwd = options.cwd || process.cwd();
@@ -159,13 +210,14 @@ export function standardsCommand(options = {}) {
 
   let registry;
   try {
-    registry = loadRegistry(standardsJsonPath);
+    registry = loadStandardsRegistry(standardsJsonPath);
   } catch (err) {
     console.error(chalk.red(`\n❌ STANDARDS.json inválido em ${standardsJsonPath}: ${err.message}\n`));
     process.exit(1);
   }
 
-  const standards = Array.isArray(registry.standards) ? registry.standards : [];
+  const standards = registry.standards;
+  if (options.show) showStandard(standards, standardsJsonPath, options.show, options.json);
   const query = (options.find || '').trim();
 
   // ── Bare call (no --find): categories + counts, cheap orientation ────────
@@ -180,7 +232,7 @@ export function standardsCommand(options = {}) {
     for (const { category, count } of counts) {
       console.log(`  ${col(category, 20)}${count}`);
     }
-    console.log(chalk.gray('\nUse --find "<query>" para buscar (top 3, com digest completo).\n'));
+    console.log(chalk.gray('\nUse --find "<query>" para buscar (top 3, com digest e âncoras) e --show <id>#<âncora> para ler uma seção.\n'));
     process.exit(0);
   }
 
@@ -201,7 +253,8 @@ export function standardsCommand(options = {}) {
   }
 
   const shaped = results.map((r) => ({
-    id: r.id, name: r.name, path: r.path, category: r.category, digest: r.digest, score: r.score,
+    id: r.id, name: r.name, path: r.path, category: r.category, digest: r.digest,
+    anchors: Object.keys(r.anchors || {}), score: r.score,
   }));
 
   if (options.json) {
@@ -214,6 +267,7 @@ export function standardsCommand(options = {}) {
     console.log(chalk.cyan(`${i + 1}. ${r.id}`) + chalk.gray(`  (${r.category})`));
     console.log(`   ${r.path}`);
     console.log(chalk.gray(`   ${r.digest}`));
+    if (r.anchors.length) console.log(`   âncoras: ${r.anchors.join(', ')}` + chalk.gray(`  → morph-spec standards --show ${r.id}#<âncora>`));
     console.log('');
   });
   process.exit(0);