@polymorphism-tech/morph-spec 10.7.1 → 10.8.0

package/src/commands/state/finish.js

@@ -11,6 +11,7 @@ import {
   buildBranchName,
   branchExists,
   cwdIsInsideWorktree,
+  worktreeHeldElsewhere,
   sessionAnchoredInWorktree,
   classifyIgnoredLeftovers,
 } from '../project/worktree.js';
@@ -51,6 +52,50 @@ export function buildPrTitle(feature, fj) {
   return prefix + (raw.length <= room ? raw : `${raw.slice(0, room - 1)}…`);
 }
 
+const ISSUE_URL_RE = /https?:\/\/github\.com\/([\w.-]+\/[\w.-]+)\/issues\/(\d+)/;
+const ISSUE_KEYWORD_RE = /\b(close[sd]?|fix(e[sd])?|resolve[sd]?|refs?)\s+([\w.-]+\/[\w.-]+)?#\d+/i;
+
+// The description's own keyword wins (`Refs #N` keeps the issue open); a bare issue link closes it.
+export function prBodyFor(feature, fj) {
+  const described = typeof fj?.description === 'string' ? fj.description.trim() : '';
+  const body = described || `Feature ${feature} — integrada via morph-spec finish --pr.`;
+  const issue = described.match(ISSUE_URL_RE);
+  if (!issue || ISSUE_KEYWORD_RE.test(described)) return body;
+  return `${body}\n\nCloses ${issue[1]}#${issue[2]}`;
+}
+
+// Regenerated from the tree: on a merge, the default's copy is as good as ours.
+const GENERATED_PATHS = new Set(['.morph/context/README.md']);
+
+/** Merges origin/<default> into the feature branch so the PR is never born CONFLICTING. */
+function joinDefault(tree, defaultBranch) {
+  const target = `origin/${defaultBranch}`;
+  try {
+    execFileSync('git', ['fetch', '-q', 'origin', defaultBranch], { cwd: tree, stdio: 'pipe' });
+  } catch (err) {
+    return { error: 'default-fetch-failed', output: gitErr(err) };
+  }
+  try {
+    execFileSync('git', ['merge-base', '--is-ancestor', target, 'HEAD'], { cwd: tree, stdio: 'pipe' });
+    return { merged: false };
+  } catch { /* behind the default: merge it */ }
+  try {
+    execFileSync('git', ['merge', '-q', '--no-edit', target], { cwd: tree, stdio: 'pipe' });
+    return { merged: true };
+  } catch (err) {
+    const conflicts = execFileSync('git', ['diff', '--name-only', '--diff-filter=U'], { cwd: tree, stdio: 'pipe' })
+      .toString().split(/\r?\n/).filter(Boolean);
+    if (conflicts.length > 0 && conflicts.every((p) => GENERATED_PATHS.has(p))) {
+      execFileSync('git', ['checkout', '--theirs', '--', ...conflicts], { cwd: tree, stdio: 'pipe' });
+      execFileSync('git', ['add', '--', ...conflicts], { cwd: tree, stdio: 'pipe' });
+      execFileSync('git', ['commit', '-q', '--no-edit'], { cwd: tree, stdio: 'pipe' });
+      return { merged: true, resolved: conflicts };
+    }
+    tryGit(['merge', '--abort'], tree);
+    return { error: 'default-conflict', conflicts, output: conflicts.length ? undefined : gitErr(err) };
+  }
+}
+
 const MEMORY_NOTE = 'o fechamento desta feature já está registrado no repositório (commit de archive, `plan.md` com as decisões, índice de ADRs, `git log`) — memória de sessão só para o que NENHUM deles guarda: decisão do usuário, pendência a observar em produção, custo medido.';
 
 // Every refusal is fail-CLOSED and happens BEFORE the archive, the first mutation. Resumable: a
@@ -167,6 +212,18 @@ export async function finishCommand(feature, options = {}) {
       });
       process.exit(1);
     }
+    // The session's own anchor defers the teardown instead; any other holder would orphan the folder.
+    if (!options.dryRun && !sessionAnchoredInWorktree(worktreePath) && worktreeHeldElsewhere(worktreePath)) {
+      emit({
+        finished: false,
+        error: 'worktree-in-use',
+        feature,
+        path: worktreePath,
+        root,
+        hint: `outro processo tem "${worktreePath}" como pasta de trabalho (um terminal, o editor, um servidor de dev): feche-o ou saia da pasta e rode o finish de novo. Nada foi mexido.`,
+      });
+      process.exit(1);
+    }
   } else {
     // A feature with no morph/{f} branch predates this flow: route it to archive-without-integrate.
     if (!branchExists(expectedBranch, root)) {
@@ -293,9 +350,7 @@ export async function finishCommand(feature, options = {}) {
     process.exit(1);
   }
   const prTitle = buildPrTitle(feature, fj);
-  const prBody = (fj?.description && String(fj.description).trim())
-    ? String(fj.description).trim()
-    : `Feature ${feature} — integrada via morph-spec finish --pr.`;
+  const prBody = prBodyFor(feature, fj);
 
   // Clean, so the scoped archive commit contains only the move.
   const cleanCwd = isWorktreeFlow ? worktreePath : root;
@@ -363,7 +418,23 @@ export async function finishCommand(feature, options = {}) {
   if (isWorktreeFlow) {
     for (const p of testArtifacts) rmSync(join(cleanCwd, p), { recursive: true, force: true });
   }
-  const arch =runArchive(feature, { cwd: featureCwd, force: options.force, git: true });
+  if (mode === 'pr') {
+    const joined = joinDefault(cleanCwd, defaultBranch);
+    if (joined.error) {
+      emit({
+        finished: false,
+        error: joined.error,
+        feature,
+        ...(joined.conflicts?.length ? { conflicts: joined.conflicts } : {}),
+        ...(joined.output ? { output: joined.output } : {}),
+        hint: joined.error === 'default-conflict'
+          ? `origin/${defaultBranch} conflita com ${expectedBranch} em ${joined.conflicts.join(', ') || '(ver output)'}; o merge foi desfeito e nada foi arquivado nem enviado. Rode \`git merge origin/${defaultBranch}\` em ${cleanCwd}, resolva, commite e rode o finish de novo`
+          : `não consegui buscar origin/${defaultBranch}; nada foi arquivado nem enviado. Confira a rede e o remoto e rode de novo`,
+      });
+      process.exit(1);
+    }
+  }
+  const arch = runArchive(feature, { cwd: featureCwd, force: options.force, git: true });
   if (!arch.ok) {
     emit({ finished: false, error: `archive-${arch.error}`, feature });
     process.exit(1);

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

@@ -3,6 +3,7 @@ import { getFeature } from '../../core/state/state-manager.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 { featureDiffRisk } from '../../lib/risk/diff-risk.js';
 import { collectScreenChecklist } from '../../lib/specs/screen-checklist.js';
 import { persistGateDecision, VALID_GATES, readTrustFromConfig } from './gate-decision.js';
 import { minimatch } from 'minimatch';
@@ -48,8 +49,12 @@ function collectPromptModel(cwd, defaultBranch) {
 export function collectReviewRequirement(cwd, feature) {
   let changed = [];
   try { changed = changedPathsAgainst(detectDefaultBranch(cwd), cwd); } catch { changed = []; }
-  const security = securityReviewFor(changed);
-  return { required: requiredReviewRoles({ workType: feature?.workType, securityRequired: security.required }), security };
+  const byPath = securityReviewFor(changed);
+  const risk = featureDiffRisk(cwd, detectDefaultBranch(cwd));
+  const reasons = [...new Set([...byPath.reasons, ...(risk?.security.reasons ?? [])])];
+  const security = { required: reasons.length > 0, reasons };
+  const required = requiredReviewRoles({ workType: feature?.workType, securityRequired: security.required, risk: risk?.level ?? null });
+  return { required, security, risk: risk ? { level: risk.level, reasons: risk.reasons } : null };
 }
 
 export function collectReviewSignal(cwd, featureName, feature, planChecks = readPlanChecks(cwd, featureName)) {

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

@@ -41,13 +41,19 @@ function reviewDispatch(cwd, feature) {
   const globs = Array.isArray(watch) ? watch.filter((g) => typeof g === 'string' && g.trim()) : [];
   let workType;
   try { workType = JSON.parse(readFileSync(join(cwd, '.morph', 'features', feature, 'feature.json'), 'utf8')).workType; } catch { workType = undefined; }
-  const { required, security } = collectReviewRequirement(cwd, { workType });
+  const { required, security, risk } = collectReviewRequirement(cwd, { workType });
+  // A confirmation re-judges a delta against scenarios already proven: never the expensive model.
+  const confirming = Object.values(reviewReports(cwd, feature)).some((r) => r.status !== 'missing');
   return {
     required,
-    verifier: verifierModelFor({
-      promptModelTouched: changedFiles.some((f) => globs.some((g) => minimatch(f, g))),
-      generatesMedia: featureGeneratesMedia(readOrEmpty(getAbsoluteOutputPath(cwd, feature, 'plan'))),
-    }),
+    risk,
+    selfReview: ['low', 'none'].includes(risk?.level) && workType !== 'hotfix',
+    verifier: confirming
+      ? { model: 'sonnet', reasons: ['confirmação de delta'] }
+      : verifierModelFor({
+        promptModelTouched: changedFiles.some((f) => globs.some((g) => minimatch(f, g))),
+        generatesMedia: featureGeneratesMedia(readOrEmpty(getAbsoluteOutputPath(cwd, feature, 'plan'))),
+      }),
     reviewer: { model: 'sonnet', reasons: [] },
     security: { required: security.required, model: 'opus', reasons: security.reasons },
   };
@@ -118,6 +124,22 @@ function gate3Briefing(cwd, feature) {
   };
 }
 
+// An agent writes its report and never commits: left loose it rides into whatever commit comes next, and
+// a revert of that commit takes the report with it. Only these files, in a commit of their own.
+function commitLooseReports(cwd, feature) {
+  const rels = Object.keys(reviewReports(cwd, feature)).map((role) => `.morph/features/${feature}/4-review/${reviewFileName(role)}`);
+  const loose = gitLine(cwd, ['status', '--porcelain', '--untracked-files=all', '--', ...rels]);
+  if (!loose) return [];
+  const paths = loose.split('\n').map((line) => line.slice(3).trim()).filter(Boolean);
+  try {
+    execFileSync('git', ['add', '--', ...paths], { cwd, stdio: 'pipe' });
+    execFileSync('git', ['commit', '-q', '-m', `chore(${feature}): relatórios do Gate 3`, '--', ...paths], { cwd, stdio: 'pipe' });
+    return paths;
+  } catch {
+    return [];
+  }
+}
+
 export function reportCheckCommand(feature, options = {}) {
   const cwd = options.cwd || process.cwd();
   const emit = (obj, code) => {
@@ -138,7 +160,12 @@ export function reportCheckCommand(feature, options = {}) {
     ? { total: progress.total, done: progress.done, pending: progress.checks.filter((c) => c.status === 'pendente').map((c) => c.id),
       blocked: progress.checks.filter((c) => c.status === 'bloqueado').map((c) => c.id), legacy: progress.legacy, warnings }
     : null;
-  emit({ feature, implement, reviews: inspectReviewReports(cwd, feature), ...treeFor(cwd, feature, options.beforeEval) }, 0);
+  const committedReports = commitLooseReports(cwd, feature);
+  emit({
+    feature, implement, reviews: inspectReviewReports(cwd, feature),
+    ...(committedReports.length ? { committedReports } : {}),
+    ...treeFor(cwd, feature, options.beforeEval),
+  }, 0);
 }
 
 function printHuman(obj) {

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

@@ -6,6 +6,7 @@ import { isGateApproved } from '../../../framework/hooks/shared/state-reader.js'
 import { FEATURE_VIEW_FILE, getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { parsePlan } from '../../lib/plan/plan-parser.js';
 import { buildChecks, planHash, planRuleOptions, validatePlan } from '../../lib/plan/checks.js';
+import { critiqueByAgent } from '../../lib/plan/critique.js';
 import { revocationWarnings } from '../../lib/specs/adr-index.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
 import { seedDotnetBuildIgnores } from '../../lib/stack/dotnet-build-ignores.js';
@@ -37,8 +38,13 @@ export function runPlanCheck(featureName, cwd = process.cwd()) {
     return { ...result, ok: false, exit: 1, error: 'frozen', previousHash: previous.planHash ?? null };
   }
 
-  atomicWriteJson(checksPath, buildChecks(featureName, text, plan));
-  return { ...result, ok: true, exit: 0, written: true, viewPath: join(cwd, '.morph', 'features', featureName, FEATURE_VIEW_FILE) };
+  const checks = buildChecks(featureName, text, plan);
+  atomicWriteJson(checksPath, checks);
+  const critique = critiqueByAgent(checks, text);
+  return {
+    ...result, ok: true, exit: 0, written: true, viewPath: join(cwd, '.morph', 'features', featureName, FEATURE_VIEW_FILE),
+    critique: { by: critique.agent ? 'agent' : 'session', reasons: critique.reasons },
+  };
 }
 
 export function planCheckCommand(featureName, options = {}) {
@@ -80,6 +86,9 @@ export function planCheckCommand(featureName, options = {}) {
   } else {
     console.log(chalk.green(`✓ plan-check: ${join('2-plan', 'checks.json')} gravado (${result.planHash.slice(0, 12)})`));
     console.log(chalk.gray(`  página da feature: ${result.viewPath}`));
+    console.log(chalk.gray(result.critique.by === 'agent'
+      ? `  crítica do plano: sub-agent em contexto fresco (${result.critique.reasons.join('; ')})`
+      : '  crítica do plano: a própria sessão, com o checklist de grep (sem sinal de risco)'));
     reportDotnetIgnores(gitignoreAdded);
   }
   process.exit(result.exit);

package/src/commands/validation/prove-red.js

@@ -0,0 +1,95 @@
+import chalk from 'chalk';
+import { execFileSync, spawnSync } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { detectDefaultBranch } from '../../lib/git/default-branch.js';
+import { diffLines, fileClass } from '../../lib/risk/diff-risk.js';
+
+const git = (cwd, args) => execFileSync('git', args, { cwd, stdio: 'pipe' }).toString();
+
+function mergeBase(cwd) {
+  const def = detectDefaultBranch(cwd);
+  for (const ref of def ? [`origin/${def}`, def] : []) {
+    try {
+      return git(cwd, ['merge-base', 'HEAD', ref]).trim();
+    } catch { /* next ref */ }
+  }
+  return null;
+}
+
+function baseContent(cwd, base, path) {
+  try {
+    return execFileSync('git', ['show', `${base}:${path}`], { cwd, stdio: 'pipe' });
+  } catch {
+    return null;
+  }
+}
+
+function runTest(cwd, command) {
+  const r = spawnSync(command, { cwd, shell: true, stdio: 'pipe', encoding: 'utf8' });
+  return r.status === 0 ? 'pass' : 'fail';
+}
+
+/**
+ * The "see it fail without the change" proof, done by the CLI: run the scenario's test with the change,
+ * put the feature's production code back to the merge-base, run it again, restore. Only `code` files
+ * are reverted (never tests), and the restore runs in `finally` from an in-memory copy.
+ */
+export function proveRed(cwd, { test, files = null }) {
+  const base = mergeBase(cwd);
+  if (!base) return { code: 2, out: { error: 'no-base', hint: 'sem merge-base com a branch padrão: não há "sem a mudança" para comparar' } };
+  const changed = diffLines(cwd, base).filter((f) => fileClass(f.path) === 'code').map((f) => f.path);
+  const targets = files ? changed.filter((p) => files.includes(p)) : changed;
+  if (targets.length === 0) {
+    return { code: 2, out: { error: 'nothing-to-revert', changed, hint: 'nenhum arquivo de produção do diff da feature casa com --files' } };
+  }
+
+  const withChange = runTest(cwd, test);
+  if (withChange === 'fail') {
+    return { code: 2, out: { withChange, withoutChange: null, reverted: [], hint: 'o teste já está vermelho COM a mudança: conserte antes de provar' } };
+  }
+
+  const saved = new Map(targets.map((p) => [p, existsSync(join(cwd, p)) ? readFileSync(join(cwd, p)) : null]));
+  let withoutChange;
+  try {
+    for (const path of targets) {
+      const old = baseContent(cwd, base, path);
+      if (old === null) rmSync(join(cwd, path), { force: true });
+      else {
+        mkdirSync(dirname(join(cwd, path)), { recursive: true });
+        writeFileSync(join(cwd, path), old);
+      }
+    }
+    withoutChange = runTest(cwd, test);
+  } finally {
+    for (const [path, content] of saved) {
+      if (content === null) rmSync(join(cwd, path), { force: true });
+      else {
+        mkdirSync(dirname(join(cwd, path)), { recursive: true });
+        writeFileSync(join(cwd, path), content);
+      }
+    }
+  }
+
+  const out = { base, withChange, withoutChange, reverted: targets };
+  if (withoutChange === 'pass') {
+    return { code: 1, out: { ...out, hint: 'o teste passa SEM a mudança: ele não prova o cenário (filtro errado, ou asserção que já era verdade)' } };
+  }
+  return { code: 0, out };
+}
+
+export function proveRedCommand(feature, options = {}) {
+  const cwd = process.cwd();
+  if (!options.test) {
+    console.error(chalk.red('\n❌ --test "<comando do teste do cenário>" é obrigatório\n'));
+    process.exit(2);
+  }
+  const files = options.files ? String(options.files).split(',').map((f) => f.trim().replace(/\\/g, '/')).filter(Boolean) : null;
+  const { code, out } = proveRed(cwd, { test: options.test, files });
+  const payload = { feature, ...out };
+  if (options.json) console.log(JSON.stringify(payload, null, 2));
+  else if (code === 0) console.log(chalk.green(`\n✓ ${feature}: o teste fica vermelho sem a mudança (${out.reverted.join(', ')}) e verde com ela\n`));
+  if (code !== 0 && !options.json) console.error(chalk.red(`\n❌ ${out.hint ?? out.error}\n`));
+  else if (code !== 0) console.error(chalk.red(`❌ ${out.hint ?? out.error}`));
+  process.exit(code);
+}

package/src/commands/validation/verify.js

@@ -1,11 +1,14 @@
 import chalk from 'chalk';
+import { execFileSync } from 'child_process';
 import { resolve } from 'path';
 import { getFeature, updateFeature } from '../../core/state/state-manager.js';
 import { runVerify, VerifyUsageError } from '../../lib/validators/verify-runner.js';
 import { resolvePrimaryRoot } from '../project/worktree.js';
 import { resolveFeatureTree } from '../../lib/worktree/feature-truth.js';
 import { canonicalPath, readMorphConfig } from '../../lib/tasks/test-runner.js';
-import { getHeadSha } from '../../lib/git/default-branch.js';
+import { detectDefaultBranch, getHeadSha } from '../../lib/git/default-branch.js';
+import { featureDiffRisk } from '../../lib/risk/diff-risk.js';
+import { uncommittedCode } from '../../lib/ci/github-ci.js';
 import { EVAL_RUNNER } from '../../lib/tasks/eval-node.js';
 import { buildVerifyEvent, recordVerifyEvent, findRepeatedVerify } from '../../lib/telemetry/verify-event.js';
 import { treeFingerprint } from '../../lib/git/tree-fingerprint.js';
@@ -13,7 +16,7 @@ import { HeavyBusyError } from '../../lib/heavy/gate.js';
 import { afterHeavyRun } from '../../lib/heavy/cleanup.js';
 import { memoryBusyHint } from '../../lib/heavy/live-stacks.js';
 import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js';
-import { runCiVerify, CiUsageError, reusableLocalStamp, resolvePrProof } from '../../lib/ci/ci-verify.js';
+import { reusableLocalStamp, resolvePrProof } from '../../lib/ci/ci-verify.js';
 import { syncStackRules } from '../../lib/installers/stack-sync.js';
 import {
   DETACH_RUN_ENV, DETACH_STAGE_ENV, DETACH_WORKER_ENV, launchWorker, markWorkerExit, runFilesOf, superviseVerify,
@@ -184,6 +187,33 @@ function exitWithReusedStamp(featureName, reused, why, options) {
   process.exit(0);
 }
 
+const E2E_PATH = /(^|\/)(e2e|playwright)\/|\.spec\.[cm]?[jt]sx?$/i;
+
+/**
+ * When a green affected run stands for the gate: over a low-risk diff it IS the proof (the e2e waiver is
+ * classified, never "requested"); over a green complete stamp it renews it when the delta since that stamp
+ * reaches only what it ran (selection is from the merge-base, so it covers the delta; e2e it never runs).
+ * Only a committed tree: the stamp names a SHA.
+ */
+function affectedProof(cwd, prev, stamp) {
+  const dirty = uncommittedCode(cwd);
+  if (!stamp.sha || dirty === null || dirty.length > 0) return null;
+  const risk = featureDiffRisk(cwd, detectDefaultBranch(cwd));
+  if (risk && ['low', 'none'].includes(risk.level)) {
+    return { ...stamp, scope: 'affected', e2eReason: 'not applicable: diff de baixo risco, sem lógica (verify --affected)' };
+  }
+  if (prev?.status !== 'pass' || !prev.sha || prev.pendingPr) return null;
+  let delta;
+  try {
+    delta = execFileSync('git', ['diff', '--name-only', '--no-renames', prev.sha, stamp.sha, '--', '.', ':(exclude).morph'], { cwd, stdio: 'pipe' })
+      .toString().split('\n').map((l) => l.trim()).filter(Boolean);
+  } catch {
+    return null;
+  }
+  if (delta.some((p) => E2E_PATH.test(p))) return null;
+  return { ...prev, sha: stamp.sha, ts: stamp.ts, renewedBy: 'affected' };
+}
+
 // Exit 2 is "the command cannot mean what you typed" (unknown feature, `--filter` matching
 // nothing, `--record-baseline` without config.json, `--linux` without Docker): never a verdict.
 export async function verifyCommand(featureName, options = {}) {
@@ -219,6 +249,12 @@ export async function verifyCommand(featureName, options = {}) {
     console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
     process.exit(2);
   }
+  // A green run of this same tree, complete or affected, already covers what an affected run selects.
+  if (options.affected && !options.fresh) {
+    const fresh = reusableLocalStamp(process.cwd(), feature.verification)
+      ?? reusableLocalStamp(process.cwd(), feature.verifications?.affected);
+    if (fresh) exitWithReusedStamp(featureName, fresh, 'rodada verde deste mesmo tree — não roda de novo', options);
+  }
   if (options.detach) await runDetached(featureName, options);
 
   syncStackRules(process.cwd(), { persistTags: false, log: (line) => console.error(chalk.gray(line)) });
@@ -226,49 +262,28 @@ export async function verifyCommand(featureName, options = {}) {
   if (options.ci) {
     const conflict = CI_EXCLUSIVE_FLAGS.find(([flag]) => options[flag])?.[1];
     if (conflict) {
-      console.error(chalk.red(`\n❌ --ci roda a suíte inteira da feature no CI; não combina com ${conflict}\n`));
+      console.error(chalk.red(`\n❌ --ci é a prova completa da feature; não combina com ${conflict}\n`));
       process.exit(2);
     }
   }
 
-  let ci = null;
+  // Nothing is pushed here: the suites the PR proves are waited for by `finish --pr`, one CI run per SHA.
   let prProof = null;
   if (options.ci) {
     const fresh = reusableLocalStamp(process.cwd(), feature.verification);
-    if (fresh) exitWithReusedStamp(featureName, fresh, 'stamp verde e fresco — o CI não roda de novo', options);
+    if (fresh) exitWithReusedStamp(featureName, fresh, 'stamp verde e fresco — não roda de novo', options);
     prProof = resolvePrProof(process.cwd(), featureName, readMorphConfig(process.cwd()));
-    if (prProof?.local) console.error(chalk.yellow(`\n↪ completa local: ${prProof.local}\n`));
-    try {
-      const outcome = prProof ? null : await runCiVerify(process.cwd(), featureName, readMorphConfig(process.cwd()), {
-        log: (line) => console.error(chalk.gray(`   ${line}`)),
-      });
-      if (!outcome) {
-        // The PR proof has no run to wait for here: `finish --pr` waits for it.
-      } else if (outcome.mode === 'ci') {
-        ci = outcome;
-      } else if (outcome.mode === 'pending') {
-        if (options.json) console.log(JSON.stringify({ status: 'pending', persisted: false, reason: outcome.reason }, null, 2));
-        console.error(chalk.yellow(`\n⏳ ${outcome.reason}. Não é vermelho e não há stamp: não repita em laço — siga e deixe o gate-check decidir.\n`));
-        process.exit(3);
-      } else {
-        console.error(chalk.yellow(`\n↪ CI indisponível (${outcome.reason}) — verify local.\n`));
-      }
-    } catch (err) {
-      if (err instanceof CiUsageError) {
-        console.error(chalk.red(`\n❌ ${err.message}\n`));
-        process.exit(2);
-      }
-      throw err;
-    }
+    if (!prProof) console.error(chalk.yellow('\n↪ sem project.prChecks — verify local completo.\n'));
+    else if (prProof.local) console.error(chalk.yellow(`\n↪ completa local: ${prProof.local}\n`));
   }
 
   // Taken before the run: it is the tree the run is about to read.
   const fingerprint = treeFingerprint(process.cwd());
 
   const pendingPr = prProof?.covers ? prProof : null;
-  const result = ci ? ci.result : await runLocalVerify(featureName, { ...options, excludeNodes: pendingPr?.covers }, fingerprint);
+  const result = await runLocalVerify(featureName, { ...options, excludeNodes: pendingPr?.covers }, fingerprint);
 
-  const cleanup = ci ? { status: 'skipped', reason: 'ci' } : afterHeavyRun({
+  const cleanup = afterHeavyRun({
     projectPath: process.cwd(),
     config: readHeavyConfig(process.cwd()),
     onlyUnderPressure: true,
@@ -308,13 +323,20 @@ export async function verifyCommand(featureName, options = {}) {
       status: result.status,
       nodes: nodeStatuses(result),
       e2eReason: result.nodes.e2e.status === 'skip' ? (result.nodes.e2e.reason ?? null) : null,
-      sha: ci ? ci.run.headSha : getHeadSha(process.cwd()),
+      sha: getHeadSha(process.cwd()),
       ts: now,
       ...(result.flaky?.length ? { flaky: result.flaky } : {}),
-      ...(ci ? { source: 'ci', ciRun: ci.run.url } : {}),
       ...(pendingPr && result.status === 'pass' ? { pendingPr } : {}),
     };
     if (!scopedRun) await updateFeature(featureName, 'verification', stamp);
+    else if (result.status === 'pass') {
+      const proof = affectedProof(process.cwd(), feature.verification, stamp);
+      if (proof) {
+        await updateFeature(featureName, 'verification', proof);
+        console.error(chalk.gray(proof.renewedBy ? `↪ carimbo renovado: a rodada afetada cobre o delta desde ${feature.verification.sha.slice(0, 8)}`
+          : '↪ diff de baixo risco: a rodada afetada é a prova do gate'));
+      }
+    }
   }
 
   // A run over the exact tree of the previous one proves nothing
@@ -322,9 +344,9 @@ export async function verifyCommand(featureName, options = {}) {
   let repeatOf = null;
   try {
     const cwd = process.cwd();
-    if (persist && !ci) repeatOf = findRepeatedVerify(cwd, { feature: featureName, fingerprint });
+    if (persist) repeatOf = findRepeatedVerify(cwd, { feature: featureName, fingerprint });
     const tree = resolve(cwd).replace(/\\/g, '/') === resolvePrimaryRoot(cwd) ? 'root' : 'worktree';
-    recordVerifyEvent(cwd, buildVerifyEvent(result, { sha: ci ? ci.run.headSha : getHeadSha(cwd), tree, persisted: persist && !scopedRun, reason: scopedRun ? 'affected' : reason, fingerprint, source: ci ? 'ci' : 'local' }));
+    recordVerifyEvent(cwd, buildVerifyEvent(result, { sha: getHeadSha(cwd), tree, persisted: persist && !scopedRun, reason: scopedRun ? 'affected' : reason, fingerprint, source: 'local' }));
   } catch { /* telemetry never changes the verdict */ }
 
   // The refusal always goes to stderr, so it survives --json (whose stdout has
@@ -343,16 +365,10 @@ export async function verifyCommand(featureName, options = {}) {
     const output = {
       ...result, nodes, persisted: persist, ...(persist ? {} : { reason }), repeatOf, cleanup,
       ...(pendingPr ? { pendingPr } : {}),
-      ...(ci ? { source: 'ci', ciRun: { id: ci.run.databaseId, url: ci.run.url, sha: ci.run.headSha }, workflowCreated: ci.created } : {}),
     };
     console.log(JSON.stringify(output, null, 2));
   } else {
     console.log(formatVerifyResult(result));
-    if (ci) {
-      console.log(chalk.cyan(`fonte: CI ${ci.run.url}`));
-      if (result.status === 'fail') console.log(chalk.gray(`   log das falhas: gh run view ${ci.run.databaseId} --log-failed`));
-      console.log('');
-    }
     if (cleanup.status !== 'skipped') {
       const mark = cleanup.status === 'ran' ? chalk.green('✓') : chalk.yellow('⚠');
       console.log(chalk.gray(`${mark} dotnet build-server shutdown: ${cleanup.status}${cleanup.reason ? ` (${cleanup.reason})` : ''}\n`));

package/src/lib/ci/ci-verify.js

@@ -1,55 +1,10 @@
-import { execFileSync } from 'child_process';
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
 import { getHeadSha } from '../git/default-branch.js';
 import { treeMovedSince } from '../git/evidence-staleness.js';
-import { resolveGh } from '../git/gh.js';
-import {
-  CI_WORKFLOW_DIR, CI_WORKFLOW_FILE, ciAvailability, downloadResult, findCiWorkflow, pushBranch,
-  uncommittedCode, waitForRun, workflowPushProblem,
-} from './github-ci.js';
+import { ciAvailability, uncommittedCode } from './github-ci.js';
 import { prProofConfig } from './pr-checks.js';
-import { renderCiWorkflow } from './workflow-scaffold.js';
 import { resolveTestNodes } from '../tasks/test-nodes.js';
 import { selectAffected } from '../verify/affected.js';
 
-export const CI_WAIT_MS = 50 * 60 * 1000;
-const APPEAR_MS = Number(process.env.MORPH_CI_APPEAR_MS ?? 90 * 1000);
-
-export class CiUsageError extends Error {}
-
-const NODE_KEYS = ['build', 'tests', 'validators', 'e2e'];
-
-function isVerifyResult(result) {
-  return Boolean(result) && ['pass', 'fail'].includes(result.status)
-    && NODE_KEYS.every((k) => typeof result.nodes?.[k]?.status === 'string');
-}
-
-function scaffoldWorkflow(root, config) {
-  const rel = `${CI_WORKFLOW_DIR}/${CI_WORKFLOW_FILE}`;
-  const abs = join(root, rel);
-  if (existsSync(abs)) return { error: `${rel} já existe e não chama morph-spec verify publicando o JSON` };
-  try {
-    mkdirSync(join(root, CI_WORKFLOW_DIR), { recursive: true });
-    writeFileSync(abs, renderCiWorkflow(root, config));
-    execFileSync('git', ['add', '--', rel], { cwd: root, stdio: 'pipe' });
-    execFileSync('git', ['commit', '-m', 'ci: workflow morph-verify (prova do Gate 3 no CI)', '--', rel], { cwd: root, stdio: 'pipe' });
-    return { path: rel };
-  } catch (err) {
-    return { error: `não consegui criar ${rel}: ${(err.stderr?.toString() || err.message).trim()}` };
-  }
-}
-
-function dispatchWorkflow(root, workflow, branch) {
-  try {
-    const { bin, prefix } = resolveGh();
-    execFileSync(bin, [...prefix, 'workflow', 'run', workflow, '--ref', branch], { cwd: root, stdio: 'pipe', timeout: 15000 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // The last green stamp still proves the tree if nothing moved since it and nothing is uncommitted
 // (treeMovedSince sees only commits). A null sha or HEAD would read as "not moved", so both are required.
 export function reusableLocalStamp(root, stamp) {
@@ -73,63 +28,3 @@ export function resolvePrProof(root, featureName, config, { select = selectAffec
   const selection = select({ projectPath: root, nodes: resolveTestNodes(root).nodes });
   return selection.scope === 'full' ? { local: selection.reason } : proof;
 }
-
-// Every way CI cannot answer is `mode: 'local'` with the reason: no CI is never a pause. Only the
-// uploaded `verify --json` becomes a result, judged by the same stamp and rules as a local run.
-export async function runCiVerify(root, featureName, config, { log = () => {}, waitMs = CI_WAIT_MS, wait = waitForRun } = {}) {
-  const avail = ciAvailability(root, featureName, config);
-  if (!avail.ok) return { mode: 'local', reason: avail.reason };
-
-  const dirty = uncommittedCode(root);
-  if (dirty === null) return { mode: 'local', reason: 'git status não respondeu' };
-  if (dirty.length > 0) {
-    const shown = dirty.slice(0, 5).join(', ') + (dirty.length > 5 ? ` (+${dirty.length - 5})` : '');
-    throw new CiUsageError(`o CI só vê commits e há trabalho fora deles: ${shown}. Commite na branch da feature (git add <paths> && git commit) e rode de novo, ou rode sem --ci`);
-  }
-
-  let workflow = findCiWorkflow(root);
-  let created = null;
-  if (!workflow) {
-    const problem = workflowPushProblem(avail);
-    if (problem) return { mode: 'local', reason: problem };
-    const scaffold = scaffoldWorkflow(root, config);
-    if (scaffold.error) return { mode: 'local', reason: scaffold.error };
-    created = scaffold.path;
-    workflow = CI_WORKFLOW_FILE;
-    log(`workflow criado e commitado: ${created}`);
-  }
-
-  const pushError = pushBranch(root, avail.branch);
-  if (pushError) return { mode: 'local', reason: `push de ${avail.branch} falhou: ${pushError}` };
-
-  const head = getHeadSha(root);
-  const waitOpts = {
-    branch: avail.branch,
-    workflow,
-    isCurrent: (sha) => !treeMovedSince(root, sha, head),
-    timeoutMs: waitMs,
-    appearMs: APPEAR_MS,
-    onPending: (run) => log(`CI rodando: ${run.url}`),
-  };
-  let outcome = await wait(root, waitOpts);
-  if (outcome.state === 'no-run' && dispatchWorkflow(root, workflow, avail.branch)) {
-    log(`nenhum run para este commit; disparei ${workflow} manualmente`);
-    outcome = await wait(root, waitOpts);
-  }
-  if (outcome.state === 'no-run') return { mode: 'local', reason: `${workflow} não rodou para este commit` };
-  if (outcome.state === 'unknown') return { mode: 'local', reason: 'gh run list não respondeu' };
-  if (outcome.state === 'timeout') {
-    return { mode: 'pending', reason: `o CI não terminou em ${Math.round(waitMs / 60000)} min`, run: outcome.run ?? null };
-  }
-
-  const { run } = outcome;
-  const result = downloadResult(root, run.databaseId);
-  if (!isVerifyResult(result)) {
-    return {
-      mode: 'local',
-      reason: `run ${run.conclusion} sem o JSON do verify (${run.url}; gh run view ${run.databaseId} --log-failed)`,
-    };
-  }
-  const { persisted, reason, repeatOf, cleanup, ...verdict } = result;
-  return { mode: 'ci', result: verdict, run, created };
-}