@polymorphism-tech/morph-spec 9.7.0 → 10.0.0

package/src/commands/project/update.js

@@ -1,7 +1,7 @@
 import { join, dirname, relative, isAbsolute } from 'path';
 import { fileURLToPath } from 'url';
 import { spawnSync } from 'child_process';
-import { existsSync, readdirSync } from 'fs';
+import { existsSync, readdirSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -27,9 +27,10 @@ import {
 } from '../../utils/version-checker.js';
 import { installClaudeHooks, installGlobalStatusline } from '../../utils/claude-settings-manager.js';
 import { installSkills } from '../../utils/skills-installer.js';
-import { installAgents, installDomainAgents } from '../../utils/agents-installer.js';
+import { installAgents } from '../../utils/agents-installer.js';
 import { injectMorphImport } from '../../utils/claude-md-injector.js';
 import { getProjectTags } from '../../lib/stack-filter.js';
+import { detectStackTags, mergeDetectedTags } from '../../lib/installers/stack-sync.js';
 import { updateClaudeMdAgentsBlock, installRulesForStack, installCommandsForStack } from '../../scripts/setup-infra.js';
 import { reconcileLegacyTemplatesCopy } from '../../lib/installers/templates-reconcile.js';
 import { createEffects } from '../../lib/installers/effects.js';
@@ -145,6 +146,26 @@ export function stateJsonIsTracked(targetPath) {
   }
 }
 
+const SLICES_HEADING = /^## Fatias\s*$/m;
+
+/** Active features still planned in 9.x slices: a plan with `## Fatias` and no `3-implement/report.md` yet. */
+export function legacySliceFeatures(targetPath) {
+  const featuresDir = join(targetPath, '.morph', 'features');
+  let names;
+  try { names = readdirSync(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name); } catch { return []; }
+  return names.filter((name) => {
+    const dir = join(featuresDir, name);
+    if (existsSync(join(dir, '3-implement', 'report.md'))) return false;
+    try { return SLICES_HEADING.test(readFileSync(join(dir, '2-plan', 'plan.md'), 'utf8')); } catch { return false; }
+  }).sort();
+}
+
+export function legacySliceNotice(names) {
+  if (names.length === 0) return null;
+  return `Feature(s) planejada(s) em fatias (9.x): ${names.join(', ')}. Plano não aprovado: tire \`## Fatias\` e rode \`morph-spec plan-check <f>\`. `
+    + 'Já em implement: segue pelos `reports/F*.md`; para o formato novo, crie `3-implement/report.md` com uma linha por `Cn` (CHANGELOG 10.0.0).';
+}
+
 export function untrackCommittedStateJson(targetPath, fx = createEffects({ dryRun: false })) {
   if (!stateJsonIsTracked(targetPath)) return false;
   return fx.gitIndex('rm --cached --quiet', '.morph/state.json', { cwd: targetPath });
@@ -487,6 +508,19 @@ export async function updateCommand(options = {}) {
     try {
       if (configBackup) projectTags = getProjectTags(configBackup);
     } catch {}
+    // The same detection as `syncStackRules`, folded in before the installs: `restoreUserConfig`
+    // writes `configBackup`, and a dry run sees `.claude/rules/` before the clean, not after.
+    if (configBackup) {
+      try {
+        const detected = detectStackTags(targetPath, { config: configBackup });
+        const merged = mergeDetectedTags(configBackup, detected.persist);
+        if (merged.changed) {
+          configBackup.project = merged.config.project;
+          logger.dim(`  ✓ config.json: + ${merged.added.join(', ')} (detectado nos arquivos)`);
+        }
+        projectTags = [...new Set([...getProjectTags(configBackup), ...detected.tags])];
+      } catch {}
+    }
 
     let commandsCopied = false;
     const commandsSrc = join(frameworkDir, 'commands');
@@ -504,7 +538,6 @@ export async function updateCommand(options = {}) {
 
     updateSpinner.text = 'Syncing agents to .claude/agents/...';
     const agentsResult = await installAgents(targetPath, frameworkDir, { projectTags, fx });
-    await installDomainAgents(targetPath, frameworkDir, { projectTags, fx });
 
     updateSpinner.text = 'Syncing rules to .claude/rules/...';
     const rulesSrc = join(frameworkDir, 'rules');
@@ -566,6 +599,9 @@ export async function updateCommand(options = {}) {
       }
     }
 
+    const sliceNotice = legacySliceNotice(legacySliceFeatures(targetPath));
+    if (sliceNotice) notices.push(sliceNotice);
+
     const untracked = untrackCommittedStateJson(targetPath, fx);
 
     updateSpinner.text = 'Saving version info...';

package/src/commands/project/worktree.js

@@ -85,8 +85,27 @@ function getDateSuffix() {
   return new Date().toISOString().slice(0, 10).replace(/-/g, '');
 }
 
-// The ONLY links `finish` may auto-remove (never widened to any reparse point found), plus
-// `{project.frontendPath}/node_modules`: a monorepo frontend has its own install.
+function trackedPackageNodeModules(mainCwd) {
+  let out;
+  try {
+    out = execFileSync('git', ['ls-files', '-z', '--', '*package.json'], { cwd: mainCwd, stdio: 'pipe' }).toString();
+  } catch {
+    return [];
+  }
+  const dirs = [];
+  for (const file of out.split('\0')) {
+    const parts = file.split('/');
+    if (parts.length < 2 || parts.at(-1) !== 'package.json') continue;
+    const dirParts = parts.slice(0, -1);
+    if (dirParts.includes('node_modules') || WORKTREE_DIR_NAMES.includes(dirParts[0])) continue;
+    const rel = join(...dirParts, 'node_modules');
+    if (existsSync(join(mainCwd, rel))) dirs.push(rel);
+  }
+  return dirs;
+}
+
+// The ONLY links `finish` may auto-remove (never widened to any reparse point found), plus the
+// `node_modules` of each tracked nested package: a monorepo package has its own install.
 function resolveInfraLinkDirs(mainCwd) {
   const dirs = ['node_modules', '.claude'];
   if (existsSync(join(mainCwd, '.morph', 'framework'))) {
@@ -100,6 +119,9 @@ function resolveInfraLinkDirs(mainCwd) {
       if (frontendPath) dirs.push(join(frontendPath, 'node_modules'));
     }
   } catch {}
+  for (const rel of trackedPackageNodeModules(mainCwd)) {
+    if (!dirs.includes(rel)) dirs.push(rel);
+  }
   return dirs;
 }
 
@@ -298,15 +320,6 @@ export async function runWorktreeSetup(feature, options = {}) {
 
     const graph = seedWorktreeGraph(worktreePath, cwd);
 
-    // Fail-open; a no-op under `create --worktree`, which regenerates it after its copy.
-    try {
-      if (existsSync(join(worktreePath, '.morph', 'features', feature, 'feature.json'))) {
-        const { writeHandoff } = await import('../../lib/generators/handoff-generator.js');
-        // `worktree` is root-owned and absent from this branch copy: pass it so the doc says "Local: worktree".
-        writeHandoff(feature, worktreePath, { worktree: { path: worktreePath, branch } });
-      }
-    } catch {}
-
     try {
       const { loadState, saveState } = await import('../../core/state/state-manager.js');
       const state = loadState(false);
@@ -812,9 +825,9 @@ export function pickRemovalFailure(stderrs) {
 
 /**
  * PROVE-or-DECLINE. `refused` (proved unsafe) restores the junctions; a git FAILURE leaves them down
- * (`infraLeftUnlinked`) unless `relinkOnFailure` (the reaper, whose agent may still be live).
+ * (`infraLeftUnlinked`).
  */
-export async function teardownWorktree(worktreePath, { root, feature, branch, options = {}, deleteBranch = true, addressByTarget = false, relinkOnFailure = false, stamp }) {
+export async function teardownWorktree(worktreePath, { root, feature, branch, options = {}, deleteBranch = true, addressByTarget = false, stamp }) {
   // ORDER IS LOAD-BEARING: unlink the junctions BEFORE git touches the dir. `git worktree remove`
   // follows them and deletes the root's installation; a declined path is repaired by the rollback below.
   const unlinked = unlinkWorktreeInfraLinks(worktreePath, root);
@@ -859,8 +872,7 @@ export async function teardownWorktree(worktreePath, { root, feature, branch, op
   // would make the next retry (or a raw `--force`) follow the junctions out.
   const refused = !canRemove;
   let relinked = false;
-  const relinkAfterFailure = relinkOnFailure && !refused && !worktreeRemoved && !removalFailure?.alreadyDeregistered;
-  if ((refused || relinkAfterFailure) && unlinked.length && existsSync(worktreePath)) {
+  if (refused && unlinked.length && existsSync(worktreePath)) {
     try {
       setupInfraLinks(worktreePath, root);
       relinked = true;
@@ -1033,7 +1045,6 @@ export async function runWorktreeRemove(featureArg, options = {}) {
     options: { discardIgnored: options.discardIgnored === true },
     // The branch is the work: deleting it would discard unintegrated commits. Opt-in only.
     deleteBranch: options.deleteBranch === true,
-    relinkOnFailure: options.relinkOnFailure === true,
     // Re-run advice must address the worktree the way it was addressable here:
     // a `--target` worktree has no feature name that would resolve.
     addressByTarget: !featureAddressable,

package/src/commands/state/advance.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { existsSync, mkdirSync, readFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { join, relative } from 'path';
 import { fileURLToPath } from 'url';
 import { getFeature, setApprovalGate, derivePhase } from '../../core/state/state-manager.js';
@@ -8,7 +8,7 @@ import { OUTPUT_SCHEMA } from '../../core/paths/output-schema.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
 import { uiuxAutoApprovalBlock } from '../../lib/specs/screen-checklist.js';
 import { seedDesignArtifacts } from '../../lib/specs/design-seed.js';
-import { sliceProgress } from '../../../framework/hooks/shared/slice-progress.js';
+import { implementProgress, reportPath, reportSkeleton } from '../../../framework/hooks/shared/report-progress.js';
 import { autoApprovalRefusal, printRefusal } from './auto-approval.js';
 import { seedDotnetBuildIgnores } from '../../lib/stack/dotnet-build-ignores.js';
 
@@ -38,17 +38,25 @@ function missingPhaseArtifacts(phase, featurePath) {
       const rel = `${entry.phaseDir}/${entry.filename}`;
       if (!existsSync(join(featurePath, entry.phaseDir, entry.filename))) missing.push(rel);
     }
-    if (phase === 'implement') missing.push(...unfinishedSliceReports(featurePath));
+    if (phase === 'implement') missing.push(...unfinishedScenarios(featurePath));
     return missing;
   } catch {
     return [];
   }
 }
 
-function unfinishedSliceReports(featurePath) {
-  const progress = sliceProgress(featurePath);
+function unfinishedScenarios(featurePath) {
+  const progress = implementProgress(featurePath);
   if (!progress) return ['2-plan/checks.json'];
-  return progress.slices.filter((s) => s.status !== 'feito').map((s) => `3-implement/reports/${s.id}.md`);
+  const open = progress.checks.filter((c) => c.status !== 'feito').map((c) => c.id);
+  return open.length ? [`3-implement/report.md (${open.join(', ')} não feito)`] : [];
+}
+
+function seedReport(featurePath, featureName) {
+  const path = reportPath(featurePath);
+  if (existsSync(path)) return;
+  const progress = implementProgress(featurePath);
+  if (progress) writeFileSync(path, reportSkeleton(featureName, progress.checks.map((c) => c.id)));
 }
 
 // Message-only and fail-open: names the worktree that holds the artifacts instead of demanding
@@ -114,10 +122,6 @@ export async function advanceCommand(featureName, options = {}) {
       mkdirSync(join(featurePath, '1-design'), { recursive: true });
       reportDesignSeed(seedDesignArtifacts(featureName, process.cwd()));
       reportDotnetIgnores(seedDotnetBuildIgnores(process.cwd(), { featureName }));
-      try {
-        const { writeHandoff } = await import('../../lib/generators/handoff-generator.js');
-        writeHandoff(featureName, process.cwd());
-      } catch { /* fail-open */ }
       console.log(chalk.green(`\n✅ "${featureName}": gate plan já aprovado — ramo de design aberto (1-design/).\n`));
       return;
     }
@@ -129,7 +133,7 @@ export async function advanceCommand(featureName, options = {}) {
       return;
     }
 
-    // `implement` has no gate, so this is what keeps unfinished slice reports out of review.
+    // `implement` has no gate, so this is what keeps unfinished scenarios out of review.
     // `--force` bypasses it but still names what was skipped.
     const missingArtifacts = missingPhaseArtifacts(phase, featurePath);
     if (missingArtifacts.length && !options.force) {
@@ -166,7 +170,7 @@ export async function advanceCommand(featureName, options = {}) {
     }
 
     // `setApprovalGate` replaces the gate whole: rewriting an approved gate would turn a human
-    // signature into "auto". Skips ONLY the write, so the scaffold and handoff below still run.
+    // signature into "auto". Skips ONLY the write, so the scaffold below still runs.
     const priorGate = gate ? feature.approvalGates?.[gate] : null;
     const alreadyApproved = priorGate?.approved === true;
 
@@ -193,13 +197,9 @@ export async function advanceCommand(featureName, options = {}) {
       if (!existsSync(nextPath)) mkdirSync(nextPath, { recursive: true });
     }
     if (nextDir === '1-design') reportDesignSeed(seedDesignArtifacts(featureName, process.cwd()));
+    if (nextDir === '3-implement') seedReport(featurePath, featureName);
     if (phase === 'plan') reportDotnetIgnores(seedDotnetBuildIgnores(process.cwd(), { featureName }));
 
-    // A phase transition is when a session hands the feature over: refresh handoff.md.
-    try {
-      const { writeHandoff } = await import('../../lib/generators/handoff-generator.js');
-      writeHandoff(featureName, process.cwd());
-    } catch { /* fail-open */ }
 
     console.log(chalk.green(`\n✅ Advanced "${featureName}" past the ${phase} phase.`));
     if (missingArtifacts.length) {

package/src/commands/state/approve.js

@@ -260,12 +260,6 @@ export async function approveCommand(featureName, gateName, options = {}) {
       ...(selfAssessed ? { selfAssessed: true } : {}),
     });
 
-    // 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 os relatórios de review independentes (--self-assessed).'));
       console.log(chalk.gray('   Registrado em feature.json → approvalGates.review.selfAssessed.'));

package/src/commands/state/archive.js

@@ -1,9 +1,10 @@
 import chalk from 'chalk';
-import { existsSync, renameSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, renameSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'fs';
 import { join, resolve, sep } from 'path';
 import { execFileSync } from 'child_process';
 import { ADR_INDEX_PATHSPEC, updateAdrIndex } from '../../lib/specs/adr-index.js';
 import { isValidFeatureName } from '../project/worktree.js';
+import { RECAP_FILES, writeRecap } from './recap.js';
 
 function assertContained(scopeDir, name, target) {
   const scopeAbs = resolve(scopeDir) + sep;
@@ -38,6 +39,17 @@ function readReviewApproved(fjPath) {
  * Never calls process.exit, and resolves everything from `cwd` so `finish` can archive inside a
  * worktree. Idempotent: an existing archive returns `{ ok: true, alreadyArchived: true }`.
  */
+// plan.md stays: a squash merge drops every file born and pruned inside the branch.
+function pruneArchive(dir) {
+  for (const entry of readdirSync(dir)) {
+    if (entry === 'feature.json' || Object.values(RECAP_FILES).includes(entry)) continue;
+    if (entry !== '2-plan') { rmSync(join(dir, entry), { recursive: true, force: true }); continue; }
+    for (const planEntry of readdirSync(join(dir, entry))) {
+      if (planEntry !== 'plan.md') rmSync(join(dir, entry, planEntry), { recursive: true, force: true });
+    }
+  }
+}
+
 export function runArchive(feature, opts = {}) {
   const cwd = opts.cwd || process.cwd();
 
@@ -71,6 +83,10 @@ export function runArchive(feature, opts = {}) {
   }
 
   const useGit = opts.git !== false && isGitRepo(cwd);
+  let archivedFromSha = null;
+  if (useGit) {
+    try { archivedFromSha = execFileSync('git', ['rev-parse', 'HEAD'], { cwd, stdio: 'pipe' }).toString().trim(); } catch { /* no commit yet */ }
+  }
 
   // `git mv` keeps history and stages in one step; an untracked folder falls back to rename.
   mkdirSync(archiveDir, { recursive: true });
@@ -96,6 +112,7 @@ export function runArchive(feature, opts = {}) {
       const fj = JSON.parse(readFileSync(fjPathAfter, 'utf8'));
       fj.status = 'completed';
       fj.archivedAt = new Date().toISOString();
+      if (archivedFromSha) fj.archivedFrom = { sha: archivedFromSha };
       fj.updatedAt = fj.archivedAt;
       writeFileSync(fjPathAfter, JSON.stringify(fj, null, 2), 'utf8');
       if (useGit && staged) {
@@ -113,6 +130,13 @@ export function runArchive(feature, opts = {}) {
     try { execFileSync('git', ['add', '-A', '--', ADR_INDEX_PATHSPEC], { cwd, stdio: 'pipe' }); } catch { /* non-fatal */ }
   }
 
+  // Before the prune: the recap reads the Gate 3 reports the archive does not keep.
+  const recap = opts.recap === false ? null : writeRecap(archivePath, archivePath, feature, { cwd });
+  pruneArchive(archivePath);
+  if (useGit && staged) {
+    try { execFileSync('git', ['add', '-A', '--', archivePathspec], { cwd, stdio: 'pipe' }); } catch { /* non-fatal */ }
+  }
+
   // Scoped to this feature's pathspec, never `commit -a`. The ADR index joins only when it
   // changed: git refuses a pathspec that matches nothing, leaving the tree dirty for the merge.
   let committed = false;
@@ -144,6 +168,7 @@ export function runArchive(feature, opts = {}) {
 
   return {
     ok: true, archived: true, committed, staged, archivePath,
+    recap: recap?.ok ? recap.path : null,
     revocationProblems: adrIndex.problems,
     adrIndex: adrIndex.changed ? { added: adrIndex.added, revoked: adrIndex.revoked, narrowed: adrIndex.narrowed } : null,
   };
@@ -180,6 +205,7 @@ export async function archiveCommand(featureName, options = {}) {
 
     console.log(chalk.green(`\n📦 Archived "${featureName}" → .morph/archive/${featureName}/`));
     console.log(chalk.gray(`   status: completed, archivedAt stamped in feature.json.`));
+    if (result.recap) console.log(chalk.gray(`   recap: ${result.recap} (morph-spec recap ${featureName} --piper narra com o Piper)`));
     if (result.adrIndex) {
       const { added, revoked, narrowed } = result.adrIndex;
       console.log(chalk.gray(`   ADR index (.morph/specs/adrs/): +${added.length} −${revoked.length} ~${narrowed.length}.`));

package/src/commands/state/auto-approval.js

@@ -34,7 +34,7 @@ export function autoApprovalRefusal({ cwd, featureName, feature, gate, approvedB
     if (block) {
       return {
         title: `O gate "plan" não pode ser auto-aprovado — ${block}.`,
-        hints: ['Com plan-check verde, rode de novo; ou aprove com --approver <nome>. O --force não dispensa o checks.json.'],
+        hints: ['Sem checks.json fresco: plan-check verde e rode de novo. Com degrau: aprove com --approver <nome> ou pela resposta humana. O --force não dispensa nenhum dos dois.'],
       };
     }
   }

package/src/commands/state/create.js

@@ -185,11 +185,6 @@ export async function createCommand(featureName, options = {}) {
             // Re-materialize after the copy: the setup's earlier materialize ran with no features yet.
             const remat = await materializeState(worktreeResult.path);
             worktreeResult.materialized = remat.materialized;
-            try {
-              const { writeHandoff } = await import('../../lib/generators/handoff-generator.js');
-              // `worktree` was stripped from this copy above, so pass where it actually lives.
-              writeHandoff(featureName, worktreeResult.path, { worktree: { path: worktreeResult.path, branch: worktreeResult.branch } });
-            } catch { /* fail-open */ }
           } catch { /* fail-open — the feature already exists in root */ }
         }
       } else {

package/src/commands/state/finish.js

@@ -292,7 +292,8 @@ export async function finishCommand(feature, options = {}) {
   }
   const dirtLines = withoutLeftoverIgnore(cleanCwd, dirty.split(/\r?\n/).filter((l) => l.trim()));
   const testArtifacts = untrackedTestArtifacts(dirtLines);
-  if (dirtLines.length > testArtifacts.length) {
+  const commitState = dirtLines.length > testArtifacts.length && onlyFeatureStateDirty(cleanCwd, feature);
+  if (dirtLines.length > testArtifacts.length && !commitState) {
     emit({ finished: false, error: isWorktreeFlow ? 'worktree-dirty' : 'working-dir-dirty', hint: 'commit seu trabalho na branch antes do finish', feature });
     process.exit(1);
   }
@@ -341,6 +342,10 @@ export async function finishCommand(feature, options = {}) {
 
   // Every refusal is behind us: the leftover of a killed `graph refresh` goes now, never before.
   dropLeftoverIgnore(cleanCwd);
+  if (commitState && !commitFeatureState(cleanCwd, feature)) {
+    emit({ finished: false, error: 'state-commit-failed', hint: `não foi possível commitar .morph/features/${feature} (identidade git ausente?) — commite o estado na branch e rode o finish de novo`, feature });
+    process.exit(1);
+  }
   if (isWorktreeFlow) {
     for (const p of testArtifacts) rmSync(join(cleanCwd, p), { recursive: true, force: true });
   }
@@ -409,6 +414,15 @@ export function finishPreflight({ feature, root, worktreePath, cwd, mode, branch
 
   if (defaultBranch) out.defaultBranch = defaultBranch;
 
+  try {
+    const tree = worktreePath || root;
+    const dirt = gitStatusPorcelain(tree);
+    const work = dirt === null ? [] : withoutLeftoverIgnore(tree, dirt.split(/\r?\n/).filter((l) => l.trim()));
+    if (work.length > untrackedTestArtifacts(work).length && onlyFeatureStateDirty(tree, feature)) {
+      out.wouldDo.unshift(`commitar o estado sujo de .morph/features/${feature} (${stateCommitMessage(feature)}) na branch ${branch}`);
+    }
+  } catch { /* o pré-voo nunca lança */ }
+
   // A retenção automática também é mutação do finish real; a contagem é a de AGORA, antes do
   // backup que este finish gravar.
   try {
@@ -808,6 +822,34 @@ function untrackedTestArtifacts(lines) {
     .filter((p) => isTestArtifact(p));
 }
 
+const stateCommitMessage = (feature) => `chore(morph): estado da feature ${feature}`;
+
+// `--untracked-files=all`: o porcelain padrão colapsa `?? .morph/` e esconderia sujeira fora do escopo.
+function onlyFeatureStateDirty(cwd, feature) {
+  let out;
+  try {
+    out = execFileSync('git', ['status', '--porcelain', '--untracked-files=all'], { cwd, stdio: 'pipe' }).toString();
+  } catch {
+    return false;
+  }
+  const scope = `.morph/features/${feature}/`;
+  const paths = out.split(/\r?\n/).filter((l) => l.trim())
+    .flatMap((l) => l.slice(3).split(' -> '))
+    .map((p) => p.replace(/^"|"$/g, ''));
+  return paths.length > 0 && paths.every((p) => p.startsWith(scope));
+}
+
+function commitFeatureState(cwd, feature) {
+  const scope = `.morph/features/${feature}`;
+  try {
+    execFileSync('git', ['add', '-A', '--', scope], { cwd, stdio: 'pipe' });
+    execFileSync('git', ['commit', '-q', '-m', stateCommitMessage(feature), '--', scope], { cwd, stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function gitStatusPorcelain(cwd) {
   try {
     return execFileSync('git', ['status', '--porcelain'], { cwd, stdio: 'pipe' }).toString();

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

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { getFeature } from '../../core/state/state-manager.js';
-import { shouldPauseGate, getRiskSignals, classifyE2eSkip, planChecksPause, securityReviewFor } from '../../lib/risk-detector.js';
+import { shouldPauseGate, getRiskSignals, classifyE2eSkip, planChecksPause, securityReviewFor, pausingRungs, migrationsTouched, contractsTouched, humanApprover, rungPause, planCritiquePause } from '../../lib/risk-detector.js';
+import { readPlanCritique } from '../../lib/plan/critique.js';
 import { reviewReports, reviewSignal, requiredReviewRoles, verifierMediaSection } from '../../lib/review-reports.js';
 import { collectScreenChecklist } from '../../lib/specs/screen-checklist.js';
 import { persistGateDecision, VALID_GATES, readTrustFromConfig } from './gate-decision.js';
@@ -9,33 +10,22 @@ import { detectDefaultBranch, getHeadSha, getDiffStat, changedPathsAgainst } fro
 import { treeMovedSince } from '../../lib/git/evidence-staleness.js';
 import { readMorphConfig } from '../../lib/tasks/test-runner.js';
 import { readPlanChecks } from '../../lib/plan/checks.js';
+import { featureGeneratesMedia } from '../../lib/plan/media.js';
+import { readFileSync, existsSync } from 'fs';
+import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
 
+export { featureGeneratesMedia, MEDIA_STANDARD_IDS, standardIdOf } from '../../lib/plan/media.js';
+
 // Only signals NOT derivable from disk may be overridden: overriding a disk fact (e.g. `workType`
 // away from hotfix) would silently defeat the policy this command makes deterministic.
 const OVERRIDABLE_SIGNAL_KEYS = ['standardsViolations', 'designSystemDivergence'];
 
-export const MEDIA_STANDARD_IDS = [
-  'ai-agents-modalities-image-gen',
-  'ai-agents-media-video',
-  'ai-agents-media-pipeline',
-];
-
-// O plano escreve o standard pelo id ou pelo caminho (com ou sem `framework/`/`standards/`).
-export function standardIdOf(value) {
-  return String(value ?? '').trim().replace(/\\/g, '/')
-    .replace(/^(\.morph\/)?(framework\/)?(standards\/)?/, '')
-    .replace(/\.md$/, '')
-    .replace(/\//g, '-');
+function readPlanText(cwd, featureName) {
+  const path = getAbsoluteOutputPath(cwd, featureName, 'plan');
+  try { return existsSync(path) ? readFileSync(path, 'utf8') : ''; } catch { return ''; }
 }
 
-// Decide se um guardrail arma: um predicado que sempre devolve `false` desarma em silêncio a
-// pausa de mídia da review e a rota opus.
-export function featureGeneratesMedia(slices) {
-  if (!Array.isArray(slices)) return false;
-  return slices.some((s) => Array.isArray(s?.standards)
-    && s.standards.some((id) => MEDIA_STANDARD_IDS.includes(standardIdOf(id))));
-}
 
 // `declared: false` (nenhum caminho declarado: regra inerte) e `touched: []` (declarou, nada
 // tocado) não podem colapsar num array vazio. COLETA, NUNCA DECIDE: política no coletor cria
@@ -70,7 +60,11 @@ export function collectReviewSignal(cwd, featureName, feature, planChecks = read
 
 /** Why an automatic signature may not close the plan gate: the rule that makes gate-check pause it. */
 export function planAutoApprovalBlock(cwd, featureName) {
-  const reason = planChecksPause(readPlanChecks(cwd, featureName).status);
+  const planChecks = readPlanChecks(cwd, featureName);
+  const workType = getFeature(featureName)?.workType || 'feature';
+  const reason = planChecksPause(planChecks.status)
+    ?? planCritiquePause(readPlanCritique(cwd, featureName, { workType, planChecks }))
+    ?? rungPause({ gate: 'plan', rungs: pausingRungs(planChecks.checks) })?.reason;
   return reason ? reason.replace('{feature}', featureName) : null;
 }
 
@@ -79,7 +73,6 @@ export function planAutoApprovalBlock(cwd, featureName) {
 // waiver from missing proof.
 export function collectSignals(featureName, feature, cwd, gateName) {
   const planChecks = readPlanChecks(cwd, featureName);
-  const slices = planChecks.checks?.slices ?? null;
   const defaultBranch = detectDefaultBranch(cwd);
   const sha = getHeadSha(cwd);
   const verification = feature.verification || null;
@@ -88,12 +81,15 @@ export function collectSignals(featureName, feature, cwd, gateName) {
     // Disk-derived, never overridable: a caller cannot spoof which gate is being decided.
     gate: gateName,
     workType: feature.workType || 'feature',
-    sliceCount: slices ? slices.length : null,
     standardsViolations: [],
     designSystemDivergence: false,
   };
 
-  if (gateName === 'plan') signals.planChecks = planChecks.status;
+  if (gateName === 'plan') {
+    signals.planChecks = planChecks.status;
+    signals.planCritique = readPlanCritique(cwd, featureName, { workType: signals.workType, planChecks });
+  }
+  if (gateName === 'plan' || gateName === 'review') signals.rungs = pausingRungs(planChecks.checks);
 
   // Só onde o checklist decide algo: no fecho do design e no ship.
   if (gateName === 'uiux' || gateName === 'review') {
@@ -104,13 +100,20 @@ export function collectSignals(featureName, feature, cwd, gateName) {
     signals.reviewReports = collectReviewSignal(cwd, featureName, feature, planChecks);
     signals.mediaClaims = {
       section: verifierMediaSection(cwd, featureName),
-      featureGeneratesMedia: featureGeneratesMedia(slices),
+      featureGeneratesMedia: featureGeneratesMedia(readPlanText(cwd, featureName)),
     };
+    let changed = [];
+    try { changed = changedPathsAgainst(defaultBranch, cwd); } catch { changed = []; }
+    signals.migrationsTouched = migrationsTouched(changed);
+    signals.contractsTouched = contractsTouched(changed);
+    signals.planApprovedByHuman = feature.approvalGates?.plan?.approved === true
+      && humanApprover(feature.approvalGates.plan.approvedBy);
   }
 
   // verificationStale é fail-open: stamp sem sha (checkout sem git) ou ausente lê como NOT stale.
   signals.verification = verification;
   if (verification?.status) signals.verificationStatus = verification.status;
+  signals.failStreak = feature.verifications?.feature?.failStreak ?? 0;
   signals.verificationStale = treeMovedSince(cwd, verification?.sha, sha);
 
   // Separado do rollup: um `skip` NÃO reprova `verification.status`. `null` é DESCONHECIDO, nunca
@@ -189,10 +192,12 @@ export async function gateCheckCommand(featureName, gateName, options = {}) {
     const computed = shouldPauseGate({ trust }, signals);
     const manual = feature.gateDecisions?.[gateName];
     const manualPause = manual?.source === 'manual' && manual.pause === true;
-    const { pause, reason, signal } = manualPause ? { pause: true, reason: manual.reason, signal: 'manual' } : computed;
+    const { pause, reason, signal, resolver } = manualPause
+      ? { pause: true, reason: manual.reason, signal: 'manual', resolver: 'human' }
+      : computed;
 
     const entry = await persistGateDecision(featureName, gateName, {
-      pause, reason, signal, signals, trust, cwd, source: manualPause ? 'manual' : 'gate-check',
+      pause, reason, signal, resolver, signals, trust, cwd, source: manualPause ? 'manual' : 'gate-check',
     });
 
     if (options.json) {
@@ -201,9 +206,11 @@ export async function gateCheckCommand(featureName, gateName, options = {}) {
     }
 
     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(!entry.pause
+      ? chalk.green(`\n▶️  Gate "${gateName}" — auto-pass (${featureName})`)
+      : entry.resolver === 'session'
+        ? chalk.yellow(`\n🔧 Gate "${gateName}" — PAUSE, resolver: session (${featureName}): do what the reason says and run gate-check again`)
+        : chalk.yellow(`\n⏸️  Gate "${gateName}" — PAUSE, resolver: human (${featureName})`));
     console.log(chalk.gray(`   reason: ${entry.reason} | trust: ${entry.trust} | decidedAt: ${entry.decidedAt}`));
     if (manualPause) {
       console.log(chalk.gray(`   pausa manual mantida (sinais calculados: ${computed.reason}); só \`morph-spec gate-decision ${featureName} ${gateName} --pause false\` a libera`));

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

@@ -32,9 +32,10 @@ export function readTrustFromConfig() {
  * The ONE write path of `gateDecisions.{gate}`, shared by `gate-decision` and `gate-check`.
  * Does not validate `gateName`. A uiux decision records the `mockupsHash` it saw.
  */
-export async function persistGateDecision(featureName, gateName, { pause, reason, signal, signals = {}, trust, cwd = process.cwd(), source } = {}) {
+export async function persistGateDecision(featureName, gateName, { pause, reason, signal, resolver, signals = {}, trust, cwd = process.cwd(), source } = {}) {
   const entry = {
     pause,
+    resolver: pause ? resolver ?? 'human' : null,
     reason: reason || (pause ? 'risco detectado' : 'nenhum sinal de risco'),
     signals,
     trust: trust || readTrustFromConfig(),
@@ -44,7 +45,7 @@ export async function persistGateDecision(featureName, gateName, { pause, reason
   };
 
   await updateFeature(featureName, `gateDecisions.${gateName}`, entry);
-  recordGateEvent(cwd, { feature: featureName, gate: gateName, step: 'decision', pause, signal, source });
+  recordGateEvent(cwd, { feature: featureName, gate: gateName, step: 'decision', pause, signal, source, resolver: entry.resolver });
   return entry;
 }
 

package/src/commands/state/next.js

@@ -20,5 +20,6 @@ export function nextCommand(featureName, options = {}) {
     return;
   }
   console.log(formatNext(next));
+  for (const line of next.how ?? []) console.log(`   ${line}`);
   if (owner.tree !== process.cwd()) console.log(chalk.gray(`   árvore dona: ${owner.tree}`));
 }