@polymorphism-tech/morph-spec 8.37.0 → 8.38.0

package/src/lib/graph/graph-loader.js

@@ -12,7 +12,14 @@
  */
 import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { execFileSync } from 'node:child_process';
+import {
+  graphFreshness, readRefreshRecord,
+} from '../../../framework/hooks/shared/graph-freshness.js';
+import {
+  isPrimaryTree, readRefreshLock, resolveGraphify,
+} from '../../../framework/hooks/shared/graph-refresh.js';
+import { isSecondaryWorktree, workTreeTop } from '../../../framework/hooks/shared/git-paths.js';
+import { GRAPHIFY_PACKAGE, GRAPHIFY_VERSION } from './graphify-runtime.js';
 
 /**
  * @param {string} projectPath
@@ -50,37 +57,104 @@ export function loadGraph(projectPath) {
   }
 }
 
-function readHead(projectPath) {
-  try {
-    return execFileSync('git', ['rev-parse', 'HEAD'], {
-      cwd: projectPath,
-      encoding: 'utf-8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    }).trim() || null;
-  } catch {
-    return null;
-  }
-}
-
 /**
- * O hook post-commit do graphify rebuilda em BACKGROUND: logo depois de um
- * commit o grafo ainda é o do commit anterior. Quem consome precisa saber, ou
- * conclui "ninguém usa isso" a partir de um grafo velho.
+ * O frescor do grafo, pela regra única (framework/hooks/shared/graph-freshness.js):
+ * o carimbo e o registro da última rodada contra o HEAD, e as regras do
+ * `.graphifyignore` por conteúdo. Um grafo velho diz "não existe" sobre o que
+ * o último commit trouxe — quem consome precisa saber, ou conclui "ninguém usa
+ * isso" a partir dele.
  *
  * @param {string} projectPath
- * @param {object} graph
+ * @param {object} graph - o graph.json já parseado (o carimbo sai dele)
  * @param {{_head?: (projectPath: string) => string|null}} [deps]
- * @returns {{builtAtCommit: string|null, headCommit: string|null, state: 'fresh'|'stale'|'unknown'}}
+ * @returns {{builtAtCommit: string|null, headCommit: string|null, state: 'fresh'|'stale'|'unknown', reason?: 'ignore-changed'|'rules-unknown'}}
  */
 export function getFreshness(projectPath, graph, deps = {}) {
-  const headCommit = (deps._head ?? readHead)(projectPath);
-  const builtAtCommit = graph?.built_at_commit ?? null;
-  if (!headCommit || !builtAtCommit) {
-    return { builtAtCommit, headCommit, state: 'unknown' };
+  const f = graphFreshness(projectPath, {
+    graph,
+    ...(deps._head ? { head: deps._head(projectPath) } : {}),
+  });
+  return {
+    builtAtCommit: f.built,
+    headCommit: f.head,
+    state: f.state === 'missing' ? 'unknown' : f.state,
+    ...(f.reason ? { reason: f.reason } : {}),
+  };
+}
+
+const short = (sha) => (sha ? String(sha).slice(0, 8) : '?');
+
+/**
+ * O porquê de um grafo stale, em uma linha — carimbo antigo ou regras.
+ *
+ * @param {{builtAtCommit: string|null, headCommit: string|null, reason?: string}} freshness
+ * @returns {string}
+ */
+export function staleCause(freshness) {
+  if (freshness.reason === 'ignore-changed') {
+    return 'as regras do .graphifyignore mudaram depois da extração';
+  }
+  if (freshness.reason === 'rules-unknown') {
+    return 'sem registro das regras do .graphifyignore com que o grafo foi extraído';
   }
+  return `construído em ${short(freshness.builtAtCommit)}, HEAD é ${short(freshness.headCommit)}`;
+}
+
+/**
+ * O que o refresh automático faz por esta árvore. Ele cobre só a árvore
+ * principal (`auto`); numa worktree, `running` é sempre false — um lock vivo
+ * ali seria o refresh da raiz. `last` é a última rodada registrada para esta
+ * árvore: em background, manual ou a semeadura.
+ *
+ * @param {string} projectPath
+ * @returns {{auto: boolean, running: boolean, since: string|null, pid: number|null, last: {ok: boolean, exit: number|null, head: string|null, ts: string, unavailable?: boolean, seeded?: boolean}|null}}
+ */
+export function refreshState(projectPath) {
+  const auto = isPrimaryTree(projectPath);
+  const lock = auto ? readRefreshLock(projectPath) : null;
+  const record = readRefreshRecord(projectPath);
   return {
-    builtAtCommit,
-    headCommit,
-    state: builtAtCommit === headCommit ? 'fresh' : 'stale',
+    auto,
+    running: Boolean(lock?.live),
+    since: lock?.live ? lock.since : null,
+    pid: lock?.live ? lock.pid : null,
+    last: record ? {
+      ok: record.exit === 0,
+      exit: record.exit ?? null,
+      head: record.head ?? null,
+      ts: record.at,
+      ...(record.unavailable ? { unavailable: true } : {}),
+      ...(record.seeded ? { seeded: true } : {}),
+    } : null,
   };
 }
+
+/**
+ * A frase de grafo stale — a mesma no status, no explain, no affected e no
+ * doctor, e verdadeira sobre o mecanismo: o refresh em background só cobre a
+ * raiz, disparado pelos hooks do morph-spec; a worktree só anda à mão.
+ *
+ * @param {string} projectPath
+ * @param {{builtAtCommit?: string|null, headCommit?: string|null}} [freshness]
+ * @returns {string}
+ */
+export function describeStale(projectPath, freshness = {}) {
+  const tree = workTreeTop(projectPath) ?? projectPath;
+  const state = refreshState(projectPath);
+  if (!state.auto && isSecondaryWorktree(tree)) {
+    return state.last?.seeded
+      ? `grafo semeado da raiz em ${short(state.last.head ?? freshness.builtAtCommit)}; \`morph-spec graph refresh\` atualiza esta worktree`
+      : 'o refresh automático só cobre a raiz; `morph-spec graph refresh` atualiza esta worktree';
+  }
+  if (state.running) {
+    return `refresh em background em andamento desde ${new Date(state.since).toLocaleTimeString()} — confirme no código antes de agir`;
+  }
+  // Registrado como ausente mas já de volta ao PATH: o próximo disparo roda.
+  if (state.last?.unavailable && !resolveGraphify()) {
+    return `graphify fora do PATH: o refresh automático está parado até ele voltar (uv tool install ${GRAPHIFY_PACKAGE}==${GRAPHIFY_VERSION}); depois, morph-spec graph refresh`;
+  }
+  if (state.last && !state.last.ok && state.last.head === (freshness.headCommit ?? null)) {
+    return `o último refresh falhou neste HEAD (exit ${state.last.exit ?? '?'}) e só se repete quando o HEAD andar — rode morph-spec graph refresh e leia a saída`;
+  }
+  return 'o refresh roda em background depois dos comandos git/gh/morph-spec do agente e no início da sessão; para já: morph-spec graph refresh';
+}

package/src/lib/graph/graphifyignore.js

@@ -2,30 +2,53 @@
  * Geração stack-aware do .graphifyignore (ADR-004).
  *
  * Filtrar teste não é cosmético: sem isso o god node #1 do MORPH_GHLBrain é
- * `FakeGhlToolbelt`, um dublê. Pior, os dublês criam um segundo implementador e
- * quebram o guard de "implementador único" do `dispatches_to` — a aresta que
- * atravessa a injeção de dependência cai de 109 para 1.
+ * `FakeGhlToolbelt`, um dublê. E o padrão genérico `tests/` NÃO serve em .NET:
+ * no ProspectPRO os testes vivem em `src/backend/ProspectPRO.Tests/`. Com
+ * `**\/*.Tests/` o grafo caiu de 10.450 para 7.384 nós — 30% era ruído de teste.
  *
- * E o padrão genérico `tests/` NÃO serve em .NET: no ProspectPRO os testes
- * vivem em `src/backend/ProspectPRO.Tests/`. Com `**\/*.Tests/` o grafo caiu de
- * 10.450 para 7.384 nós — 30% era ruído de teste.
+ * Mas dublê, fixture e helper de teste precisam ser ACHÁVEIS: são o que um
+ * teste novo deveria reusar, e fora do grafo `graph explain FakeX` dá
+ * not-found. Por isso o conteúdo dos projetos de teste sai e esses arquivos
+ * voltam. A forma é ditada pela regra do gitignore que o graphify 0.9.50 segue
+ * (detect.py `_is_ignored`): um `!` não reinclui nada sob um diretório já
+ * excluído. Medido num fixture: `**\/*.Tests/` + `!**\/Fakes/` não traz nada de
+ * volta; excluir o CONTEÚDO (`**\/*.Tests/**`), reincluir os diretórios
+ * (`!**\/*.Tests/**\/`) e então os helpers traz. `bin/`/`obj/` vêm DEPOIS das
+ * reinclusões — antes, a reinclusão de diretório os devolveria (`obj/` tem
+ * `.cs` gerado). No MORPH_GHLBrain: +9,6% de nós (11.591 → 12.706), 94
+ * arquivos de teste, nenhum de bin/obj.
+ *
+ * Os dublês quebram o guard de "implementador único" do `dispatches_to` do
+ * graphify (de 122 para 5 arestas no GHLBrain); o saneamento as recupera
+ * (sanitize.js `recoverDispatch`) e tira o teste dos god nodes.
  *
  * Em Next.js o problema é outro: metade dos nós vinha de JSON de configuração,
  * e os god nodes viravam `dependencies` e `compilerOptions`.
  *
  * @module graphifyignore
  */
-import { writeFileSync, existsSync } from 'node:fs';
+import { writeFileSync, existsSync, readFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import { join } from 'node:path';
 import { WORKTREE_DIR_NAMES } from '../worktree/dirs.js';
+import { ignoreRules } from '../../../framework/hooks/shared/graph-freshness.js';
 
 export const ALWAYS_IGNORED = [
   '.git/', '.morph/', 'artifacts/', ...WORKTREE_DIR_NAMES.map((d) => `${d}/`),
   'coverage/', 'graphify-out/', 'dist/', 'out/',
 ];
 
+const TEST_PROJECTS = ['**/*.Tests', '**/*Tests', '**/*.Test'];
+const TEST_HELPER_DIRS = ['TestDoubles', 'Fakes', 'Stubs', 'Mocks', 'Fixtures', 'Helpers', 'Builders'];
+const TEST_HELPER_FILES = ['*Fixture.cs', '*Fixtures.cs', 'Fake*.cs', 'Stub*.cs', '*Stub.cs'];
+const DOTNET_BUILD_OUTPUT = ['bin/', 'obj/', 'TestResults/'];
+
 const DOTNET_IGNORED = [
-  '**/*.Tests/', '**/*Tests/', '**/*.Test/', 'bin/', 'obj/', 'TestResults/',
+  ...TEST_PROJECTS.map((p) => `${p}/**`),
+  ...TEST_PROJECTS.map((p) => `!${p}/**/`),
+  ...TEST_HELPER_DIRS.map((d) => `!**/${d}/**`),
+  ...TEST_HELPER_FILES.map((f) => `!**/${f}`),
+  ...DOTNET_BUILD_OUTPUT,
 ];
 
 const WEB_IGNORED = [
@@ -35,31 +58,35 @@ const WEB_IGNORED = [
   '/next.config.js', '/next.config.mjs', '/tailwind.config.js', '/tailwind.config.ts',
 ];
 
+const HEADER = '# Gerado por morph-spec (ADR-004). Editável: um arquivo editado nunca é sobrescrito.';
+
+/**
+ * O que a versão anterior gerava — os testes .NET inteiros fora. Só existe
+ * para reconhecer um arquivo que ninguém editou e trocá-lo pelo atual.
+ */
+const PREVIOUS = {
+  header: '# Gerado por morph-spec (ADR-004). Editável: o CLI não sobrescreve.',
+  dotnetTitle: '# .NET — testes em qualquer nível (tests/ genérico não serve)',
+  dotnet: ['**/*.Tests/', '**/*Tests/', '**/*.Test/', ...DOTNET_BUILD_OUTPUT],
+};
+
 const DOTNET_TAGS = new Set(['dotnet', 'aspnet']);
 const WEB_TAGS = new Set([
   'nextjs', 'next', 'next.js', 'react', 'vue', 'nodejs', 'nodejs-cli', 'node-cli',
 ]);
 
-/**
- * @param {string[]} [projectTags] saída de `getProjectTags(config)` — stack
- *   splitado por `-`/`+` mais as integrations
- * @returns {string} conteúdo completo do .graphifyignore
- */
-export function buildGraphifyignore(projectTags = []) {
+const hasDotnetTag = (tags) => [...new Set(tags)].some((t) => DOTNET_TAGS.has(t));
+
+function render(projectTags, { header, dotnetTitle, dotnet }) {
   const tags = new Set(projectTags);
-  const hasDotnet = [...tags].some((t) => DOTNET_TAGS.has(t));
   const hasWeb = [...tags].some((t) => WEB_TAGS.has(t));
 
   const sections = [
-    ['# Gerado por morph-spec (ADR-004). Editável: o CLI não sobrescreve.', ''],
+    [header, ''],
     ['# Sempre', ...ALWAYS_IGNORED],
   ];
-  if (hasDotnet) {
-    sections.push(['', '# .NET — testes em qualquer nível (tests/ genérico não serve)', ...DOTNET_IGNORED]);
-  }
-  if (hasWeb) {
-    sections.push(['', '# Web — dependências e JSON de configuração de raiz', ...WEB_IGNORED]);
-  }
+  if (hasDotnetTag(tags)) sections.push(['', dotnetTitle, ...dotnet]);
+  if (hasWeb) sections.push(['', '# Web — dependências e JSON de configuração de raiz', ...WEB_IGNORED]);
 
   const seen = new Set();
   const lines = [];
@@ -73,15 +100,105 @@ export function buildGraphifyignore(projectTags = []) {
 }
 
 /**
- * Escreve o .graphifyignore. Arquivo já existente é do usuário: não é tocado.
+ * @param {string[]} [projectTags] saída de `getProjectTags(config)` — stack
+ *   splitado por `-`/`+` mais as integrations
+ * @returns {string} conteúdo completo do .graphifyignore
+ */
+export function buildGraphifyignore(projectTags = []) {
+  return render(projectTags, {
+    header: HEADER,
+    dotnetTitle: '# .NET — conteúdo dos projetos de teste fora; dublês, fixtures e helpers dentro',
+    dotnet: DOTNET_IGNORED,
+  });
+}
+
+const normalize = (text) => String(text).replace(/^/, '').replace(/\r\n/g, '\n');
+
+/**
+ * Escreve ou migra o .graphifyignore.
+ *
+ *   ausente                                → escreve o atual
+ *   idêntico ao que a versão anterior
+ *   gerava para as mesmas tags             → troca pelo atual (`migrated`) —
+ *                                            só se as REGRAS mudam (em
+ *                                            projeto sem .NET a diferença é
+ *                                            só o cabeçalho, e reescrever
+ *                                            seria um diff à toa num arquivo
+ *                                            versionado)
+ *   qualquer outra coisa                   → é do usuário: não toca, e em
+ *                                            projeto .NET que ainda exclui os
+ *                                            testes inteiros devolve em
+ *                                            `outdated` a troca a fazer
  *
  * @param {string} projectPath
  * @param {string[]} [projectTags]
- * @returns {{written: boolean, path: string}}
+ * @param {{fx?: {writeFile: (path: string, content: string) => void}}} [opts]
+ *   coletor de efeitos do `update` — com ele, o `--dry-run` prevê a escrita
+ * @returns {{written: boolean, migrated?: boolean, outdated?: {remove: string[], add: string[]}, path: string}}
  */
-export function writeGraphifyignore(projectPath, projectTags = []) {
+export function writeGraphifyignore(projectPath, projectTags = [], { fx } = {}) {
   const path = join(projectPath, '.graphifyignore');
-  if (existsSync(path)) return { written: false, path };
-  writeFileSync(path, buildGraphifyignore(projectTags), 'utf-8');
-  return { written: true, path };
+  const current = buildGraphifyignore(projectTags);
+  const write = () => (fx ? fx.writeFile(path, current) : writeFileSync(path, current, 'utf-8'));
+
+  if (!existsSync(path)) {
+    write();
+    return { written: true, path };
+  }
+
+  let existing;
+  try {
+    existing = normalize(readFileSync(path, 'utf-8'));
+  } catch {
+    return { written: false, path };
+  }
+  if (existing === current) return { written: false, path };
+  if (existing === render(projectTags, PREVIOUS)) {
+    // A régua é a mesma do frescor do grafo (graph-freshness.js): o que o
+    // graphify lê, sem cabeçalho nem comentário.
+    if (ignoreRules(existing) === ignoreRules(current)) return { written: false, path };
+    write();
+    return { written: true, migrated: true, path };
+  }
+
+  // Acrescentar não basta: enquanto `**/*.Tests/` excluir o DIRETÓRIO, nenhum
+  // `!` reinclui o que está dentro dele.
+  const lines = new Set(existing.split('\n').map((l) => l.trim()));
+  const remove = PREVIOUS.dotnet.slice(0, 3).filter((l) => lines.has(l));
+  if (hasDotnetTag(projectTags) && remove.length) {
+    const add = DOTNET_IGNORED.filter((l) => !DOTNET_BUILD_OUTPUT.includes(l) && !lines.has(l));
+    return { written: false, outdated: { remove, add }, path };
+  }
+  return { written: false, path };
+}
+
+/**
+ * A frase que todo chamador imprime para um `outdated` — uma só.
+ *
+ * @param {{remove: string[], add: string[]}} outdated
+ * @returns {string}
+ */
+export function describeOutdatedIgnore(outdated) {
+  return `.graphifyignore editado mantém os testes .NET inteiros fora do grafo ` +
+    `(dublês e fixtures dão not-found). Troque ${outdated.remove.join(' ')} por, nesta ordem e ` +
+    `antes de bin/ e obj/: ${outdated.add.join(' ')} — depois, morph-spec graph refresh`;
+}
+
+/**
+ * O `.graphifyignore` é versionado? Então uma migração só chega às worktrees
+ * e ao resto do time depois de commitada — cada checkout lê o seu. Fail-open:
+ * sem git, false.
+ *
+ * @param {string} projectPath
+ * @returns {boolean}
+ */
+export function graphifyignoreTracked(projectPath) {
+  try {
+    execFileSync('git', ['ls-files', '--error-unmatch', '--', '.graphifyignore'], {
+      cwd: projectPath, stdio: 'ignore', windowsHide: true, timeout: 10000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
 }

package/src/lib/graph/sanitize.js

@@ -41,13 +41,25 @@ const LANG_BY_EXT = {
 };
 
 /**
- * Projeto de teste em qualquer nível. Três formas, e só três, porque
- * `[^/]*[Tt]ests?/` genérico também casaria `latest/` e `contests/`:
+ * Código de teste — o predicado ÚNICO de "isto é teste" do grafo e do
+ * validador de reuso. Pasta de projeto de teste em qualquer nível, em três
+ * formas, e só três, porque `[^/]*[Tt]ests?/` genérico também casaria
+ * `latest/` e `contests/`:
  *   - o segmento inteiro é `test`/`tests` (qualquer caixa)
  *   - termina em `.Test`/`.Tests` — a convenção .NET (ProspectPRO.Tests/)
  *   - termina em `Test`/`Tests` com T maiúsculo — PascalCase (AlvoTests/)
+ * mais o teste colocado ao lado do código em JS/TS: `__tests__/`,
+ * `*.test.*` e `*.spec.*`.
  */
-const TEST_PATH = /(^|\/)(?:[Tt]ests?|[^/]*\.[Tt]ests?|[^/]*[a-z0-9_]Tests?)\//;
+const TEST_PATH = /(^|\/)__tests__\/|\.(test|spec)\.[jt]sx?$|(^|\/)(?:[Tt]ests?|[^/]*\.[Tt]ests?|[^/]*[a-z0-9_]Tests?)\//;
+
+/**
+ * @param {string} sourceFile
+ * @returns {boolean} o arquivo é código de teste (dublê, fixture ou o teste em si)
+ */
+export function isTestPath(sourceFile) {
+  return TEST_PATH.test(String(sourceFile || '').replace(/\\/g, '/'));
+}
 
 /**
  * @param {string} sourceFile
@@ -75,6 +87,7 @@ const baseOf = (norm) => norm.replace(/\(\s*\)$/, '');
  * @property {Map<string, {real: object[], stub: object[]}>} byLabel
  * @property {Map<string, object[]>} byBaseLabel label sem `()` -> nós reais
  * @property {Map<string, string>} coalesce stubId -> id do nó real
+ * @property {object[]} recovered `dispatches_to` recuperados (ver recoverDispatch)
  */
 
 /**
@@ -114,7 +127,94 @@ export function buildIndex(graph) {
     else byBaseLabel.set(base, [...entry.real]);
   }
 
-  return { byId, byLabel, byBaseLabel, coalesce };
+  const index = { byId, byLabel, byBaseLabel, coalesce, recovered: [] };
+  index.recovered = recoverDispatch(index, graph);
+  return index;
+}
+
+const isCsharp = (node) => Boolean(node?.source_file) && /\.cs$/i.test(node.source_file);
+
+/** Nome do método sem o ponto inicial e sem a assinatura, como o graphify casa. */
+const methodName = (node) => String(node.label ?? '').trim().replace(/^\./, '').split('(')[0];
+
+/**
+ * `dispatches_to` que o graphify deixou de emitir por causa de um dublê de
+ * teste. O resolvedor dele (graphify/csharp_dispatch.py) liga o método da
+ * interface ao da implementação só quando há EXATAMENTE um implementador — e
+ * um `FakeX : IX` no grafo é o segundo. Este é o mesmo algoritmo, com o guard
+ * contando só implementadores de produção. Medido no MORPH_GHLBrain: com os
+ * dublês no grafo o graphify cai de 122 para 5 arestas, e esta função devolve
+ * as 122 do grafo sem testes, nenhuma a mais.
+ *
+ * Aditivo: um par que o graphify já emitiu não é repetido.
+ *
+ * @param {GraphIndex} index
+ * @param {{links?: object[]}} graph
+ * @returns {object[]} arestas sintéticas, marcadas `_recovered: true`
+ */
+function recoverDispatch(index, graph) {
+  const implementers = new Map();
+  const methodsOf = new Map();
+  const existing = new Set();
+
+  for (const link of graph.links ?? []) {
+    if (link.relation === 'dispatches_to') {
+      existing.add(`${link.source}|${link.target}`);
+    } else if (link.relation === 'implements') {
+      const impl = index.byId.get(link.source);
+      if (!impl || isTestPath(impl.source_file)) continue;
+      const iface = resolveEdgeTarget(index, link).id;
+      if (!iface) continue;
+      if (!implementers.has(iface)) implementers.set(iface, new Set());
+      implementers.get(iface).add(link.source);
+    } else if (link.relation === 'method') {
+      const method = index.byId.get(link.target);
+      if (!isCsharp(method)) continue;
+      const name = methodName(method);
+      if (!name) continue;
+      if (!methodsOf.has(link.source)) methodsOf.set(link.source, new Map());
+      const byName = methodsOf.get(link.source);
+      if (!byName.has(name)) byName.set(name, new Set());
+      byName.get(name).add(link.target);
+    }
+  }
+
+  const recovered = [];
+  for (const [ifaceId, impls] of implementers) {
+    if (impls.size !== 1) continue;
+    const [implId] = impls;
+    const impl = index.byId.get(implId);
+    if (!isCsharp(index.byId.get(ifaceId)) || !isCsharp(impl)) continue;
+    const implMethods = methodsOf.get(implId) ?? new Map();
+    for (const [name, declared] of methodsOf.get(ifaceId) ?? new Map()) {
+      const candidates = implMethods.get(name);
+      if (declared.size !== 1 || candidates?.size !== 1) continue;
+      const [source] = declared;
+      const [target] = candidates;
+      const key = `${source}|${target}`;
+      if (source === target || existing.has(key)) continue;
+      existing.add(key);
+      recovered.push({
+        source, target, relation: 'dispatches_to', context: 'call',
+        source_file: impl.source_file, source_location: impl.source_location ?? '',
+        _recovered: true,
+      });
+    }
+  }
+  return recovered;
+}
+
+/**
+ * As arestas do grafo mais as recuperadas pelo saneamento — o conjunto que
+ * todo consumidor deve percorrer.
+ *
+ * @param {GraphIndex} index
+ * @param {{links?: object[]}} graph
+ * @returns {object[]}
+ */
+export function linksOf(index, graph) {
+  const own = graph.links ?? [];
+  return index.recovered?.length ? own.concat(index.recovered) : own;
 }
 
 /**
@@ -201,20 +301,21 @@ export function resolveLabel(index, label) {
  * @param {{links: object[]}} graph
  * @param {string} id
  * @param {{prod?: boolean, excludeInheritance?: boolean}} [opts]
- * @returns {Array<{id: string, label: string, source_file: string, source_location: string, relation: string}>}
+ * @returns {Array<{id: string, label: string, source_file: string, source_location: string, relation: string, test: boolean}>}
  */
 export function affected(index, graph, id, opts = {}) {
   const seen = new Set();
   const out = [];
 
-  for (const link of graph.links ?? []) {
+  for (const link of linksOf(index, graph)) {
     if (!USE_RELATIONS.has(link.relation)) continue;
     if (opts.excludeInheritance && INHERITANCE_RELATIONS.has(link.relation)) continue;
     if (resolveEdgeTarget(index, link).id !== id) continue;
 
     const source = index.byId.get(link.source);
     if (!source || !source.source_file) continue;
-    if (opts.prod && TEST_PATH.test(source.source_file)) continue;
+    const test = isTestPath(source.source_file);
+    if (opts.prod && test) continue;
 
     const key = `${source.id}|${link.relation}`;
     if (seen.has(key)) continue;
@@ -226,6 +327,7 @@ export function affected(index, graph, id, opts = {}) {
       source_file: source.source_file,
       source_location: source.source_location ?? '',
       relation: link.relation,
+      test,
     });
   }
 
@@ -234,7 +336,8 @@ export function affected(index, graph, id, opts = {}) {
 
 /**
  * Vizinhança de um nó, para `graph explain`. Cada aresta carrega a procedência
- * (`via`), então dá para ver o que o saneamento recuperou.
+ * (`via`), então dá para ver o que o saneamento recuperou, e `test` diz se a
+ * outra ponta é código de teste.
  *
  * @param {GraphIndex} index
  * @param {{links: object[]}} graph
@@ -244,8 +347,9 @@ export function neighborhood(index, graph, id) {
   const incoming = [];
   const outgoing = [];
 
-  for (const link of graph.links ?? []) {
+  for (const link of linksOf(index, graph)) {
     const resolved = resolveEdgeTarget(index, link);
+    const via = link._recovered ? 'recovered-dispatch' : resolved.kind;
 
     if (resolved.id === id) {
       const source = index.byId.get(link.source);
@@ -256,7 +360,8 @@ export function neighborhood(index, graph, id) {
           relation: link.relation,
           source_file: link.source_file || source.source_file,
           source_location: link.source_location || source.source_location || '',
-          via: resolved.kind,
+          via,
+          test: isTestPath(source.source_file),
         });
       }
     }
@@ -270,7 +375,8 @@ export function neighborhood(index, graph, id) {
           relation: link.relation,
           source_file: link.source_file || target.source_file,
           source_location: link.source_location || '',
-          via: resolved.kind,
+          via,
+          test: isTestPath(target.source_file),
         });
       }
     }