@polymorphism-tech/morph-spec 9.8.0 → 10.0.0

package/src/lib/risk-detector.js

@@ -1,5 +1,5 @@
-import { MAX_SLICES } from './plan/checks.js';
 import { BLOCKER_TYPES, reviewFileName } from './review-reports.js';
+import { FIX_ATTEMPTS } from '../../framework/hooks/shared/next-step.js';
 import { isTestPath } from './graph/sanitize.js';
 import { isTestArtifact } from './worktree/ignored-triage.js';
 
@@ -55,7 +55,7 @@ function firstOf(items) {
 
 // Exportada porque approve/advance `auto` recusam pela mesma regra. Sem design de tela não conta,
 // e o legado chega sem problemas: a auditoria o isenta. Checklist
-// completo ainda deve o protótipo e os prints 1280/390 (`prototypes`).
+// completo ainda deve o protótipo, os prints 1280/390 e os estados (`prototypes`).
 export function uiuxChecklistPause(screenChecklist) {
   if (screenChecklist?.mockups !== true) return null;
   const problems = screenChecklist.problems ?? [];
@@ -95,6 +95,11 @@ export function reviewPause(signal) {
     return `${untyped} bloqueador(es) sem tipo de evidência (${BLOCKER_TYPES.join(' | ')})`
          + ' — sem evidência tipada não é bloqueador: reclassifique como nota ou complete a evidência';
   }
+  for (const [role, r] of present) {
+    if ((r.humanBlockerIds?.length ?? 0) > 0) {
+      return `${role} achou mudança irreversível que o plano não declara: ${firstOf(r.humanBlockerIds)} — o usuário decide`;
+    }
+  }
   for (const [role, r] of present) {
     if ((r.blockers ?? 0) > 0) return `${role} abriu ${r.blockers} bloqueador(es): ${firstOf(r.blockerIds ?? [])}`;
   }
@@ -162,7 +167,78 @@ export function planChecksPause(status) {
   return `${what} — rode \`morph-spec plan-check {feature}\` até zero erro antes do gate do plano`;
 }
 
+export const PAUSING_RUNGS = ['migrar', 'irreversível'];
+const MIGRATION_PATH_RE = /(^|\/)migrations?\//i;
+
+export function pausingRungs(checks) {
+  const list = Array.isArray(checks?.checks) ? checks.checks : [];
+  return list.filter((c) => PAUSING_RUNGS.includes(c.rung)).map((c) => ({ id: c.id, rung: c.rung }));
+}
+
+// Só o arquivo que É o contrato. Webhook e endpoint ficam com o revisor (`irreversivel`): o caminho não diz se quebra quem consome.
+const CONTRACT_PATH_RE = /(^|\/)(openapi|swagger)\.(ya?ml|json)$|\.proto$/i;
+
+const touchedBy = (re) => (changedFiles = []) =>
+  changedFiles.map((f) => f.replaceAll('\\', '/')).filter((f) => re.test(f) && !isTestOnly(f));
+export const migrationsTouched = touchedBy(MIGRATION_PATH_RE);
+export const contractsTouched = touchedBy(CONTRACT_PATH_RE);
+
+export const humanApprover = (approvedBy) => !!approvedBy && approvedBy !== 'auto' && !String(approvedBy).startsWith('policy:');
+
+// Regra única do gate-check (pausa) e do approve/advance automáticos do plano (recusa).
+export function rungPause(signals) {
+  const rungs = signals.rungs ?? [];
+  const named = rungs.map((r) => `${r.id} (${r.rung})`).join(', ');
+  if (signals.gate === 'plan') {
+    return rungs.length ? { signal: 'rung', reason: `${named} não se desfaz com revert — o usuário confirma antes de implementar` } : null;
+  }
+  if (signals.gate !== 'review') return null;
+  const migrations = signals.migrationsTouched ?? [];
+  if (migrations.length > 0 && rungs.length === 0) {
+    return { signal: 'rung-undeclared', reason: `a feature toca migration (${firstOf(migrations)}) e nenhum cenário declara \`degrau: migrar\` ou \`irreversível\`` };
+  }
+  const contracts = signals.contractsTouched ?? [];
+  if (contracts.length > 0 && !rungs.some((r) => r.rung === 'irreversível')) {
+    return { signal: 'rung-undeclared', reason: `a feature toca contrato externo (${firstOf(contracts)}) e nenhum cenário declara \`degrau: irreversível\`` };
+  }
+  if (rungs.length > 0 && !signals.planApprovedByHuman) return { signal: 'rung', reason: `${named} não passou por aprovação humana no plano` };
+  return null;
+}
+
+const PLAN_CRITIQUE_REASONS = {
+  missing: 'sem `2-plan/critica.md`',
+  'no-hash': '`2-plan/critica.md` sem `**Plan-Hash:**`',
+  stale: '`2-plan/critica.md` é de outra versão do plano e nenhum `**Aplicado-em:**` cobre a atual',
+};
+
+// Regra única do gate-check (pausa) e do approve/advance automáticos do plano (recusa).
+export function planCritiquePause(status) {
+  const what = PLAN_CRITIQUE_REASONS[status];
+  return what ? `${what} — despache a crítica em contexto fresco (morph-plan, references/critique.md) antes do gate do plano` : null;
+}
+
+// Pauses the session clears by doing the work the reason names; the rest wait for the human.
+const REPORT_SIGNALS = ['review-reports', 'screen-checklist', 'media-claims'];
+export const SESSION_SIGNALS = ['verify-red', 'verify-missing', 'verify-stale', 'e2e-skip', 'plan-checks', 'plan-critique', 'uiux-checklist', ...REPORT_SIGNALS];
+
+const reviewRounds = (review) => Math.max(0, ...Object.values(review?.reports ?? {}).map((r) => r.rounds ?? 0));
+const humanBlockers = (review) => Object.values(review?.reports ?? {}).some((r) => (r.humanBlockerIds?.length ?? 0) > 0);
+
+export function pauseResolver(signal, signals = {}) {
+  if (!SESSION_SIGNALS.includes(signal)) return 'human';
+  if (signal === 'verify-red' && (signals.failStreak ?? 0) >= FIX_ATTEMPTS) return 'human';
+  if (signal === 'e2e-skip' && classifyE2eSkip(signals.e2eReason) !== 'requested') return 'human';
+  if (REPORT_SIGNALS.includes(signal) && reviewRounds(signals.reviewReports) >= FIX_ATTEMPTS) return 'human';
+  if (signal === 'review-reports' && humanBlockers(signals.reviewReports)) return 'human';
+  return 'session';
+}
+
 export function shouldPauseGate(config, signals) {
+  const decision = pauseDecision(config, signals);
+  return decision.pause ? { ...decision, resolver: pauseResolver(decision.signal, signals) } : decision;
+}
+
+function pauseDecision(config, signals) {
   const trust = config?.trust ?? 'auto';
 
   if (trust === 'manual') {
@@ -301,15 +377,13 @@ export function shouldPauseGate(config, signals) {
   if (signals.gate === 'plan') {
     const reason = planChecksPause(signals.planChecks);
     if (reason) return { pause: true, signal: 'plan-checks', reason };
+    const critique = planCritiquePause(signals.planCritique);
+    if (critique) return { pause: true, signal: 'plan-critique', reason: critique };
   }
 
-  if (typeof signals.sliceCount === 'number' && signals.sliceCount > MAX_SLICES) {
-    return {
-      pause: true,
-      signal: 'slice-count',
-      reason: `${signals.sliceCount} fatias, acima de ${MAX_SLICES} — o plano é grande demais para uma feature`,
-    };
-  }
+  // Por último: o usuário só é chamado pelo degrau quando a sessão não tem mais nada a corrigir.
+  const rung = rungPause(signals);
+  if (rung) return { pause: true, ...rung };
 
   return { pause: false, signal: null, reason: '' };
 }
@@ -346,8 +420,13 @@ export function getRiskSignals(signals) {
   if (signals.gate === 'plan' && signals.planChecks && signals.planChecks !== 'fresh') {
     out.push(`checks.json ${signals.planChecks}`);
   }
-  if (typeof signals.sliceCount === 'number' && signals.sliceCount > MAX_SLICES) {
-    out.push(`${signals.sliceCount} fatias (acima de ${MAX_SLICES})`);
+  if (signals.gate === 'plan' && signals.planCritique) out.push(`crítica do plano: ${signals.planCritique}`);
+  if ((signals.rungs?.length ?? 0) > 0) out.push(`degrau: ${signals.rungs.map((r) => `${r.id} ${r.rung}`).join(', ')}`);
+  if (signals.gate === 'review' && (signals.migrationsTouched?.length ?? 0) > 0) {
+    out.push(`migration tocada: ${firstOf(signals.migrationsTouched)}`);
+  }
+  if (signals.gate === 'review' && (signals.contractsTouched?.length ?? 0) > 0) {
+    out.push(`contrato externo tocado: ${firstOf(signals.contractsTouched)}`);
   }
   if (signals.gate === 'review' && signals.mediaClaims?.featureGeneratesMedia === true) {
     out.push(signals.mediaClaims.section === true

package/src/lib/specs/screen-checklist.js

@@ -5,30 +5,19 @@
 import { createHash } from 'crypto';
 import { existsSync, readFileSync } from 'fs';
 import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { verifierScreenChecklist } from '../review-reports.js';
 import { LEGACY_MOCKUP_EXEMPTION, uiuxChecklistPause } from '../risk-detector.js';
 
-const PACKAGE_AGENTS = fileURLToPath(new URL('../../../framework/agents.json', import.meta.url));
-
 /** `match` roda sobre o rótulo normalizado; um rótulo que casa com vários itens responde a todos. */
 export const SCREEN_CHECKLIST_ITEMS = [
-  { id: 'superficie', label: 'Superfície', match: /\bsuperficie\b/ },
-  { id: 'volume', label: 'Volume esperado', match: /\bvolume\b/ },
-  { id: 'paginacao', label: 'Paginação', match: /\bpaginacao\b/ },
-  { id: 'ordenacao', label: 'Ordenação', match: /\bordenacao\b/ },
-  { id: 'filtro', label: 'Filtro', match: /\bfiltros?\b/ },
-  { id: 'vazio', label: 'Estado vazio', match: /\bvazio\b/ },
-  { id: 'carregando', label: 'Estado carregando', match: /\bcarregando\b|\bcarregamento\b/ },
-  { id: 'erro', label: 'Estado de erro', match: /\berro\b/ },
-  { id: 'mobile', label: 'Mobile', match: /\bmobile\b/ },
-  { id: 'abas', label: 'Abas', match: /\babas\b/ },
+  { id: 'servidor', label: 'Lista no servidor', match: /\bpaginacao\b|\bordenacao\b|\bservidor\b/ },
+  { id: 'estados', label: 'Estados vazio e carregando', match: /\bvazio\b|\bcarregando\b|\bcarregamento\b/ },
+  { id: 'erro', label: 'Erro com próxima ação', match: /\berro\b/ },
+  { id: 'acao', label: 'Uma ação primária', match: /\bprimaria\b/ },
+  { id: 'mobile', label: 'Celular', match: /\bmobile\b|\bcelular\b/ },
 ];
 
-// A superfície decide quais standards a tela lê, não um comportamento que a tela entregue exiba.
-const NOT_VERIFIED_AT_REVIEW = new Set(['superficie']);
-
 // As exatas, e as que começam adiando a decisão ("a definir depois", "TBD.").
 const PLACEHOLDERS = new Set(['', '-', '--', '—', '–', '...', 'x', 'todo', 'definir', 'pendente']);
 const PLACEHOLDER_PREFIX_RE = /^(a definir|tbd|\?|…)/;
@@ -141,30 +130,9 @@ const isNotApplicable = (answer) => NOT_APPLICABLE_RE.test(normalizeLabel(answer
 
 const labelOf = (id) => SCREEN_CHECKLIST_ITEMS.find((item) => item.id === id)?.label ?? id;
 
-// O vocabulário válido de `Superfície`: as `surfaces` da `ui-designer`, da cópia instalada ou do pacote.
-// null quando a persona não declara o campo, e então o valor não é validado.
-export function knownSurfaces(cwd) {
-  const surfaces = readAgentsJson(cwd)?.agents?.['ui-designer']?.surfaces;
-  return surfaces && typeof surfaces === 'object' && !Array.isArray(surfaces) ? Object.keys(surfaces) : null;
-}
-
-/** The project's installed `agents.json`, else the package's; null when unreadable. */
-export function readAgentsJson(cwd) {
-  for (const path of [join(cwd, '.morph', 'framework', 'agents.json'), PACKAGE_AGENTS]) {
-    if (!existsSync(path)) continue;
-    try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
-  }
-  return null;
-}
-
-function namesSurface(answer, surfaces) {
-  const norm = normalizeLabel(answer);
-  return surfaces.some((key) => new RegExp(`(^|[^a-z0-9-])${key}([^a-z0-9-]|$)`).test(norm));
-}
-
 // Sem nenhuma `## Tela:`, só o formato antigo é legado; qualquer outro heading é "nenhuma tela
 // declarada", senão trocar o heading pularia o checklist.
-export function auditScreenChecklist(markdown, { surfaces = null } = {}) {
+export function auditScreenChecklist(markdown) {
   const parsed = parseScreens(markdown);
   const problems = [];
   if (parsed.length === 0) {
@@ -185,18 +153,25 @@ export function auditScreenChecklist(markdown, { surfaces = null } = {}) {
     } else {
       if (missing.length) problems.push(`tela "${screen.name}": falta ${missing.map(labelOf).join(', ')}`);
       if (unanswered.length) problems.push(`tela "${screen.name}": sem resposta em ${unanswered.map(labelOf).join(', ')}`);
-      const surface = screen.answers.get('superficie');
-      if (surfaces?.length && surface !== undefined && !isPlaceholder(surface) && !isNotApplicable(surface)
-          && !namesSurface(surface, surfaces)) {
-        problems.push(`tela "${screen.name}": Superfície "${surface}" não é uma das superfícies da ui-designer (${surfaces.join(', ')})`);
-      }
     }
-    return { name: screen.name, hasChecklist: screen.hasChecklist, missing, unanswered, prototype: screen.prototype };
+    return { name: screen.name, hasChecklist: screen.hasChecklist, missing, unanswered, prototype: screen.prototype, states: statesOf(screen) };
   });
   return { legacy: false, screens, problems };
 }
 
-// Linha **Protótipo:** da tela + o HTML + os prints do laço de autocrítica ao lado dele.
+/** The states the prototype must switch to, by the checklist items that apply to the screen. */
+export const PROTOTYPE_STATES = { estados: ['vazio', 'carregando'], erro: ['erro'] };
+export const STATE_PRINT_WIDTH = 390;
+
+function statesOf(screen) {
+  return Object.entries(PROTOTYPE_STATES).flatMap(([id, states]) => {
+    const answer = screen.answers.get(id);
+    return answer && !isPlaceholder(answer) && !isNotApplicable(answer) ? states : [];
+  });
+}
+
+// Linha **Protótipo:** da tela + o HTML + os prints do laço de autocrítica ao lado dele; cada estado
+// que o checklist diz que se aplica tem `data-estado` no HTML e o print de celular.
 export function auditPrototypes(screens, designDir) {
   const problems = [];
   for (const screen of screens) {
@@ -205,9 +180,19 @@ export function auditPrototypes(screens, designDir) {
       continue;
     }
     const base = screen.prototype.replace(/\.html$/i, '');
-    const expected = [screen.prototype, ...PROTOTYPE_WIDTHS.map((width) => `${base}-${width}.png`)];
+    const states = screen.states ?? [];
+    const expected = [
+      screen.prototype,
+      ...PROTOTYPE_WIDTHS.map((width) => `${base}-${width}.png`),
+      ...states.map((state) => `${base}-${state}-${STATE_PRINT_WIDTH}.png`),
+    ];
     const missing = expected.filter((rel) => !existsSync(join(designDir, rel)));
     if (missing.length) problems.push(`tela "${screen.name}": falta ${missing.map((rel) => `1-design/${rel}`).join(', ')}`);
+    const html = existsSync(join(designDir, screen.prototype)) ? readFileSync(join(designDir, screen.prototype), 'utf8') : '';
+    const unswitchable = html ? states.filter((state) => !new RegExp(`data-estado\\s*=\\s*["']${state}["']`).test(html)) : [];
+    if (unswitchable.length) {
+      problems.push(`tela "${screen.name}": o protótipo não alterna para ${unswitchable.join(', ')} (falta \`data-estado="…"\` no seletor de estado)`);
+    }
   }
   return problems;
 }
@@ -216,7 +201,7 @@ export function auditPrototypes(screens, designDir) {
 export function collectScreenChecklist(cwd, featureName, gateName) {
   const mockups = readMockups(cwd, featureName);
   if (mockups === null) return { mockups: false, legacy: false, screens: [], problems: [] };
-  const audit = auditScreenChecklist(mockups, { surfaces: knownSurfaces(cwd) });
+  const audit = auditScreenChecklist(mockups);
   const signal = { mockups: true, legacy: audit.legacy, screens: audit.screens.map((s) => s.name), problems: audit.problems };
   if (audit.legacy) signal.exempt = LEGACY_MOCKUP_EXEMPTION;
   if (gateName === 'uiux' && !audit.legacy) {
@@ -255,7 +240,7 @@ export function checklistCoverage(designMarkdown, reportSection) {
   for (const screen of parseScreens(designMarkdown)) {
     const done = covered.get(screenKey(screen.name)) ?? new Set();
     const owed = [...screen.answers]
-      .filter(([id, answer]) => !NOT_VERIFIED_AT_REVIEW.has(id) && !isPlaceholder(answer) && !isNotApplicable(answer))
+      .filter(([, answer]) => !isPlaceholder(answer) && !isNotApplicable(answer))
       .map(([id]) => id)
       .filter((id) => !done.has(id));
     if (owed.length) gaps.push(`${screen.name}: ${owed.map(labelOf).join(', ')}`);

package/src/lib/stack/dotnet-build-ignores.js

@@ -1,15 +1,14 @@
-import { readdirSync } from 'fs';
+import { existsSync, readdirSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { ensureDotnetBuildIgnores } from '../../utils/file-copier.js';
 import { getProjectTags } from '../stack-filter.js';
 import { readMorphConfig } from '../tasks/test-runner.js';
-import { readPlanChecks } from '../plan/checks.js';
+import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { WORKTREE_DIR_NAMES } from '../worktree/dirs.js';
 
-export const DOTNET_IMPLEMENTERS = ['dotnet-senior', 'ef-modeler', 'maf-expert'];
-
 const SKIPPED_DIRS = new Set([...WORKTREE_DIR_NAMES, 'node_modules', 'bin', 'obj']);
 const DOTNET_PROJECT_FILE = /\.(?:csproj|slnx?)$/i;
+const DOTNET_IN_PLAN = /\.(?:cs|csproj|slnx?)\b|\bdotnet\s+(?:test|build|new)\b/i;
 const MAX_DEPTH = 6;
 
 export function hasDotnetProjectFile(root, depth = 0) {
@@ -21,16 +20,16 @@ export function hasDotnetProjectFile(root, depth = 0) {
     && hasDotnetProjectFile(join(root, e.name), depth + 1));
 }
 
-function planHasDotnetSlice(tree, featureName) {
+function planMentionsDotnet(tree, featureName) {
   if (!featureName) return false;
-  const { checks } = readPlanChecks(tree, featureName);
-  return (checks?.slices || []).some((slice) => DOTNET_IMPLEMENTERS.includes(String(slice.persona || '').replace(/^morph-/, '')));
+  const path = getAbsoluteOutputPath(tree, featureName, 'plan');
+  try { return existsSync(path) && DOTNET_IN_PLAN.test(readFileSync(path, 'utf8')); } catch { return false; }
 }
 
-// The plan's slices are checked because a greenfield tree has no stack or .csproj yet.
+// The plan is read because a greenfield tree has no stack or .csproj yet.
 export function isDotnetProject(tree, { featureName, configRoot = tree } = {}) {
   if (getProjectTags(readMorphConfig(configRoot)).includes('dotnet')) return true;
-  return planHasDotnetSlice(tree, featureName) || hasDotnetProjectFile(tree);
+  return planMentionsDotnet(tree, featureName) || hasDotnetProjectFile(tree);
 }
 
 /** Returns the `.gitignore` entries added; `[]` when not .NET or on any error. */

package/src/lib/telemetry/metrics.js

@@ -95,36 +95,16 @@ function addRun(slot, durationMs) {
 const REVIEW_NAME = /^(?:ver|rev|sec|g3|gate3|eval|review|reviewer|security)\d*-/;
 const isReviewAgent = (type) => REVIEW_AGENT_TYPES.has(type) || type === 'morph-evaluator' || REVIEW_NAME.test(String(type ?? ''));
 
-// Same split as the test-budget hook: review first, then an unfiltered verify, then the round count.
 // A run refused by the full heavy queue ran no test.
 function testOutsideVerify(bashEvents) {
-  const out = {
-    total: newTimeSlot(),
-    subagentVerify: newTimeSlot(),
-    implementerRound3Plus: newTimeSlot(),
-    reviewTests: { ...newTimeSlot(), byPersona: newTimeSlot() },
-  };
-  const byAgent = new Map();
+  const out = { total: newTimeSlot(), reviewTests: { ...newTimeSlot(), byPersona: newTimeSlot() } };
   for (const e of bashEvents) {
     if (e.event === 'PostToolUseFailure' && e.exitCode === QUEUE_FULL_EXIT) continue;
-    const verify = morphVerifyCall(e.command);
-    if (!verify && !testRunKind(e.command)) continue;
+    if (!morphVerifyCall(e.command) && !testRunKind(e.command)) continue;
     addRun(out.total, e.durationMs);
-    if (!e.agentId) continue;
-    if (isReviewAgent(e.agentType)) {
-      addRun(out.reviewTests, e.durationMs);
-      if (REVIEW_AGENT_TYPES.has(e.agentType)) addRun(out.reviewTests.byPersona, e.durationMs);
-      continue;
-    }
-    if (!byAgent.has(e.agentId)) byAgent.set(e.agentId, []);
-    byAgent.get(e.agentId).push({ e, unfilteredVerify: Boolean(verify && !verify.filtered) });
-  }
-  for (const runs of byAgent.values()) {
-    runs.sort((a, b) => String(a.e.ts ?? '').localeCompare(String(b.e.ts ?? '')));
-    runs.forEach(({ e, unfilteredVerify }, round) => {
-      if (unfilteredVerify) addRun(out.subagentVerify, e.durationMs);
-      else if (round >= 2) addRun(out.implementerRound3Plus, e.durationMs);
-    });
+    if (!e.agentId || !isReviewAgent(e.agentType)) continue;
+    addRun(out.reviewTests, e.durationMs);
+    if (REVIEW_AGENT_TYPES.has(e.agentType)) addRun(out.reviewTests.byPersona, e.durationMs);
   }
   return out;
 }
@@ -164,7 +144,7 @@ function reuseStateOf(e) {
   return { state: 'absent', reason: null };
 }
 
-const newGateSlot = () => ({ decisions: 0, paused: 0, autoPassed: 0, approvedAfterPause: 0, reworkedAfterPause: 0, unapproved: 0, bySignal: {} });
+const newGateSlot = () => ({ decisions: 0, paused: 0, pausedForHuman: 0, pausedUnattributed: 0, autoPassed: 0, approvedAfterPause: 0, reworkedAfterPause: 0, unapproved: 0, bySignal: {} });
 
 // A pause stays open until the next approve or a decision that no longer pauses on the same signal:
 // re-running gate-check over the same unchanged pause is not rework.
@@ -173,7 +153,7 @@ function trackGate(gates, open, e) {
   const slot = gates[e.gate] ||= newGateSlot();
   const key = `${e.feature || ''}\u0000${e.gate}`;
   const pending = open.get(key);
-  const bySignal = (signal) => slot.bySignal[signal || 'desconhecido'] ||= { paused: 0, approvedAfterPause: 0, reworkedAfterPause: 0 };
+  const bySignal = (signal) => slot.bySignal[signal || 'desconhecido'] ||= { paused: 0, pausedForHuman: 0, pausedUnattributed: 0, approvedAfterPause: 0, reworkedAfterPause: 0 };
   const credit = (field) => {
     slot[field] += 1;
     bySignal(pending.signal)[field] += 1;
@@ -189,12 +169,30 @@ function trackGate(gates, open, e) {
     return;
   }
   slot.decisions += 1;
-  if (pending && e.pause && e.signal === pending.signal) return;
+  const resolver = e.resolver ?? 'human';
+  if (pending && e.pause && e.signal === pending.signal) {
+    // Same signal, new owner: the session ran out of attempts and the pause escalated to the human.
+    if (pending.resolver === 'session' && resolver === 'human') {
+      slot.pausedForHuman += 1;
+      bySignal(pending.signal).pausedForHuman += 1;
+    }
+    pending.resolver = resolver;
+    return;
+  }
   if (pending) credit(e.source === 'manual' && !e.pause ? 'approvedAfterPause' : 'reworkedAfterPause');
   if (e.pause) {
     slot.paused += 1;
     bySignal(e.signal).paused += 1;
-    open.set(key, { signal: e.signal });
+    if (resolver === 'human') {
+      slot.pausedForHuman += 1;
+      bySignal(e.signal).pausedForHuman += 1;
+    }
+    // Written before the resolver existed: counted as human above, but nobody recorded who cleared it.
+    if (e.resolver === undefined) {
+      slot.pausedUnattributed += 1;
+      bySignal(e.signal).pausedUnattributed += 1;
+    }
+    open.set(key, { signal: e.signal, resolver });
   } else {
     slot.autoPassed += 1;
     open.delete(key);

package/src/lib/validators/reuse/reuse-validator.js

@@ -123,16 +123,8 @@ export function readReuseVerdicts(projectPath, featureName) {
   return verdicts;
 }
 
-// União de duas fontes cegas em momentos diferentes: `arquivos:` das fatias sobrevivem
-// ao commit; `git status` pega o que o plano não previu.
-export function collectChangedFiles(projectPath, featureName) {
+export function collectChangedFiles(projectPath) {
   const files = new Set();
-  for (const slice of readPlanChecks(projectPath, featureName).checks?.slices ?? []) {
-    for (const file of slice.files ?? []) {
-      if (typeof file === 'string') files.add(file.replace(/\\/g, '/'));
-    }
-  }
-
   try {
     const out = execFileSync('git', ['status', '--porcelain', '--untracked-files=all'], {
       cwd: projectPath,

package/src/lib/validators/verify-runner.js

@@ -21,7 +21,6 @@ import {
   evalEmptyRunProblem, evalColdCacheWarning,
 } from '../tasks/eval-node.js';
 import { runValidation } from './validation-runner.js';
-import { checkOutputsTraceability } from './traceability-check.js';
 import { createHeavyGate } from '../heavy/gate.js';
 
 const DEFAULT_BUILD_TIMEOUT = 1_800_000;
@@ -70,7 +69,6 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
     _runValidation = runValidation,
     _runE2eCheck = runE2eCheck,
     _e2eApplicability = e2eApplicability,
-    _checkOutputsTraceability = checkOutputsTraceability,
   } = options;
 
   const stack = readStack(projectPath);
@@ -170,10 +168,6 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
     appendTestsFeedback(feedback, nodes.tests);
   }
 
-  // Outside `nodes` on purpose: status comes only from the nodes, so a traceability
-  // warning never turns red.
-  const traceability = _checkOutputsTraceability(projectPath, featureName);
-
   const baseline = recordBaseline ? recordBaselineFrom(projectPath, nodes.tests) : null;
   if (baseline && !baseline.recorded) {
     feedback.push(`[baseline] não gravada: ${baseline.reason}`);
@@ -193,7 +187,6 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
     status,
     nodes,
     feedback,
-    traceability,
     ...(baseline ? { baseline } : {}),
   };
 }

package/src/lib/worktree/fleet-scanner.js

@@ -18,12 +18,12 @@ import {
 import { listClaims } from '../../../framework/hooks/shared/claim-registry.js';
 import { buildPrIndex } from '../git/pr-index.js';
 import { pendingPrFeatures } from '../git/pending-prs.js';
-import { sliceProgress, sliceProgressFrom } from '../../../framework/hooks/shared/slice-progress.js';
+import { implementProgress, implementProgressFrom } from '../../../framework/hooks/shared/report-progress.js';
 
 const counts = (progress) => (progress ? { done: progress.done, total: progress.total } : null);
 
-// A root-resident feature's reports live on `morph/{f}`; the root tree only has the pre-work copy.
-function sliceCounts(featureDir, { root, feature, featureBranch } = {}) {
+// A root-resident feature's report lives on `morph/{f}`; the root tree only has the pre-work copy.
+function scenarioCounts(featureDir, { root, feature, featureBranch } = {}) {
   if (featureBranch && root && feature) {
     const show = (rel) => {
       try {
@@ -32,21 +32,10 @@ function sliceCounts(featureDir, { root, feature, featureBranch } = {}) {
         return null;
       }
     };
-    const onBranch = sliceProgressFrom(show('2-plan/checks.json'), (id) => show(`3-implement/reports/${id}.md`));
+    const onBranch = implementProgressFrom(show('2-plan/checks.json'), show('3-implement/report.md'), (id) => show(`3-implement/reports/${id}.md`));
     if (onBranch) return counts(onBranch);
   }
-  return counts(sliceProgress(featureDir));
-}
-
-function handoffInfo(featureDir) {
-  try {
-    const path = join(featureDir, 'handoff.md');
-    if (!existsSync(path)) return { exists: false, generatedAt: null };
-    const generatedAt = readFileSync(path, 'utf8').match(/gerado em (\d{4}-\d{2}-\d{2}T[\d:.]+Z)/)?.[1] || null;
-    return { exists: true, generatedAt };
-  } catch {
-    return { exists: false, generatedAt: null };
-  }
+  return counts(implementProgress(featureDir));
 }
 
 function lastCommitRelative(root, branch) {
@@ -132,11 +121,10 @@ function buildEntry(feature, { location, path, branch, root, allocations, blockS
     location,
     path,
     branch,
-    slices: sliceCounts(featureDir, { root, feature, featureBranch }),
+    scenarios: scenarioCounts(featureDir, { root, feature, featureBranch }),
     env: alloc && Number.isInteger(alloc.base)
       ? { base: alloc.base, range: [alloc.base, alloc.base + blockSize - 1] }
       : null,
-    handoff: handoffInfo(featureDir),
     lastCommit: location === 'worktree' && branch ? lastCommitRelative(root, branch) : null,
     dirty: location === 'worktree' ? dirtyCount(path) : null,
     remote: buildRemote(feature, branch, heads, prs),
@@ -221,9 +209,8 @@ export function scanFleet(cwd = process.cwd()) {
         location: 'pr-pending',
         path: null,
         branch: p.branch,
-        slices: null,
+        scenarios: null,
         env: null,
-        handoff: { exists: false, generatedAt: null },
         lastCommit: null,
         dirty: null,
         remote: { branch: p.branch, pushed: true, sha: null, pr: { number: p.number, state: p.state } },

package/src/lib/worktree/worktree-audit.js

@@ -13,40 +13,8 @@ import { buildPrIndex } from '../git/pr-index.js';
 import { classifyBranch, commitsAhead, resolveBaseRef } from '../git/branch-classifier.js';
 import { auditDockerStacks } from './docker-audit.js';
 import { auditFinishBackups } from './finish-backup.js';
-import { planAgentReap } from './agent-reaper.js';
 
 const norm = (p) => resolve(p).replace(/\\/g, '/');
-const AGENT_TASK = /^agent-[0-9a-f]+$/;
-
-const AGENT_FIX = {
-  'stopped-clean': 'morph-spec worktree reap  (ou `morph-spec doctor --worktrees --prune`)',
-  'orphan-branch': 'morph-spec worktree reap  (ou `morph-spec doctor --worktrees --prune`)',
-  'directory-missing': 'morph-spec doctor --worktrees --prune',
-  locked: 'a árvore está com `git worktree lock`; `git worktree unlock <path>` libera, se o lock já não vale',
-  unknown: 'não foi possível provar que é seguro remover — deixe como está',
-};
-
-function agentLeftoverIssue(item) {
-  const where = item.path ?? item.branch;
-  const reapable = item.state === 'reapable';
-  const fix = AGENT_FIX[item.reason]
-    ?? (item.reason === 'exclusive-commits'
-      ? `integre a branch (\`git merge --no-ff ${item.branch}\` no orquestrador) antes de remover — ela é o único exemplar`
-      : item.reason === 'dirty'
-        ? `confira o trabalho na árvore (commite ou descarte) e rode \`morph-spec worktree remove --target "${item.path}"\``
-        : `o harness não registrou o fim do agente; se ele já terminou, \`morph-spec worktree remove --target "${item.path}"\``);
-  return {
-    type: 'agent-worktree-leftover',
-    severity: 'info',
-    ...(item.path ? { path: item.path } : {}),
-    branch: item.branch,
-    reapable,
-    detail: reapable
-      ? `${where} é sobra de sub-agent que já parou, sem trabalho pendente`
-      : `${where} é sobra de sub-agent com trabalho a preservar (${item.reason}${item.detail ? `: ${item.detail}` : ''})`,
-    fix,
-  };
-}
 
 function knownFeatures(root) {
   const names = new Set();
@@ -197,7 +165,6 @@ export function auditWorktrees(cwd = process.cwd(), { exec } = {}) {
       }
 
       if (task) {
-        if (AGENT_TASK.test(task)) continue; // reported once, by the agent plan below
         const work = unintegratedWork(root, entry.branch, prIndex);
         if (work.unintegrated) {
           issues.push({
@@ -262,10 +229,6 @@ export function auditWorktrees(cwd = process.cwd(), { exec } = {}) {
     }
   }
 
-  for (const item of planAgentReap(root, { cwd }).items) {
-    if (item.state === 'reapable' || item.state === 'preserved') issues.push(agentLeftoverIssue(item));
-  }
-
   for (const d of dirsOnDisk(root)) {
     if (registeredPaths.has(d.path)) continue;
     issues.push({