@polymorphism-tech/morph-spec 8.18.0 → 8.19.0

package/framework/skills/core/morph-stack-scan/SKILL.md

@@ -1,10 +1,10 @@
 ---
 name: morph-stack-scan
-description: Varre o codebase existente, detecta stack atual, compara com o stack padrão e gera migration-plan.md se houver desvios
+description: Varre o codebase existente, detecta stack atual, compara com o stack padrão e registra desvios em stack-scan.md
 version: core
 when-to-invoke: ao iniciar uma feature em projeto brownfield (codebase já existente)
 user-invokable: true
-cliVersion: "8.18.0"
+cliVersion: "8.19.0"
 ---
 
 # morph-stack-scan
@@ -108,29 +108,25 @@ Antes de despachar Explore, verifique se o projeto é greenfield:
    | Runtime | .NET X | .NET 10 | ✓ / ✗ |
    ...
 
-   ## Desvios
+   ## Desvios (ordenados por severidade)
    ### Bloqueantes
-   - {desvio}: {onde foi encontrado} — impacto: {o que quebra se não migrar}
+   - {desvio}: {onde foi encontrado} — impacto: {o que quebra se não migrar} — esforço: {estimativa}
 
    ### Não bloqueantes
-   - {desvio}: {onde foi encontrado} — migração: {como resolver}
+   - {desvio}: {onde foi encontrado} — migração: {como resolver} — esforço: {estimativa}
 
    ## Recomendação
    {Em compliance — prosseguir para morph-brainstorming}
-   {ou: Migração necessária antes de prosseguir — veja migration-plan.md}
+   {ou: Migração necessária antes de prosseguir — ver Desvios acima}
    ```
 
-4. Se houver desvios bloqueantes ou altos, produza `migration-plan.md` em `.morph/features/{feature}/0-proposal/` com:
-   - Lista de desvios ordenados por severidade
-   - Para cada desvio: o que migrar, como migrar, estimativa de esforço, ordem sugerida
-   - Pergunta única via `AskUserQuestion`: "Esta migração deve ser incluída na feature atual ou tratada numa feature separada?"
+4. Se houver desvios bloqueantes ou altos, pergunte via `AskUserQuestion`: "Esta migração deve ser incluída na feature atual ou tratada numa feature separada?" A resposta é decisão humana — registre-a na seção "Compliance de stack" do `proposal.md` (produzido pela `morph-brainstorming`), não num artefato novo: a lista de desvios com impacto/esforço já vive no `stack-scan.md` acima.
 
 5. Se não houver desvios (ou apenas baixos): informe "codebase em compliance com o stack padrão" e prossiga para morph-brainstorming ou morph-plan conforme o contexto.
 
 ## Output esperado
-- `.morph/features/{feature}/0-proposal/stack-scan.md` — resultado da varredura
-- `.morph/features/{feature}/0-proposal/migration-plan.md` — apenas se houver desvios altos/bloqueantes
-- Decisão documentada: incluir migração nesta feature ou separar
+- `.morph/features/{feature}/0-proposal/stack-scan.md` — resultado da varredura, com desvios ordenados por severidade e esforço estimado
+- Decisão documentada: incluir migração nesta feature ou separar (registrada no proposal.md pela morph-brainstorming)
 
 ## Referências
 - `framework/MORPH.md` — seção 4 (Standards), seção 2 (Fases)

package/framework/skills/core/morph-standards/SKILL.md

@@ -4,7 +4,7 @@ description: Localiza e carrega um standard específico do STANDARDS.json sob de
 version: core
 when-to-invoke: quando precisar consultar um standard específico durante a implementação
 user-invokable: true
-cliVersion: "8.18.0"
+cliVersion: "8.19.0"
 ---
 
 # morph-standards

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "8.18.0",
+  "version": "8.19.0",
   "description": "MORPH-SPEC: NLH (Natural Language Harness) for spec-driven development with Claude Code",
   "keywords": [
     "claude-code",

package/src/commands/project/status.js

@@ -62,7 +62,7 @@ function getPhaseStatus(phaseKey, currentPhase, feature) {
  */
 function checkPhaseOutputs(phaseKey, feature) {
   const phaseOutputMap = {
-    proposal: ['proposal', 'stackScan', 'migrationPlan'],
+    proposal: ['proposal', 'stackScan'],
     uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
     plan: ['spec', 'mandate', 'tasks', 'decisions'],
     implement: ['recap'],
@@ -100,7 +100,7 @@ function formatPhase(phaseKey, currentPhase, feature, options = {}) {
   // Add output files if verbose
   if (options.verbose && status !== 'pending' && status !== 'skipped') {
     const phaseOutputMap = {
-      proposal: ['proposal', 'stackScan', 'migrationPlan'],
+      proposal: ['proposal', 'stackScan'],
       uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
       plan: ['spec', 'mandate', 'tasks', 'decisions'],
       implement: ['recap'],

package/src/commands/state/gate-check.js

@@ -0,0 +1,223 @@
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
+import { getFeature } from '../../core/state/state-manager.js';
+import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
+import { shouldPauseGate, getRiskSignals } from '../../lib/risk-detector.js';
+import { persistGateDecision, VALID_GATES, readTrustFromConfig } from './gate-decision.js';
+import { detectDefaultBranch, getHeadSha, getDiffStat } from '../../lib/git/default-branch.js';
+
+/**
+ * `--signals` on `gate-check` is NOT a general override like `gate-decision`'s
+ * — everything else here is read straight off disk (workType, taskCount, sha,
+ * diffstat, verification), and letting a caller override those would let a
+ * careless/hostile `--signals` silently defeat the policy this command exists
+ * to make deterministic (e.g. overriding `workType` away from "hotfix" would
+ * suppress risk-detector's forced Gate-3 pause). Only the signals that are
+ * genuinely NOT derivable from disk today are accepted here:
+ *   - standardsViolations / designSystemDivergence: still an LLM's
+ *     natural-language read (see the R4 report — no deterministic detector
+ *     exists in JS yet).
+ *   - evalScore: escape hatch for the TRUE Gate-3 composite score. Since R4
+ *     the evaluator-report carries a machine-readable `**Composite-Score:**`
+ *     token that this command parses by itself (see evaluatorCompositeScore),
+ *     so the override is only needed for legacy reports without the token —
+ *     there the taskScores-average proxy is the fallback.
+ */
+const OVERRIDABLE_SIGNAL_KEYS = ['standardsViolations', 'designSystemDivergence', 'evalScore'];
+
+/** Read tasks.json's task list for a feature; [] if missing/corrupt. Mirrors verify.js's readTasks(). */
+function readTasks(featureName) {
+  try {
+    const tasksPath = getAbsoluteOutputPath(process.cwd(), featureName, 'tasks');
+    if (!existsSync(tasksPath)) return [];
+    return JSON.parse(readFileSync(tasksPath, 'utf8')).tasks || [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Composite eval score PROXY: the average of `lastScore` across every task
+ * recorded in `feature.taskScores`, rounded to 1 decimal. `lastScore` (not
+ * `bestScore`) on purpose — a gate check reports current-state risk, and
+ * `bestScore` can be a stale high-water mark from an attempt the code no
+ * longer matches. "average" mirrors morph-apply's own Gate-3 risk-signal
+ * prose ("Score médio < 9 no review-report" — SKILL.md §5).
+ *
+ * This is explicitly NOT the true Gate-3 composite score (see
+ * OVERRIDABLE_SIGNAL_KEYS doc above) — undefined (key omitted) when no task
+ * has been scored yet, so shouldPauseGate's `typeof === 'number'` check
+ * naturally skips it instead of pausing on a false 0.
+ *
+ * @param {object} feature
+ * @returns {number|undefined}
+ */
+function compositeEvalScore(feature) {
+  const scores = Object.values(feature.taskScores || {})
+    .map((t) => t.lastScore)
+    .filter((n) => typeof n === 'number');
+  if (scores.length === 0) return undefined;
+  const avg = scores.reduce((a, b) => a + b, 0) / scores.length;
+  return Math.round(avg * 10) / 10;
+}
+
+/**
+ * Parse the machine-readable `**Composite-Score:** N.N` token out of
+ * evaluator-report.md — the mirror of approve.js's `**Reviewed-SHA:**`
+ * pattern. This is the TRUE Gate-3 composite (written by the independent
+ * evaluator, per morph-review's dispatch contract), preferred over the
+ * taskScores-average proxy whenever present. Returns undefined when the
+ * report or the token is absent (legacy report) — the proxy stays the
+ * fallback, `--signals evalScore` still overrides both.
+ */
+function evaluatorCompositeScore(cwd, featureName) {
+  try {
+    const p = getAbsoluteOutputPath(cwd, featureName, 'evaluatorReport');
+    if (!existsSync(p)) return undefined;
+    const m = readFileSync(p, 'utf8').match(/\*\*Composite-Score:\*\*\s*([0-9]+(?:\.[0-9]+)?)/);
+    return m ? Number(m[1]) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Collect every signal `shouldPauseGate()` (risk-detector.js) is documented
+ * to consume, straight off disk — the deterministic call site risk-detector
+ * never had (it shipped fully tested with zero callers; see the R4 report).
+ *
+ * `verificationStatus` feeds a real pause rule (verify vermelho pausa —
+ * política adicionada em risk-detector.js no fecho do R4); `verification`
+ * completo, verificationStale, diffstat e sha seguem como contexto de
+ * auditoria persistido, sem regra própria.
+ *
+ * @param {string} featureName
+ * @param {object} feature
+ * @param {string} cwd
+ * @param {string} gateName
+ * @returns {object}
+ */
+function collectSignals(featureName, feature, cwd, gateName) {
+  const tasks = readTasks(featureName);
+  const defaultBranch = detectDefaultBranch(cwd);
+  const sha = getHeadSha(cwd);
+  const verification = feature.verification || null;
+
+  const signals = {
+    workType: feature.workType || 'feature',
+    taskCount: tasks.length,
+    standardsViolations: [],
+    designSystemDivergence: false,
+  };
+
+  const evalScore = compositeEvalScore(feature);
+  if (evalScore !== undefined) {
+    signals.evalScore = evalScore;
+    signals.evalScoreSource = 'taskScores-proxy';
+  }
+
+  // No Gate 3, o score verdadeiro do avaliador independente (token
+  // Composite-Score no evaluator-report.md) tem precedência sobre o proxy.
+  if (gateName === 'review') {
+    const trueComposite = evaluatorCompositeScore(cwd, featureName);
+    if (trueComposite !== undefined) {
+      signals.evalScore = trueComposite;
+      signals.evalScoreSource = 'evaluator-report';
+    }
+  }
+
+  // verificationStatus alimenta a regra "verify vermelho pausa"; o resto do
+  // stamp é auditoria. verificationStale é fail-open na direção "not stale":
+  // stamp com sha null (checkout sem git) ou stamp ausente lê como NOT stale.
+  signals.verification = verification;
+  if (verification?.status) signals.verificationStatus = verification.status;
+  signals.verificationStale = Boolean(verification?.sha && sha && verification.sha !== sha);
+  signals.diffstat = getDiffStat(defaultBranch, cwd);
+  signals.sha = sha;
+
+  return signals;
+}
+
+/**
+ * `morph-spec gate-check <feature> <gate> [--signals <json>] [--trust <mode>]
+ * [--json]` — the deterministic, disk-derived counterpart to `gate-decision`:
+ * collects the signals `shouldPauseGate()` (risk-detector.js) already knows
+ * how to score, calls it, and persists the result through the SAME write path
+ * as `gate-decision` ({@link persistGateDecision}) so the two commands can
+ * never produce a differently-shaped `gateDecisions.{gate}` entry.
+ *
+ * Golden rule: this command does NOT change gate policy. It is a faithful
+ * caller of risk-detector.js's existing, already-tested rules — nothing here
+ * adds a new pause condition. Where the skills' natural-language risk tables
+ * (morph-brainstorming/morph-plan/morph-review/morph-apply) diverge from
+ * risk-detector.js, risk-detector.js wins (see the R4 report for the full list).
+ */
+export async function gateCheckCommand(featureName, gateName, options = {}) {
+  try {
+    if (!VALID_GATES.includes(gateName)) {
+      console.error(chalk.red(`\n❌ Invalid gate: ${gateName}`));
+      console.error(chalk.gray(`Valid gates: ${VALID_GATES.join(', ')}\n`));
+      process.exit(1);
+    }
+
+    const feature = getFeature(featureName);
+    if (!feature) {
+      console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
+      process.exit(1);
+    }
+
+    let overrides = {};
+    if (options.signals !== undefined) {
+      let parsed;
+      try {
+        parsed = JSON.parse(options.signals);
+      } catch (err) {
+        console.error(chalk.red(`\n❌ Invalid --signals: not valid JSON (${err.message})\n`));
+        process.exit(1);
+      }
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        console.error(chalk.red('\n❌ Invalid --signals: expected a JSON object, e.g. \'{"evalScore":9.2}\'\n'));
+        process.exit(1);
+      }
+
+      const rejected = Object.keys(parsed).filter((k) => !OVERRIDABLE_SIGNAL_KEYS.includes(k));
+      if (rejected.length > 0) {
+        console.error(chalk.yellow(
+          `\n⚠️  --signals ignored for keys not derived from disk-facts you may safely override: ${rejected.join(', ')}\n` +
+          `   Only ${OVERRIDABLE_SIGNAL_KEYS.join(', ')} may be overridden here — everything else is read from feature.json/tasks.json/git.\n` +
+          `   Use \`morph-spec gate-decision\` directly for a fully manual decision.\n`
+        ));
+      }
+      for (const key of OVERRIDABLE_SIGNAL_KEYS) {
+        if (key in parsed) overrides[key] = parsed[key];
+      }
+    }
+
+    const cwd = process.cwd();
+    const signals = { ...collectSignals(featureName, feature, cwd, gateName), ...overrides };
+
+    const trust = options.trust || readTrustFromConfig();
+    const { pause, reason } = shouldPauseGate({ trust }, signals);
+
+    const entry = await persistGateDecision(featureName, gateName, { pause, reason, signals, trust });
+
+    if (options.json) {
+      console.log(JSON.stringify({ feature: featureName, gate: gateName, ...entry }, null, 2));
+      return;
+    }
+
+    const allSignals = getRiskSignals(signals);
+    console.log(entry.pause
+      ? chalk.yellow(`\n⏸️  Gate "${gateName}" — PAUSE (${featureName})`)
+      : chalk.green(`\n▶️  Gate "${gateName}" — auto-pass (${featureName})`));
+    console.log(chalk.gray(`   reason: ${entry.reason} | trust: ${entry.trust} | decidedAt: ${entry.decidedAt}`));
+    if (allSignals.length > 0) {
+      console.log(chalk.gray(`   risk signals present: ${allSignals.join('; ')}`));
+    }
+    console.log(chalk.gray(`   signals: ${JSON.stringify(entry.signals)}`));
+    console.log('');
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Error running gate check: ${error.message}\n`));
+    process.exit(1);
+  }
+}

package/src/commands/state/gate-decision.js

@@ -3,7 +3,7 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { getFeature, updateFeature } from '../../core/state/state-manager.js';
 
-const VALID_GATES = ['proposal', 'uiux', 'plan', 'review'];
+export const VALID_GATES = ['proposal', 'uiux', 'plan', 'review'];
 
 function parsePauseValue(raw) {
   const v = String(raw).toLowerCase();
@@ -13,8 +13,12 @@ function parsePauseValue(raw) {
   process.exit(1);
 }
 
-/** trust from the committed config (BOM-tolerant), defaulting to "auto". */
-function readTrustFromConfig() {
+/**
+ * trust from the committed config (BOM-tolerant), defaulting to "auto".
+ * Shared by `gate-decision` (recorded as metadata) and `gate-check`
+ * (drives shouldPauseGate's decision directly).
+ */
+export function readTrustFromConfig() {
   try {
     const path = join(process.cwd(), '.morph', 'config', 'config.json');
     if (!existsSync(path)) return 'auto';
@@ -25,6 +29,35 @@ function readTrustFromConfig() {
   }
 }
 
+/**
+ * Write the canonical `gateDecisions.{gate}` entry to a feature's
+ * authoritative feature.json — the ONE write path both `gate-decision` (a
+ * caller-supplied pause/reason/signals, e.g. an LLM's natural-language risk
+ * read, or a manual override) and `gate-check` (a `shouldPauseGate()`-derived
+ * pause/reason/signals) feed into, so the two commands can never drift into
+ * two different persisted shapes for the same field. Does NOT validate
+ * `gateName` — callers that need a friendly CLI error check `VALID_GATES`
+ * themselves before calling this.
+ *
+ * @param {string} featureName
+ * @param {string} gateName
+ * @param {{ pause: boolean, reason?: string, signals?: object, trust?: string }} decision
+ * @returns {Promise<{ pause: boolean, reason: string, signals: object, trust: string, decidedAt: string }>}
+ *   the exact entry written (decidedAt is server-side, generated here).
+ */
+export async function persistGateDecision(featureName, gateName, { pause, reason, signals = {}, trust } = {}) {
+  const entry = {
+    pause,
+    reason: reason || (pause ? 'risco detectado' : 'nenhum sinal de risco'),
+    signals,
+    trust: trust || readTrustFromConfig(),
+    decidedAt: new Date().toISOString(),
+  };
+
+  await updateFeature(featureName, `gateDecisions.${gateName}`, entry);
+  return entry;
+}
+
 /**
  * `morph-spec gate-decision <feature> <gate> --pause <bool> [--reason <txt>]
  * [--signals <json>] [--trust <mode>]` — record the trust decision for a gate
@@ -36,6 +69,12 @@ function readTrustFromConfig() {
  * state-sync hook rewriting the file between the agent's Read and Edit
  * ("file modified since read"). The canonical shape is documented in
  * framework/schemas/feature.schema.json and consumed by gate-guard.js.
+ *
+ * The manual escape hatch: `gate-check` (src/commands/state/gate-check.js) is
+ * the default, disk-derived path via `shouldPauseGate()`; this command stays
+ * for a caller that already knows the decision (an LLM's natural-language
+ * risk read a script can't see, or a deliberate override) — both write
+ * through {@link persistGateDecision}, so the persisted shape never diverges.
  */
 export async function gateDecisionCommand(featureName, gateName, options = {}) {
   try {
@@ -71,15 +110,12 @@ export async function gateDecisionCommand(featureName, gateName, options = {}) {
       }
     }
 
-    const entry = {
+    const entry = await persistGateDecision(featureName, gateName, {
       pause,
-      reason: options.reason || (pause ? 'risco detectado' : 'nenhum sinal de risco'),
+      reason: options.reason,
       signals,
-      trust: options.trust || readTrustFromConfig(),
-      decidedAt: new Date().toISOString(),
-    };
-
-    await updateFeature(featureName, `gateDecisions.${gateName}`, entry);
+      trust: options.trust,
+    });
 
     if (options.json) {
       console.log(JSON.stringify({ feature: featureName, gate: gateName, ...entry }, null, 2));

package/src/commands/validation/verify.js

@@ -5,6 +5,7 @@ import { getFeature, updateFeature } from '../../core/state/state-manager.js';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { runVerify } from '../../lib/validators/verify-runner.js';
 import { resolvePrimaryRoot } from '../project/worktree.js';
+import { getHeadSha } from '../../lib/git/default-branch.js';
 
 /** ✓ pass · ✗ fail · – skip */
 function statusIcon(status) {
@@ -160,6 +161,7 @@ export async function verifyCommand(featureName, taskId, options = {}) {
   let compact = null;
   if (persist) {
     const prevEntry = taskId ? feature.taskVerifications?.[taskId] : feature.verifications?.feature;
+    const now = new Date().toISOString();
     compact = {
       status: result.status,
       nodes: {
@@ -169,9 +171,24 @@ export async function verifyCommand(featureName, taskId, options = {}) {
       },
       score: result.nodes.validators.score ?? null,
       attempts: (prevEntry?.attempts ?? 0) + 1,
-      updatedAt: new Date().toISOString(),
+      updatedAt: now,
     };
     await updateFeature(featureName, scopeKey, compact);
+
+    // Singular, scope-agnostic "latest stamp" — distinct from the
+    // verifications/taskVerifications history above. `sha` is what lets a
+    // consumer (morph-spec gate-check) correlate this pass/fail with the
+    // EXACT commit it covers, the same way review-report.md's
+    // `**Reviewed-SHA:**` token lets approve.js detect a stale review. null
+    // in a non-git checkout (or before the first commit) — fail-open, never
+    // blocks persistence.
+    const stamp = {
+      status: result.status,
+      sha: getHeadSha(process.cwd()),
+      ts: now,
+      scope: taskId ? `task:${taskId}` : 'feature',
+    };
+    await updateFeature(featureName, 'verification', stamp);
   }
 
   if (options.json) {

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

@@ -37,7 +37,6 @@ export const OUTPUT_SCHEMA = {
   // 0-proposal/
   proposal:       { filename: 'proposal.md',           phaseDir: '0-proposal',  phase: 'proposal',  protected: false },
   stackScan:      { filename: 'stack-scan.md',         phaseDir: '0-proposal',  phase: 'proposal',  protected: false },
-  migrationPlan:  { filename: 'migration-plan.md',     phaseDir: '0-proposal',  phase: 'proposal',  protected: false },
 
   // 1-design/ (optional)
   uiDesignSystem: { filename: 'design-system.md',      phaseDir: '1-design',    phase: 'uiux',      protected: true,  approvalGate: 'uiux' },

package/src/lib/agents/output-collector.js

@@ -15,7 +15,6 @@ import { OUTPUT_SCHEMA, getAbsoluteOutputPath } from '../../core/paths/output-sc
 export const SOURCE_WEIGHTS = {
   proposal:       1.0,
   stackScan:      0.8,
-  migrationPlan:  0.8,
   spec:           1.5,
   mandate:        1.3,
   tasks:          1.3,

package/src/lib/git/default-branch.js

@@ -71,3 +71,68 @@ export function hasOriginRemote(cwd = process.cwd()) {
     return false;
   }
 }
+
+/**
+ * Resolve HEAD's full commit SHA. Fail-open: null when cwd isn't a git repo,
+ * or the repo has no commits yet (unborn HEAD) — never throws.
+ *
+ * Shared by `morph-spec verify` (the `verification` stamp) and
+ * `morph-spec gate-check` (signals + staleness-vs-code checks) — both need
+ * the exact commit a result covers, mirroring the same fail-open pattern
+ * `reviewStaleness()` in approve.js uses for the same `git rev-parse HEAD` call.
+ *
+ * @param {string} [cwd]
+ * @returns {string|null}
+ */
+export function getHeadSha(cwd = process.cwd()) {
+  try {
+    return execFileSync('git', ['rev-parse', 'HEAD'], { cwd, stdio: 'pipe' }).toString().trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse `git diff --shortstat` output ("3 files changed, 45 insertions(+), 2
+ * deletions(-)") into counts. Any line missing (e.g. only insertions, no
+ * deletions) contributes 0 for that field. Empty input (no diff) is all-zero,
+ * not an error.
+ *
+ * @param {string} text
+ * @returns {{ filesChanged: number, insertions: number, deletions: number }}
+ */
+function parseShortstat(text) {
+  const files = /(\d+) files? changed/.exec(text || '');
+  const ins = /(\d+) insertions?\(\+\)/.exec(text || '');
+  const del = /(\d+) deletions?\(-\)/.exec(text || '');
+  return {
+    filesChanged: files ? Number(files[1]) : 0,
+    insertions: ins ? Number(ins[1]) : 0,
+    deletions: del ? Number(del[1]) : 0,
+  };
+}
+
+/**
+ * `git diff --shortstat <baseRef>` against the CURRENT WORKING TREE (tracked
+ * edits — staged, unstaged, and everything committed since baseRef —
+ * deliberately not `baseRef...HEAD`, so a gate-check mid-implement still sees
+ * uncommitted work). Same as plain `git diff`, this does NOT count brand-new
+ * UNTRACKED files (never `git add`-ed) — a real, known gap if a gate check
+ * runs before `git add`; not fixed here since covering it needs `--no-index`
+ * or `git add -N` bookkeeping this shared helper doesn't own. Fail-open: null
+ * when `baseRef` is falsy, cwd isn't a git repo, or the diff itself fails
+ * (e.g. baseRef doesn't resolve).
+ *
+ * @param {string|null} baseRef - typically `detectDefaultBranch(cwd)`
+ * @param {string} [cwd]
+ * @returns {{ filesChanged: number, insertions: number, deletions: number }|null}
+ */
+export function getDiffStat(baseRef, cwd = process.cwd()) {
+  if (!baseRef) return null;
+  try {
+    const out = execFileSync('git', ['diff', '--shortstat', baseRef], { cwd, stdio: 'pipe' }).toString().trim();
+    return parseShortstat(out);
+  } catch {
+    return null;
+  }
+}

package/src/lib/risk-detector.js

@@ -8,6 +8,7 @@
  * Signals checked (in order):
  *   - designSystemDivergence: boolean — conflicting design sources detected
  *   - standardsViolations: string[]   — violations of mandate.md proibições
+ *   - verificationStatus: string      — último `morph-spec verify` ('fail' pausa)
  *   - evalScore: number               — morph-eval score (pause if < 9)
  *   - taskCount: number               — total tasks (pause if > 20)
  */
@@ -52,6 +53,17 @@ export function shouldPauseGate(config, signals) {
     };
   }
 
+  // Verify vermelho no momento do gate = a barreira determinística (build/
+  // testes/validadores) está falhando — código antes do juiz vale também
+  // para a decisão de pausa. Só 'fail' pausa: ausência de stamp não é sinal
+  // (features antigas não têm o campo).
+  if (signals.verificationStatus === 'fail') {
+    return {
+      pause: true,
+      reason: 'último morph-spec verify está VERMELHO — rode verify e corrija antes de aprovar o gate',
+    };
+  }
+
   if (typeof signals.evalScore === 'number' && signals.evalScore < MIN_EVAL_SCORE) {
     return {
       pause: true,
@@ -80,6 +92,7 @@ export function getRiskSignals(signals) {
   if (Array.isArray(signals.standardsViolations) && signals.standardsViolations.length > 0) {
     out.push(`standards violations: ${signals.standardsViolations.join(', ')}`);
   }
+  if (signals.verificationStatus === 'fail') out.push('verify vermelho');
   if (typeof signals.evalScore === 'number' && signals.evalScore < MIN_EVAL_SCORE) {
     out.push(`eval score ${signals.evalScore}/10`);
   }

package/src/lib/standards/digest-builder.js

@@ -1,72 +0,0 @@
-/**
- * Validator Prompt Builder
- *
- * Generates read-only validation task prompts for Tier-4 validator agents
- * from agents.json hook_behavior configuration.
- *
- * Used by dispatch-agents.js in --mode validate.
- */
-
-import { readFileSync, existsSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-const AGENTS_JSON_PATH = join(__dirname, '../../../framework/agents.json');
-
-let _agentsCache = null;
-
-/** Load and cache agents.json */
-function loadAgents() {
-  if (_agentsCache) return _agentsCache;
-  if (!existsSync(AGENTS_JSON_PATH)) return { agents: {} };
-  try {
-    _agentsCache = JSON.parse(readFileSync(AGENTS_JSON_PATH, 'utf8'));
-    return _agentsCache;
-  } catch {
-    return { agents: {} };
-  }
-}
-
-/**
- * Build a read-only validation task prompt for Tier-4 validator agents.
- * Uses hook_behavior.validates[] from agents.json.
- *
- * @param {string} agentId - Agent ID (must be tier 4 with hook_behavior)
- * @param {string} [taskId] - Optional task ID being validated
- * @returns {string} Validator task prompt or ''
- */
-export function buildValidatorPrompt(agentId, taskId) {
-  const agents = loadAgents();
-  const agentData = agents.agents?.[agentId];
-  if (!agentData?.hook_behavior) return '';
-
-  const validates = agentData.hook_behavior.validates || [];
-  const severity = agentData.hook_behavior.severity || 'error';
-  const blocksOnFail = agentData.hook_behavior.blocks_on_fail ?? true;
-  const taskSuffix = taskId ? ` for task ${taskId}` : '';
-
-  const lines = [
-    `You are ${agentData.title || agentId} (Tier 4 Validator). Mode: READ-ONLY validation${taskSuffix}.`,
-    `DO NOT edit any files. Review the current implementation for the following violations:`,
-    ``,
-    `Checks (severity: ${severity}):`,
-    ...validates.map(v => `  - ${v}`),
-    ``,
-    `Output a single JSON line: { "passed": boolean, "issues": [{ "file": "path/to/file", "line": 0, "message": "description", "rule": "rule-name" }] }`,
-    blocksOnFail
-      ? `BLOCKING: if any issues found, implementation must be fixed before task can complete.`
-      : `NON-BLOCKING: issues are warnings only — task completion is not blocked.`,
-  ];
-
-  return lines.join('\n');
-}
-
-/**
- * Invalidate module-level caches.
- * Used in tests to ensure a fresh load of agents.json.
- */
-export function clearCache() {
-  _agentsCache = null;
-}