@polymorphism-tech/morph-spec 8.43.0 → 8.45.0

package/src/commands/validation/mutate.js

@@ -176,7 +176,7 @@ export async function mutateCommand(feature, options = {}) {
       merged.method.jobs = Math.max(merged.method.jobs ?? 1, result.method.jobs);
     }
   } catch (err) {
-    if (err instanceof HeavyBusyError) return fail(`suíte não rodou: ${err.message}. Tente de novo quando liberar (morph-spec heavy status).`, EXIT.busy);
+    if (err instanceof HeavyBusyError) return fail(`suíte não rodou: ${err.message}. A fila já esperou o prazo dela: não repita em laço — registre a mutação como não executada (morph-spec heavy status).`, EXIT.busy);
     if (err.code === 'baseline-build-failed') return fail(`${err.message}\n${String(err.output ?? '').split('\n').slice(-12).join('\n')}`, EXIT.failed);
     throw err;
   }

package/src/commands/validation/scout-check.js

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+import { checkScoutMap, resolveScoutRoot } from '../../lib/scout/scout-check.js';
+
+export function scoutCheckCommand(mapPath, options = {}) {
+  const file = resolve(mapPath);
+  if (!existsSync(file)) {
+    if (options.json) console.log(JSON.stringify({ ok: false, error: 'map-not-found', map: file }));
+    else console.error(chalk.red(`scout-check: mapa não encontrado: ${file}`));
+    process.exit(2);
+  }
+  const result = { map: file, ...checkScoutMap(readFileSync(file, 'utf8'), { root: resolveScoutRoot(options.root) }) };
+
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else if (result.ok) {
+    console.log(chalk.green(`✓ scout-check: ${result.citations.length} citações conferidas contra ${result.root}`));
+  } else {
+    console.log(chalk.red(`✗ scout-check: ${result.failures.length} falha(s) em ${file} (raiz ${result.root})`));
+    for (const f of result.failures) {
+      const where = f.line ? `L${f.line}` : '—';
+      console.log(`  ${where} ${chalk.yellow(f.kind)} ${f.citation ?? ''} ${f.detail}`);
+    }
+    console.log(chalk.gray('  Mapa reprovado: descarte e re-despache o scout UMA vez com estas falhas no prompt (MORPH.md §6).'));
+  }
+  process.exit(result.ok ? 0 : 1);
+}

package/src/commands/validation/validate-feature.js

@@ -84,28 +84,6 @@ const OUTPUT_SECTIONS = {
       ['Performance', 'Desempenho'],
     ],
   },
-  // morph-plan (mandate.md) emits: Stack, Standards obrigatórios,
-  // Patterns proibidos, Verificação de runtime, Checklist de done.
-  'mandate.md': {
-    required: [
-      'Stack',
-      ['Standards', 'Padrões', 'Padroes'],
-      ['Done', 'Pronto', 'Checklist', 'Critérios de done', 'Definition of Done'],
-    ],
-    recommended: [
-      ['Patterns proibidos', 'Padrões proibidos', 'Padroes proibidos', 'Forbidden Patterns', 'Forbidden', 'Proibido'],
-      // Recommended rather than required on purpose: mandate.md freezes after
-      // Gate 2 (protect-spec-files blocks Write AND Edit), so promoting this to
-      // `required` would fail every in-flight feature with no way to fix it.
-      // New mandates get the section from morph-plan §4; the enforcement that
-      // actually matters is verify's e2e node, not this heading check.
-      ['Verificação de runtime', 'Verificacao de runtime', 'Runtime', 'E2E'],
-    ],
-    optional: [
-      ['Riscos', 'Risks'],
-      ['Acesso a dados', 'Data Access', 'Repository', 'Repositório'],
-    ],
-  },
   // decisions.md follows the ADR convention: an `### ADR-NNN` heading with
   // `**Status:** / **Context:** / **Decision:**` line-start bold labels.
   'decisions.md': {
@@ -123,19 +101,14 @@ const OUTPUT_SECTIONS = {
       ['Custos', 'Costs'],
     ],
   },
-  // morph-review emits: Scores por dimensão, Bloqueantes, Melhorias,
-  // Recomendação final.
   'review-report.md': {
     required: [
-      ['Scores', 'Score', 'Pontuação', 'Pontuacao', 'Scoring'],
-      ['Recomendação', 'Recomendacao', 'Recommendation'],
+      ['Veredito', 'Verdict'],
     ],
     recommended: [
-      ['Bloqueantes', 'Bloqueante', 'Blockers'],
-    ],
-    optional: [
-      ['Melhorias', 'Improvements', 'Recomendadas'],
+      ['Bloqueadores', 'Bloqueantes', 'Blockers'],
     ],
+    optional: [],
   },
 };
 
@@ -145,13 +118,13 @@ const OUTPUT_SECTIONS = {
 const PHASE_OUTPUTS = {
   proposal: ['proposal.md'],
   uiux: ['design-system.md', 'mockups.md', 'components.md', 'flows.md'],
-  plan: ['spec.md', 'mandate.md', 'tasks.json'],
+  plan: ['spec.md', 'tasks.json'],
   implement: ['recap.md'],
   review: ['review-report.md'],
 };
 
 // Work types whose plan phase (see src/core/work-types.js) skips proposal.md/
-// spec.md/mandate.md — chore and hotfix stamp proposal+plan gates at birth
+// spec.md — chore and hotfix stamp proposal+plan gates at birth
 // (policy-approved, no human deliberation over those docs) and go straight to
 // tasks.json. Validating the full plan doc set against a feature that was
 // never asked to write those docs would be a false failure, not a real gap.

package/src/commands/validation/verify.js

@@ -129,6 +129,13 @@ function decidePersistence({ cwd, featureName, noPersist }) {
   return { persist: false, reason: samePath(root, cwd) ? 'owner-tree-elsewhere' : 'unregistered-worktree' };
 }
 
+function baselineStampBlock(baseline) {
+  if (!baseline?.recorded) return baseline?.reason ? `record-baseline: ${baseline.reason}` : 'record-baseline';
+  const fell = baseline.updates.filter((u) => u.from !== null && u.to < u.from);
+  if (fell.length === 0) return null;
+  return `record-baseline: a contagem caiu em ${fell.map((u) => `${u.id} (${u.from} → ${u.to})`).join(', ')}`;
+}
+
 /**
  * The per-node status map, in the shape `feature.schema.json` fixes for BOTH
  * writers of it — the per-scope history entry (`verifications.*`) and the
@@ -196,8 +203,7 @@ const PARTIAL_RUN_FLAGS = [['filter', 'filtered'], ['skipTests', 'skip-tests'],
  * paths to it — never a verdict, because a verdict about nothing is worse
  * than a refusal:
  *   - unknown feature, or unknown task id (the task's `group` decides the
- *     rubric, so it is a hard usage error here, unlike the advisory warning
- *     `morph-spec score` gives for the same situation);
+ *     rubric, so it is a hard usage error here);
  *   - `--filter` that matches no declared node (a filtered-to-empty run is
  *     green and proves nothing);
  *   - `--record-baseline` with nowhere to write (no `config.json`), or with a
@@ -256,7 +262,7 @@ export async function verifyCommand(featureName, taskId, options = {}) {
       process.exit(2);
     }
     // Ocupado não é veredito: nada foi verificado, então não há stamp nem
-    // evento, e o exit 3 diz "tente de novo", nunca "vermelho".
+    // evento, e o exit 3 nunca é "vermelho".
     if (err instanceof HeavyBusyError) {
       if (options.json) {
         const holders = err.holders.map(({ pid, label, feature, node, since }) => ({ pid, label, feature, node, since }));
@@ -264,7 +270,7 @@ export async function verifyCommand(featureName, taskId, options = {}) {
           status: 'busy', persisted: false, busy: { reason: err.reason, holders, freeGb: err.freeGb, waitedMs: err.waitedMs },
         }, null, 2));
       }
-      console.error(chalk.yellow(`\n⏳ verify não rodou: ${err.message}. Não é vermelho — tente de novo quando liberar (\`morph-spec heavy status\`).\n`));
+      console.error(chalk.yellow(`\n⏳ verify não rodou: ${err.message}. Não é vermelho — a fila já esperou o prazo dela: não repita em laço — siga sem esta rodada e avise o usuário (\`morph-spec heavy status\` mostra quem segura os slots).\n`));
       process.exit(3);
     }
     throw err;
@@ -277,30 +283,15 @@ export async function verifyCommand(featureName, taskId, options = {}) {
   });
 
   const scopeKey = taskId ? `taskVerifications.${taskId}` : 'verifications.feature';
-  // `--record-baseline` is config maintenance, not gate evidence: it measures
-  // the suite in order to write `expectedCount`. Persisting a `verification`
-  // stamp from it would let a maintenance run stand in for the proof a gate
-  // asks for — the same class of confusion as a hand-typed baseline.
-  //
-  // `--filter` at FEATURE scope is the other side of the same hole (#87): the
-  // run is narrowed to a subset of nodes, but the stamp it would write carries
-  // `scope: 'feature'` — the one scope risk-detector.js trusts unconditionally.
-  // A partial run must not stand in for the proof a gate asks for, same as
-  // `--record-baseline` above. `--skip-tests` and `--skip-build` are the same
-  // partial run through another door (#113): a skipped node never reddens the
-  // rollup, so the stamp said `pass` over a suite (or a build) that never ran,
-  // and no gate rule reads a skipped `tests`/`build`. Task scope is unaffected:
-  // that stamp already says `scope: 'task:{id}'` (which pauses the ship gate on
-  // its own), and `taskVerifications` never claimed to cover more than the
-  // task. Checked AFTER `--no-persist` (via the `!options.noPersist` guard) so
-  // an explicit `--no-persist` keeps its own reason instead of being reported
-  // as one of these — the flags are all "don't write", but decidePersistence()
-  // already owns the former's reason.
+  // A run that measured only part of the suite must not stand in for the proof a gate asks for:
+  // --filter and --skip-* at feature scope, or a --record-baseline that recorded nothing. Task scope
+  // is unaffected (its stamp already says scope 'task:{id}'); --no-persist keeps its own reason.
   const partialFeatureRun = (!options.noPersist && !taskId)
     ? PARTIAL_RUN_FLAGS.find(([flag]) => options[flag])?.[1] ?? null
     : null;
-  const { persist, reason } = options.recordBaseline
-    ? { persist: false, reason: 'record-baseline' }
+  const baselineBlock = options.recordBaseline ? baselineStampBlock(result.baseline) : null;
+  const { persist, reason } = baselineBlock
+    ? { persist: false, reason: baselineBlock }
     : partialFeatureRun
       ? { persist: false, reason: partialFeatureRun }
       : decidePersistence({ cwd: process.cwd(), featureName, noPersist: options.noPersist });

package/src/core/paths/output-schema.js

@@ -46,7 +46,6 @@ export const OUTPUT_SCHEMA = {
 
   // 2-plan/
   spec:           { filename: 'spec.md',               phaseDir: '2-plan',      phase: 'plan',      protected: true,  approvalGate: 'plan' },
-  mandate:        { filename: 'mandate.md',            phaseDir: '2-plan',      phase: 'plan',      protected: true,  approvalGate: 'plan' },
   tasks:          { filename: 'tasks.json',            phaseDir: '2-plan',      phase: 'plan',      protected: true,  approvalGate: 'plan', mutableFields: ['status', 'outputs', 'notes'] },
   decisions:      { filename: 'decisions.md',          phaseDir: '2-plan',      phase: 'plan',      protected: false },
   // Veredito REUSAR/ESTENDER/CRIAR por conceito que a feature introduz, com a
@@ -55,7 +54,6 @@ export const OUTPUT_SCHEMA = {
   // como decisions.md: é registro vivo — o implementador que descobre um alvo
   // melhor no meio da task precisa poder anotar, e congelá-lo transformaria a
   // correção num bloqueio de gate.
-  reuseMap:       { filename: 'reuse-map.md',          phaseDir: '2-plan',      phase: 'plan',      protected: false },
   // N files, one per system use case — the behaviour layer the plan distils
   // BEFORE spec.md/tasks.json. Deliberately NOT protected: editing a use case
   // after Gate 2 is the supported way to change behaviour and re-run implement;

package/src/core/state/state-manager.js

@@ -581,7 +581,6 @@ export async function createFeature(featureName, options = {}) {
       review: { approved: false, timestamp: null, approvedBy: null }
     },
     gateDecisions: {},
-    taskScores: {},
     tasks: {
       total: 0,
       completed: 0,
@@ -782,7 +781,7 @@ function findClosestMatch(inputType, validTypes) {
 /**
  * Mark output as created
  * @param {string} featureName - Feature name
- * @param {string} outputType - Output type (proposal, spec, mandate, etc.)
+ * @param {string} outputType - Output type (proposal, spec, tasks, etc.)
  */
 export async function markOutput(featureName, outputType) {
   await ensureFeature(featureName);