@polymorphism-tech/morph-spec 9.8.0 → 10.1.1

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({

package/src/scripts/setup-infra.js

@@ -18,10 +18,11 @@ import { injectMorphImport } from '../utils/claude-md-injector.js';
 import { saveProjectMorphVersion, getInstalledCLIVersion, getProjectMorphVersion } 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 { resolvePrimaryRoot } from '../commands/project/worktree.js';
 import { reconcileLegacyTemplatesCopy } from '../lib/installers/templates-reconcile.js';
 import { realEffects } from '../lib/installers/effects.js';
+import { installRulesForStack } from '../lib/installers/rules-installer.js';
 
 const FRAMEWORK_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'framework');
 
@@ -41,31 +42,7 @@ async function installRequiredPlugins(log, exec) {
   }
 }
 
-/** Also removes orphan rules in rulesDest that are no longer in the install set. */
-export function installRulesForStack(rulesSrc, rulesDest, projectTags, fx = realEffects()) {
-  const sourceFiles = readdirSync(rulesSrc).filter(f => f.endsWith('.md'));
-  const installed = new Set();
-
-  for (const file of sourceFiles) {
-    const content = readFileSync(join(rulesSrc, file), 'utf-8');
-    const stacks = parseStacks(content);
-    if (shouldInstall(stacks, projectTags)) {
-      fx.copyFile(join(rulesSrc, file), join(rulesDest, file));
-      installed.add(file);
-    }
-  }
-
-  // Calado em `dryRun`: `cleanFrameworkDirs()` já apagou `.claude/rules/` inteiro antes da execução real.
-  if (!fx.dryRun) {
-    for (const file of readdirSync(rulesDest).filter(f => f.endsWith('.md'))) {
-      if (!installed.has(file)) {
-        fx.remove(join(rulesDest, file));
-      }
-    }
-  }
-
-  return { installed: installed.size };
-}
+export { installRulesForStack };
 
 /** Clean-slate: removes only a framework command the stack filtered out, never one the user wrote. */
 export function installCommandsForStack(commandsSrc, commandsDest, projectTags, fx = realEffects()) {
@@ -118,10 +95,7 @@ async function installStackAwareAssets(targetPath, log) {
   log('Installing agents...');
   const agentCounts = await installAgents(targetPath, FRAMEWORK_DIR, { projectTags });
 
-  log('Installing domain agents...');
-  const domainCounts = await installDomainAgents(targetPath, FRAMEWORK_DIR, { projectTags });
-
-  return { agentCounts, domainCounts, projectTags };
+  return { agentCounts, projectTags };
 }
 
 /**
@@ -138,9 +112,9 @@ export async function updateClaudeMdAgentsBlock(claudeMdPath, agents = [], optio
 
   const list = agents.length > 0
     ? agents.map(a => `- \`${a.name}\` — ${a.title}${a.domains?.length ? ` (${a.domains.join(', ')})` : ''}`).join('\n')
-    : '_Nenhuma persona instalada — configure `project.stack` em `.morph/config/config.json` e rode `morph-spec setup-infra --reinstall`._';
+    : '_Nenhum agente instalado — rode `morph-spec setup-infra --reinstall`._';
 
-  const block = `${START}\n**Personas instaladas neste projeto** (derivado de agents.json na última instalação):\n\n${list}\n${END}`;
+  const block = `${START}\n**Agentes do Gate 3** (derivado de agents.json na última instalação):\n\n${list}\n${END}`;
   const updated = content.replace(
     new RegExp(`${START}[\\s\\S]*?${END}`),
     block
@@ -178,16 +152,10 @@ export async function setupInfra(targetPath, {
 
   if (reinstall) {
     log('setup-infra (reinstall): re-installing stack-aware assets...');
-    const { agentCounts, domainCounts } = await installStackAwareAssets(targetPath, log);
+    const { agentCounts } = await installStackAwareAssets(targetPath, log);
     await updateClaudeMdAgentsBlock(join(targetPath, '.claude', 'CLAUDE.md'), agentCounts?.agents ?? []);
     log('setup-infra (reinstall): complete.');
-    return {
-      agents: {
-        tier1: agentCounts?.tier1 ?? 0,
-        tier2: agentCounts?.tier2 ?? 0,
-        specialists: domainCounts?.specialists ?? 0,
-      },
-    };
+    return { agents: { installed: agentCounts?.installed ?? 0 } };
   }
 
   await installRequiredPlugins(log, _exec);
@@ -316,7 +284,7 @@ export async function setupInfra(targetPath, {
   const claudeDest = join(targetPath, '.claude');
 
   log('Steps 10-13: Installing stack-aware assets...');
-  const { agentCounts, domainCounts, projectTags } = await installStackAwareAssets(targetPath, log);
+  const { agentCounts, projectTags } = await installStackAwareAssets(targetPath, log);
 
   log('Step 14: Installing .claude/CLAUDE.md...');
   const runtimeClaudeMdDest = join(claudeDest, 'CLAUDE.md');
@@ -374,7 +342,9 @@ export async function setupInfra(targetPath, {
       log(`  ✓ graphify ${installed} já instalado`);
     } else {
       const { kind } = detectInstaller();
-      if (!kind) {
+      if (process.env.MORPH_NO_TOOL_INSTALL === '1') {
+        log(`  ○ graphify não instalado (MORPH_NO_TOOL_INSTALL=1). Depois: uv tool install ${GRAPHIFY_PACKAGE}==${GRAPHIFY_VERSION}`);
+      } else if (!kind) {
         log(`  ⚠ Sem uv/pipx/python — grafo indisponível. Depois: uv tool install ${GRAPHIFY_PACKAGE}==${GRAPHIFY_VERSION}`);
       } else {
         // Sem o extra [sql] os arquivos .sql são ignorados em silêncio.
@@ -382,7 +352,8 @@ export async function setupInfra(targetPath, {
         const { cmd, args } = installArgs(kind, { withSql });
         try {
           _exec(`${cmd} ${args.join(' ')}`, { stdio: 'ignore' });
-          log(`  ✓ graphify ${GRAPHIFY_VERSION}${withSql ? ' [sql]' : ''} via ${kind}`);
+          if (probe() === GRAPHIFY_VERSION) log(`  ✓ graphify ${GRAPHIFY_VERSION}${withSql ? ' [sql]' : ''} via ${kind}`);
+          else log(`  ⚠ ${kind} instalou o graphify, mas o binário não responde (nem no PATH nem no venv da ferramenta) — rode ${cmd} ${args.join(' ')} --force no seu terminal`);
         } catch {
           log(`  ⚠ Falha ao instalar o graphify via ${kind} — manualmente: ${cmd} ${args.join(' ')}`);
         }
@@ -414,11 +385,5 @@ export async function setupInfra(targetPath, {
 
   log('setup-infra: complete.');
 
-  return {
-    agents: {
-      tier1: agentCounts?.tier1 ?? 0,
-      tier2: agentCounts?.tier2 ?? 0,
-      specialists: domainCounts?.specialists ?? 0,
-    },
-  };
+  return { agents: { installed: agentCounts?.installed ?? 0 } };
 }