@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

package/src/commands/state/approve.js

@@ -1,83 +1,63 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { execFileSync } from 'child_process';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync } from 'fs';
 import { join } from 'path';
 import { getFeature, setApprovalGate, getApprovalGate, getApprovalHistory, derivePhase } from '../../core/state/state-manager.js';
 import { unmetPrereqs } from '../../core/state/gate-order.js';
-import { evaluatorReportState, VERDICT_TOKEN } from '../../lib/evaluator-report.js';
+import { reviewReports, reviewFileName, REVIEW_ROLES, VERDICT_TOKEN, REVIEWED_SHA_TOKEN } from '../../lib/review-reports.js';
 import { shouldPauseGate } from '../../lib/risk-detector.js';
-import { collectSignals } from './gate-check.js';
+import { collectSignals, collectReviewRequirement } from './gate-check.js';
+import { autoApprovalRefusal, printRefusal } from './auto-approval.js';
 import { readTrustFromConfig } from './gate-decision.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
-import { uiuxAutoApprovalBlock } from '../../lib/specs/screen-checklist.js';
 import { treeMovedSince } from '../../lib/git/evidence-staleness.js';
+import { seedDotnetBuildIgnores } from '../../lib/stack/dotnet-build-ignores.js';
+import { reportDotnetIgnores } from './advance.js';
 
-/**
- * The literal token `review-report.md` carries to declare which tree it
- * reviewed. Kept as one exported constant so the CLI parser, the warning text
- * and the `morph-review` skill can never drift apart (the A5 lesson).
- */
-export const REVIEWED_SHA_TOKEN = '**Reviewed-SHA:**';
-
-const REVIEWED_SHA_RE = /\*\*Reviewed-SHA:\*\*\s*([0-9a-f]{7,40})/i;
-
-/**
- * Is the feature's `review-report.md` still describing the current tree?
- *
- * @param {string} featureName
- * @returns {{ status: 'ok'|'stale'|'unstamped'|'skip', reviewed?: string, head?: string, ahead?: number }}
- *   `skip` covers every case where the question cannot be answered honestly:
- *   no report, no git repo, an unresolvable SHA. Never a false refusal.
- */
-function reviewStaleness(featureName) {
-  const cwd = process.cwd();
-  const reportPath = join(cwd, '.morph', 'features', featureName, '4-review', 'review-report.md');
-  if (!existsSync(reportPath)) return { status: 'skip' };
+export { REVIEWED_SHA_TOKEN };
+
+const SIGNED_OFF = { required: [], reports: {}, checks: { status: 'ok', total: 0, missing: [], notProven: [] } };
 
+// The worst answer across every report present wins. `skip` (no verifier report, no git) never
+// refuses falsely.
+function reviewStaleness(reports) {
+  if (reports.verifier.status === 'missing') return { status: 'skip' };
+  const cwd = process.cwd();
   let head;
   try {
     head = execFileSync('git', ['rev-parse', 'HEAD'], { cwd, stdio: 'pipe' }).toString().trim();
-  } catch {
-    return { status: 'skip' }; // not a git repo (or no commits) — nothing to compare
-  }
-
-  let body = '';
-  try {
-    body = readFileSync(reportPath, 'utf8');
   } catch {
     return { status: 'skip' };
   }
 
-  const stamped = body.match(REVIEWED_SHA_RE)?.[1];
-  if (!stamped) return { status: 'unstamped', head };
-
-  let reviewed;
-  try {
-    reviewed = execFileSync('git', ['rev-parse', '--verify', `${stamped}^{commit}`], { cwd, stdio: 'pipe' })
-      .toString().trim();
-  } catch {
-    // A stamp git cannot resolve (rewritten history, a typo) is not evidence
-    // of staleness — say "unstamped" rather than block on a guess.
-    return { status: 'unstamped', head };
+  let unstamped = null;
+  for (const [role, report] of Object.entries(reports)) {
+    if (report.status === 'missing') continue;
+    const file = reviewFileName(role);
+    let reviewed = null;
+    try {
+      if (report.reviewedSha) {
+        reviewed = execFileSync('git', ['rev-parse', '--verify', `${report.reviewedSha}^{commit}`], { cwd, stdio: 'pipe' })
+          .toString().trim();
+      }
+    } catch {
+      reviewed = null;
+    }
+    if (!reviewed) {
+      unstamped ??= { status: 'unstamped', file, head };
+      continue;
+    }
+    if (!treeMovedSince(cwd, reviewed, head)) continue;
+    let ahead = 0;
+    try {
+      ahead = Number(execFileSync('git', ['rev-list', '--count', `${reviewed}..${head}`], { cwd, stdio: 'pipe' }).toString().trim()) || 0;
+    } catch { ahead = 0; }
+    return { status: 'stale', file, reviewed, head, ahead };
   }
-  if (!treeMovedSince(cwd, reviewed, head)) return { status: 'ok', reviewed, head };
-
-  let ahead = 0;
-  try {
-    ahead = execFileSync('git', ['rev-list', '--count', `${reviewed}..${head}`], { cwd, stdio: 'pipe' })
-      .toString().trim();
-    ahead = Number(ahead) || 0;
-  } catch { ahead = 0; }
-
-  // HEAD not descending from the reviewed commit (a rebase, a different branch)
-  // is still "not the tree that was reviewed".
-  return { status: 'stale', reviewed, head, ahead };
+  return unstamped ?? { status: 'ok', head };
 }
 
-/**
- * Unapprove action function - Revoke a previously approved gate
- */
 export async function unapproveCommand(featureName, gateName, options = {}) {
   try {
     if (!VALID_GATES.includes(gateName)) {
@@ -106,8 +86,7 @@ export async function unapproveCommand(featureName, gateName, options = {}) {
       return;
     }
 
-    // Same honesty rule as approveCommand: don't pretend a human revoked
-    // the gate when there's no interactive shell behind the invocation.
+    // Don't pretend a human revoked the gate without an interactive shell behind the call.
     let revokedBy;
     if (options.revoker) {
       revokedBy = options.revoker;
@@ -134,44 +113,25 @@ export async function unapproveCommand(featureName, gateName, options = {}) {
   }
 }
 
-/**
- * Approval Commands - Manage approval gates for MORPH workflow
- *
- * Commands:
- * - approve: Mark a gate as approved
- * - unapprove: Revoke a gate approval
- * - approval-status: Show approval status for all gates
- */
-
 const program = new Command();
 
-/**
- * Valid approval gate names
- */
-const VALID_GATES = ['proposal', 'uiux', 'plan', 'review'];
+const VALID_GATES = ['plan', 'uiux', 'review'];
 
-/**
- * Approve action function - Mark a gate as approved
- */
 export async function approveCommand(featureName, gateName, options = {}) {
   try {
-    // Validate gate name
     if (!VALID_GATES.includes(gateName)) {
       console.error(chalk.red(`\n❌ Invalid gate: ${gateName}`));
       console.log(chalk.gray(`Valid gates: ${VALID_GATES.join(', ')}\n`));
       process.exit(1);
     }
 
-    // Get feature state
     const feature = getFeature(featureName);
     if (!feature) {
       console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
       process.exit(1);
     }
 
-    // Owner-tree guard: a live worktree elsewhere owns this feature's state —
-    // never stamp a gate onto the root's birth-instant skeleton (branch-drift
-    // created by this command, not merely left behind by one).
+    // A live worktree elsewhere owns the state: never stamp a gate onto the root skeleton.
     const owner = assertOwnerTree(featureName, process.cwd());
     if (owner.blocked) {
       for (const { tone, text } of ownerTreeRefusalLines(featureName, owner.tree, owner.branch, `morph-spec approve ${featureName} ${gateName}`)) {
@@ -180,26 +140,18 @@ export async function approveCommand(featureName, gateName, options = {}) {
       process.exit(1);
     }
 
-    // Check if already approved
     const currentStatus = getApprovalGate(featureName, gateName);
     if (currentStatus?.approved) {
       console.log(chalk.yellow(`\n⚠️  Gate "${gateName}" is already approved`));
       console.log(chalk.gray(`Approved at: ${currentStatus.timestamp}`));
       console.log(chalk.gray(`Approved by: ${currentStatus.approvedBy || 'Unknown'}`));
-      // This early-out is a no-op that still exits 0 — deliberate, and
-      // `--force` does NOT cover it (that flag only covers gate ORDER). A
-      // caller who meant to re-approve therefore reads success and is left
-      // with nowhere to go. The way out already exists as `unapprove`; the
-      // message just never named it. Naming it is the whole fix (no new flag).
+      // `--force` does not cover this no-op (it only covers gate ORDER), so name the way out.
       console.log(chalk.gray(`To approve it again, revoke it first: morph-spec unapprove ${featureName} ${gateName}\n`));
+      if (gateName === 'plan') reportDotnetIgnores(seedDotnetBuildIgnores(process.cwd(), { featureName }));
       return;
     }
 
-    // Gate monotonicity: a gate may only be approved once its predecessors are
-    // approved (proposal → plan → review; uiux requires proposal). Prevents the
-    // lead-termometro shape — plan.approved with proposal pending. Policy-stamped
-    // gates count as approved, so chore/hotfix satisfy prereqs naturally.
-    // Escape via --force for deliberate recovery.
+    // Gate monotonicity: predecessors first; policy stamps count (`--force` to recover).
     const unmet = unmetPrereqs(gateName, feature.approvalGates);
     if (unmet.length && !options.force) {
       console.error(chalk.red(`\n❌ Cannot approve "${gateName}" — prerequisite gate(s) not approved: ${unmet.join(', ')}.`));
@@ -207,22 +159,8 @@ export async function approveCommand(featureName, gateName, options = {}) {
       process.exit(1);
     }
 
-    // Resolve who approved BEFORE the hotfix backstop — the backstop gates on
-    // the resolved signature, not the raw --mode string (see below).
-    //
-    // approvedBy resolution (most explicit wins):
-    //   1. --approver flag (CLI caller signalled who approved)
-    //   2. --mode auto  → "auto" (intentionally non-human signature)
-    //   3. interactive shell (TTY on stdin) → $USER / $USERNAME (a real
-    //      human is at the terminal; their name is the honest answer)
-    //   4. non-interactive (no TTY) → "auto"
-    //
-    // The TTY check exists because morph-spec is increasingly invoked
-    // from headless contexts (claude -p subprocesses, CI, the
-    // morph-e2e-tester). Stamping the host's $USERNAME on a gate that
-    // no human actually approved is misleading — it lies to the audit
-    // trail. "auto" reads as what it is: a deterministic policy gate,
-    // not a human signing off.
+    // Resolved BEFORE the hotfix backstop, which gates on the signature. Without a TTY the answer
+    // is "auto": stamping $USERNAME on a gate no human approved lies to the audit trail.
     let approvedBy;
     if (options.approver) {
       approvedBy = options.approver;
@@ -234,119 +172,57 @@ export async function approveCommand(featureName, gateName, options = {}) {
       approvedBy = 'auto';
     }
 
-    // Hotfix backstop: Gate 3 (review) requires a genuine HUMAN signature even
-    // in trust:auto — a work-type policy (forcedPauseGates in
-    // src/core/work-types.js, mirrored by risk-detector's
-    // FORCED_PAUSE_WORK_TYPES), enforced server-side rather than trusting the
-    // calling skill. It gates on the RESOLVED approvedBy, NOT the raw --mode
-    // string: every headless context (claude -p, CI, the Bash tool) runs
-    // without a TTY, so an omitted --mode — or any --mode ≠ 'auto' — still
-    // resolves to "auto" and would otherwise rubber-stamp the gate. A human
-    // approval is --approver <name> or an interactive TTY ($USER); anything
-    // resolving to "auto" is refused here.
-    if (gateName === 'review' && feature.workType === 'hotfix' && approvedBy === 'auto') {
-      console.error(chalk.red('\n❌ Hotfix exige aprovação humana no Gate 3 — trust:auto não se aplica.'));
-      console.error(chalk.gray('   Aprove com --approver <nome>, num terminal interativo, ou pela resposta humana "aprovado" (state-sync) ao review-report via AskUserQuestion.\n'));
+    const refusal = autoApprovalRefusal({ cwd: process.cwd(), featureName, feature, gate: gateName, approvedBy });
+    if (refusal) {
+      printRefusal(chalk, refusal);
       process.exit(1);
     }
 
-    // Gate 3 staleness backstop (D1): a review reviews a TREE, and the tree
-    // moves. Observed: review-report.md written at b30ac6e, then T3 landed and
-    // inverted the default of a business rule; the report stayed in the repo
-    // claiming 976/976 tests (they were 982) and never mentioning T3. Nothing
-    // detected that the review artifact had fallen behind the code it reviews.
-    //
-    // The report stamps the SHA it reviewed; approval compares it with HEAD.
-    // A stamp that is BEHIND HEAD refuses. A MISSING stamp only warns — reports
-    // written before this existed must not brick a legacy feature — but the
-    // warning names the exact token to add, so it teaches instead of nagging.
+    // A review reviews a TREE: a `Reviewed-SHA` behind HEAD refuses. A missing stamp only warns,
+    // naming the token to add, so a legacy report does not brick the feature.
+    const reports = gateName === 'review' ? reviewReports(process.cwd(), featureName) : null;
     if (gateName === 'review') {
-      const stale = reviewStaleness(featureName);
+      const stale = reviewStaleness(reports);
       if (stale.status === 'stale') {
-        console.error(chalk.red('\n❌ O `4-review/review-report.md` está desatualizado em relação ao código.'));
+        console.error(chalk.red(`\n❌ O \`4-review/${stale.file}\` está desatualizado em relação ao código.`));
         console.error(chalk.gray(`   Revisado em: ${stale.reviewed.slice(0, 8)}`));
         console.error(chalk.gray(`   HEAD atual:  ${stale.head.slice(0, 8)}${stale.ahead ? ` (${stale.ahead} commit(s) depois da revisão)` : ''}`));
         console.error(chalk.gray('   Um review revisa uma ÁRVORE, e a árvore andou. Re-rode a `morph-review`'));
-        console.error(chalk.gray('   (incluindo o avaliador independente) e atualize o `**Reviewed-SHA:**`.\n'));
+        console.error(chalk.gray(`   e atualize o \`${REVIEWED_SHA_TOKEN}\` de cada relatório.\n`));
         process.exit(1);
       }
       if (stale.status === 'unstamped') {
-        console.log(chalk.yellow('\n⚠️  O `review-report.md` não carrega `**Reviewed-SHA:**` — impossível saber se ele revisa o código atual.'));
-        console.log(chalk.gray(`   Adicione a linha \`**Reviewed-SHA:** ${stale.head}\` ao relatório para que o Gate 3 possa verificar.`));
-      }
-    }
-
-    // Skipped-pause backstop: a gate whose recorded decision demanded a human
-    // pause (gateDecisions[gate].pause === true) cannot then be stamped by a
-    // non-human signature. The detection already existed — in gate-guard.js —
-    // but that hook is registered for `Write|Edit|AskUserQuestion`, and a Bash
-    // tool call fires no hook at all. Since MORPH.md requires gate approval to
-    // go through THIS command and forbids hand-editing the state, the only path
-    // the hook could ever see was the one the charter bans. The check belongs
-    // where the stamp is applied, not beside it.
-    //
-    // Gated on the RESOLVED `approvedBy`, matching the hotfix backstop above:
-    // an omitted --mode in a headless context also resolves to "auto" and must
-    // not slip through. `--force` does NOT bypass this either — it is the
-    // out-of-order recovery flag, a different concern. The way out is a human
-    // signature, or rewriting the decision that asked for the pause.
-    const decision = feature.gateDecisions?.[gateName];
-    if (decision?.pause === true && approvedBy === 'auto') {
-      console.error(chalk.red(`\n❌ O Gate "${gateName}" registrou pause:true — auto-aprovação não se aplica.`));
-      console.error(chalk.gray(`   Sinal: ${decision.reason || 'risco detectado'}`));
-      console.error(chalk.gray('   A decisão gravada exigia pausa humana. Aprove com --approver <nome>, num'));
-      console.error(chalk.gray('   terminal interativo, ou pela resposta humana via AskUserQuestion (state-sync).'));
-      console.error(chalk.gray('   Se o sinal de risco já não vale, regrave a decisão:'));
-      console.error(chalk.gray(`   morph-spec gate-decision ${featureName} ${gateName} --pause false --reason "<motivo>"\n`));
-      process.exit(1);
-    }
-
-    // The same backstop when no gate-check ran: the pause it WOULD record for
-    // the screen checklist, by the predicate advance.js reads too. `--force`
-    // does not bypass it, for the reason above.
-    if (gateName === 'uiux' && approvedBy === 'auto') {
-      const block = uiuxAutoApprovalBlock(process.cwd(), featureName, feature);
-      if (block) {
-        console.error(chalk.red(`\n❌ O Gate "uiux" não pode ser auto-aprovado — ${block}.`));
-        console.error(chalk.gray('   Complete o checklist (ver a skill morph-uiux) e rode de novo, aprove com'));
-        console.error(chalk.gray('   --approver <nome>, ou, se a pausa já foi decidida, grave a decisão:'));
-        console.error(chalk.gray(`   morph-spec gate-decision ${featureName} uiux --pause false --reason "<motivo>"\n`));
-        process.exit(1);
+        console.log(chalk.yellow(`\n⚠️  O \`${stale.file}\` não carrega \`${REVIEWED_SHA_TOKEN}\` — impossível saber se ele revisa o código atual.`));
+        console.log(chalk.gray(`   Adicione a linha \`${REVIEWED_SHA_TOKEN} ${stale.head}\` ao relatório para que o Gate 3 possa verificar.`));
       }
     }
 
     let selfAssessed = false;
     if (gateName === 'review') {
       if (feature.workType === 'hotfix') {
-        // Hotfix Gate 3 does NOT require the independent evaluator: `morph-hotfix`
-        // (SKILL.md §7) never dispatches `morph-evaluator` — speed over ceremony
-        // is the point of a hotfix — and instead writes `4-review/review-report.md`
-        // (diff + real test evidence) before asking the human to approve. Requiring
-        // evaluator-report.md here made the skill's own documented flow unable to
-        // clear its own Gate 3 (the only escape was --self-assessed, which stamps
-        // a degradation for a report that was never supposed to exist). The human
-        // signature is already enforced above (line ~215) — this only checks the
-        // artifact the skill actually produces.
-        const reviewReport = join(process.cwd(), '.morph', 'features', featureName, '4-review', 'review-report.md');
-        if (!existsSync(reviewReport)) {
-          console.error(chalk.red('\n❌ Gate 3 de hotfix exige `4-review/review-report.md` — não existe.'));
-          console.error(chalk.gray('   É o artefato que a `morph-hotfix` produz (diff do fix + evidência real de'));
-          console.error(chalk.gray('   teste do `morph-spec verify`), não o `evaluator-report.md` do avaliador'));
-          console.error(chalk.gray('   independente — hotfix nunca despacha o avaliador. Escreva o relatório antes'));
+        // Hotfix never dispatches: the orchestrator writes `verifier.md` itself
+        // (diff + real verify evidence); the human signature above decides.
+        if (reports.verifier.status === 'missing') {
+          console.error(chalk.red('\n❌ Gate 3 de hotfix exige `4-review/verifier.md` — não existe.'));
+          console.error(chalk.gray('   No hotfix o orquestrador o escreve (diff do fix + evidência real do'));
+          console.error(chalk.gray('   `morph-spec verify`) sem despachar ninguém. Escreva o relatório antes'));
           console.error(chalk.gray('   de aprovar; a assinatura humana já é exigida pelo backstop acima.\n'));
           process.exit(1);
         }
       } else {
-        const report = evaluatorReportState(process.cwd(), featureName);
-        if (report.status !== 'ok') {
+        const { required } = collectReviewRequirement(process.cwd(), feature);
+        const unusable = required.filter((role) => reports[role].status !== 'ok');
+        if (unusable.length) {
           if (!options.selfAssessed) {
-            if (report.status === 'missing') {
-              console.error(chalk.red('\n❌ Gate 3 exige o avaliador independente — `4-review/evaluator-report.md` não existe.'));
-            } else {
-              console.error(chalk.red(`\n❌ Gate 3: o \`4-review/evaluator-report.md\` não tem \`${VERDICT_TOKEN} SHIP|FIX\`.`));
-              console.error(chalk.gray('   Peça ao avaliador o relatório completo (morph-review §4) ou retome-o por SendMessage.'));
+            console.error(chalk.red(`\n❌ Gate 3 exige ${required.map((r) => `\`4-review/${reviewFileName(r)}\``).join(', ')}.`));
+            for (const role of unusable) {
+              const { status } = reports[role];
+              const what = status === 'missing' ? 'não existe'
+                : status === 'partial' ? 'está PARCIAL — retome o mesmo agente por SendMessage'
+                  : `não tem \`${VERDICT_TOKEN} SHIP|FIX\``;
+              console.error(chalk.gray(`   ${reviewFileName(role)} ${what}.`));
             }
-            console.error(chalk.gray('   O veredito vem do avaliador (persona `evaluator`, contexto fresco), nunca de quem implementou.'));
+            console.error(chalk.gray(`   Os relatórios vêm de ${unusable.map((r) => `\`${REVIEW_ROLES[r].persona}\``).join(', ')} em contexto fresco, nunca de quem implementou.`));
             console.error(chalk.gray('   Se o dispatch for impossível nesta sessão, aprove com --self-assessed —'));
             console.error(chalk.gray('   a degradação fica registrada no feature.json e aparece no `list`/`fleet`.\n'));
             process.exit(1);
@@ -354,12 +230,11 @@ export async function approveCommand(featureName, gateName, options = {}) {
           selfAssessed = true;
         }
 
-        // Sem gate-check prévio não há `gateDecisions.review` para o backstop acima morder; em
-        // campo, ships passaram assim com verify vermelho ou ausente. A auto-aprovação recalcula
-        // a decisão pela MESMA régua do gate-check. --self-assessed já dispensou o veredito.
+        // Sem gate-check prévio não há `gateDecisions.review` para o backstop morder: a auto-aprovação
+        // recalcula a decisão pela MESMA régua do gate-check. --self-assessed já dispensou os relatórios.
         if (approvedBy === 'auto') {
           const signals = collectSignals(featureName, feature, process.cwd(), 'review');
-          if (selfAssessed) signals.evaluatorVerdict = { status: 'ok', verdict: 'SHIP', blockers: 0, untyped: 0 };
+          if (selfAssessed) signals.reviewReports = SIGNED_OFF;
           const { pause, reason } = shouldPauseGate({ trust: readTrustFromConfig() }, signals);
           if (pause) {
             console.error(chalk.red(`\n❌ Gate 3 não pode ser auto-aprovado — ${reason}.`));
@@ -368,9 +243,12 @@ export async function approveCommand(featureName, gateName, options = {}) {
           }
         }
 
-        if (report.status === 'ok' && report.superseded.length > 0) {
-          console.log(chalk.yellow(`\n⚠️  O relatório do avaliador tem ${report.superseded.length + 1} vereditos (append-only).`));
-          console.log(chalk.gray(`   Vigente: ${report.verdict}, ${report.blockers.length} bloqueador(es). Superados: ${report.superseded.join(', ')}\n`));
+        for (const role of required) {
+          const r = reports[role];
+          if (r.status === 'ok' && r.superseded.length > 0) {
+            console.log(chalk.yellow(`\n⚠️  ${reviewFileName(role)} tem ${r.superseded.length + 1} vereditos (append-only).`));
+            console.log(chalk.gray(`   Vigente: ${r.verdict}, ${r.blockers.length} bloqueador(es). Superados: ${r.superseded.join(', ')}\n`));
+          }
         }
       }
     }
@@ -382,23 +260,19 @@ export async function approveCommand(featureName, gateName, options = {}) {
       ...(selfAssessed ? { selfAssessed: true } : {}),
     });
 
-    // Fleet handoff (mirrors advance.js): approving a gate is exactly when a
-    // feature hands over between sessions too — `approve` is the real path
-    // Gate 2 took in the field (`approve <f> plan --mode auto`), not just
-    // `advance`, so a handoff.md left stale after approve was the common
-    // case, not the edge case. Same helper, same fail-open contract: a
-    // regeneration failure must never fail the approval itself.
+    // Approving is a session handoff too; a regeneration failure must never fail the approval.
     try {
       const { writeHandoff } = await import('../../lib/generators/handoff-generator.js');
       writeHandoff(featureName, process.cwd());
     } catch { /* fail-open */ }
 
     if (selfAssessed) {
-      console.log(chalk.yellow('\n⚠️  Gate 3 aprovado SEM avaliador independente (--self-assessed).'));
+      console.log(chalk.yellow('\n⚠️  Gate 3 aprovado SEM os relatórios de review independentes (--self-assessed).'));
       console.log(chalk.gray('   Registrado em feature.json → approvalGates.review.selfAssessed.'));
     }
 
     console.log(chalk.green(`\n✅ Gate "${gateName}" approved for feature: ${featureName}`));
+    if (gateName === 'plan') reportDotnetIgnores(seedDotnetBuildIgnores(process.cwd(), { featureName }));
     console.log(chalk.gray(`Workflow can now proceed past ${gateName} phase\n`));
 
   } catch (error) {
@@ -407,28 +281,20 @@ export async function approveCommand(featureName, gateName, options = {}) {
   }
 }
 
-/**
- * Approve command - Mark a gate as approved
- */
 program
   .command('approve <feature> <gate>')
   .description('Approve a phase gate to allow workflow progression')
   .action(approveCommand);
 
-/**
- * Approval status action function - Show all gates and their status
- */
 export async function approvalStatusCommand(featureName, options = {}) {
   try {
-    // Get feature state
     const feature = getFeature(featureName);
     if (!feature) {
       console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
       process.exit(1);
     }
 
-    // v5 removed the stored feature.phase — derive it from the filesystem +
-    // approved gates (same as `morph-spec status`), never print "unknown".
+    // Phase derived from the filesystem + approved gates, never "unknown".
     const featurePath = join(process.cwd(), '.morph', 'features', featureName);
     const phase = feature.phase || derivePhase(featurePath);
 
@@ -437,7 +303,6 @@ export async function approvalStatusCommand(featureName, options = {}) {
     const uiuxGate = getApprovalGate(featureName, 'uiux');
     const uiuxTaken = uiuxGate?.approved === true || existsSync(join(featurePath, '1-design'));
 
-    // JSON output
     if (options.json) {
       const status = {
         feature: featureName,
@@ -458,11 +323,9 @@ export async function approvalStatusCommand(featureName, options = {}) {
     console.log(chalk.bold(`\n📋 Approval Status for: ${featureName}`));
     console.log('━'.repeat(60));
 
-    // Show current phase
     console.log(chalk.cyan(`\nCurrent Phase: ${phase}`));
     console.log(chalk.gray(`Feature Status: ${feature.status || 'unknown'}\n`));
 
-    // Show each gate
     console.log(chalk.bold('Approval Gates:'));
 
     for (const gateName of VALID_GATES) {
@@ -504,7 +367,6 @@ export async function approvalStatusCommand(featureName, options = {}) {
       }
     }
 
-    // Show approval history if available
     const history = getApprovalHistory(featureName);
     if (history && history.length > 0) {
       console.log(chalk.bold('\nApproval History:'));
@@ -522,16 +384,12 @@ export async function approvalStatusCommand(featureName, options = {}) {
   }
 }
 
-/**
- * Approval status command - Show all gates and their status
- */
 program
   .command('approval-status <feature>')
   .alias('status')
   .description('Show approval status for all gates')
   .action(approvalStatusCommand);
 
-// Only parse if run directly (not imported as module)
 if (import.meta.url === `file://${process.argv[1]}`) {
   if (process.argv.length > 2) {
     program.parse(process.argv);