@payconductor/houndsman 0.14.0 → 0.16.0

package/src/core/severity.ts

@@ -0,0 +1,245 @@
+/**
+ * Severidade determinística (biblioteca) — a regra manda, não a opinião do watchdog.
+ *
+ * Finding de regra (`basis: "rule"`) usa a severidade declarada em `Rule.severity`;
+ * finding emergente (`Lógica:`/`Domínio:`) usa a tabela fixa de `impactClass`. O valor
+ * emitido só prevalece quando não há como resolver (paráfrase sem casamento, relatório
+ * legado sem `impactClass`) — fail-open. Toda divergência é contabilizada para o
+ * finalize avisar e para o `compare` provar a estabilidade entre runs.
+ */
+
+import { type Finding, inferBasis, type WatchdogReport } from "./report-builder";
+import { type Rule, type Severity, severityRank } from "./types";
+
+/** Classe de impacto de um finding emergente — define a severidade fora de regra. */
+export type ImpactClass = "flow-break" | "contract-drift" | "degradation" | "cosmetic";
+
+/** Classes válidas, da mais para a menos grave. */
+export const IMPACT_CLASSES: readonly ImpactClass[] = [
+	"flow-break",
+	"contract-drift",
+	"degradation",
+	"cosmetic",
+];
+
+/** Tabela fixa `impactClass` → severidade. */
+export const SEVERITY_BY_IMPACT: Record<ImpactClass, Severity> = {
+	"flow-break": "blocking",
+	"contract-drift": "attention",
+	degradation: "suggestion",
+	cosmetic: "nit",
+};
+
+const IMPACT_SET = new Set<string>(IMPACT_CLASSES);
+
+/** Tamanho mínimo para casar uma regra com o trecho citado pelo watchdog. */
+const MIN_FRAGMENT_CHARS = 24;
+
+/** `true` quando `value` é uma classe de impacto conhecida. */
+export function isImpactClass(value: unknown): value is ImpactClass {
+	return typeof value === "string" && IMPACT_SET.has(value);
+}
+
+/**
+ * Texto canônico da regra para casar `findings[].rule` com `rules[].text`.
+ *
+ * O brief imprime `- ❌ **blocking** — Promover: …`; o watchdog às vezes copia a
+ * linha inteira, às vezes só o trecho. A normalização remove markdown, emoji,
+ * bullet e o prefixo de severidade antes de comparar.
+ */
+export function normalizeRuleText(text: string): string {
+	return text
+		.normalize("NFC")
+		.replace(/[`*_]/g, "")
+		.replace(/\p{Extended_Pictographic}|\uFE0F/gu, "")
+		.replace(/\s+/g, " ")
+		.trim()
+		.toLowerCase()
+		.replace(/^[-•]\s*/u, "")
+		.replace(/^(blocking|attention|suggestion|nit)\s*[—–-]\s*/u, "")
+		.replace(/[.:;]+$/u, "")
+		.trim();
+}
+
+/** Regra declarada correspondente a um texto de finding. */
+export type DeclaredSeverity = { rule: Rule; severity: Severity };
+
+/**
+ * Resolve a regra declarada que corresponde ao texto reportado.
+ *
+ * Exato primeiro; depois contenção (o modelo citou a regra inteira ou um trecho
+ * com pelo menos `MIN_FRAGMENT_CHARS`). Empate entre watchdogs fica com a regra
+ * mais grave — determinístico e coerente com o dedupe.
+ */
+export function resolveDeclaredSeverity(
+	ruleText: string,
+	rules: readonly Rule[],
+): DeclaredSeverity | null {
+	const needle = normalizeRuleText(ruleText);
+	if (!needle) return null;
+
+	const candidates = rules.map((rule) => ({
+		rule,
+		text: normalizeRuleText(rule.text),
+	}));
+	const exact = candidates.filter((item) => item.text === needle);
+	const matches =
+		exact.length > 0
+			? exact
+			: candidates.filter((item) => isFragment(needle, item.text));
+	if (matches.length === 0) return null;
+
+	let best = matches[0].rule;
+	for (const item of matches) {
+		if (severityRank(item.rule.severity) < severityRank(best.severity)) {
+			best = item.rule;
+		}
+	}
+	return { rule: best, severity: best.severity };
+}
+
+/** Contenção nos dois sentidos, exigindo fragmento longo o bastante. */
+function isFragment(a: string, b: string): boolean {
+	if (a.length < MIN_FRAGMENT_CHARS || b.length < MIN_FRAGMENT_CHARS) return false;
+	return a.includes(b) || b.includes(a);
+}
+
+/** De onde veio a severidade aplicada. */
+export type SeveritySource = "rule" | "impact";
+
+/** Divergência entre o valor emitido e o resolvido (para aviso no finalize). */
+export type SeverityDivergence = {
+	watchdogId: string;
+	file: string;
+	rule: string;
+	emitted: Severity;
+	resolved: Severity;
+	source: SeveritySource;
+};
+
+/** Resultado da ancoragem sobre os relatórios de uma run. */
+export type SeverityAnchoring = {
+	reports: WatchdogReport[];
+	/** Findings de regra cujo texto casou com uma regra declarada. */
+	anchored: number;
+	/** Findings emergentes com `impactClass` válido. */
+	classified: number;
+	/** Findings de regra sem casamento (severidade emitida mantida). */
+	unmatched: number;
+	diverged: SeverityDivergence[];
+};
+
+type Resolution = { severity: Severity; source: SeveritySource };
+
+/** Severidade declarada pelo motor (null = manter a emitida). */
+function resolveSeverity(finding: Finding, rules: readonly Rule[]): Resolution | null {
+	if ((finding.basis ?? inferBasis(finding.rule)) !== "rule") {
+		const impact = finding.impactClass;
+		if (!isImpactClass(impact)) return null;
+		return { severity: SEVERITY_BY_IMPACT[impact], source: "impact" };
+	}
+	const declared = resolveDeclaredSeverity(finding.rule, rules);
+	return declared ? { severity: declared.severity, source: "rule" } : null;
+}
+
+/**
+ * Gate de prova: fora de regra, `blocking` exige gatilho + evidência.
+ *
+ * `normalizeFinding` já aplica isso na leitura do relatório; a checagem aqui
+ * cobre chamadas com findings construídos em memória (harness/testes).
+ */
+function provenSeverity(finding: Finding, resolution: Resolution): Severity {
+	if (resolution.source !== "impact" || resolution.severity !== "blocking") {
+		return resolution.severity;
+	}
+	const proven = Boolean(finding.scenario?.trim() && finding.evidence?.trim());
+	return proven ? "blocking" : "attention";
+}
+
+/**
+ * Ancora a severidade de todos os relatórios (função pura — devolve novos objetos).
+ * `rules` é a união das regras de todos os watchdogs ativos (inclui o piso do `general`).
+ */
+export function anchorReports(
+	reports: readonly WatchdogReport[],
+	rules: readonly Rule[],
+): SeverityAnchoring {
+	const anchoring: SeverityAnchoring = {
+		reports: [],
+		anchored: 0,
+		classified: 0,
+		unmatched: 0,
+		diverged: [],
+	};
+
+	for (const report of reports) {
+		const findings = report.findings.map((finding) => {
+			const resolution = resolveSeverity(finding, rules);
+			if (!resolution) {
+				if ((finding.basis ?? inferBasis(finding.rule)) === "rule") {
+					anchoring.unmatched++;
+				}
+				return finding;
+			}
+
+			if (resolution.source === "rule") anchoring.anchored++;
+			else anchoring.classified++;
+
+			const severity = provenSeverity(finding, resolution);
+			if (severity === finding.severity) return finding;
+
+			anchoring.diverged.push({
+				watchdogId: report.watchdogId,
+				file: finding.file,
+				rule: finding.rule,
+				emitted: finding.severity,
+				resolved: severity,
+				source: resolution.source,
+			});
+			return { ...finding, severity };
+		});
+		anchoring.reports.push({ ...report, findings });
+	}
+
+	return anchoring;
+}
+
+/** Texto curto do finding nas mensagens do finalize. */
+function describe(divergence: SeverityDivergence, max = 72): string {
+	const text =
+		divergence.rule.length <= max
+			? divergence.rule
+			: `${divergence.rule.slice(0, max - 1).trimEnd()}…`;
+	return `· ${divergence.watchdogId} \`${divergence.file}\` — ${divergence.emitted} → ${divergence.resolved} (${divergence.source === "rule" ? "regra" : "impacto"}): ${text}`;
+}
+
+/**
+ * Mensagens de resumo da ancoragem (vazias quando nada foi resolvido nem corrigido).
+ * `limit` controla quantos exemplos de divergência aparecem.
+ */
+export function severityAnchoringMessages(
+	anchoring: SeverityAnchoring,
+	limit = 3,
+): string[] {
+	const messages: string[] = [];
+	if (anchoring.anchored > 0 || anchoring.classified > 0) {
+		const parts = [
+			anchoring.anchored > 0 ? `${anchoring.anchored} pela regra` : "",
+			anchoring.classified > 0 ? `${anchoring.classified} pelo impacto` : "",
+		].filter(Boolean);
+		const corrected =
+			anchoring.diverged.length > 0
+				? ` — ${anchoring.diverged.length} divergência(s) corrigida(s).`
+				: ".";
+		messages.push(`Severidade: ${parts.join(", ")}${corrected}`);
+	}
+	for (const divergence of anchoring.diverged.slice(0, limit)) {
+		messages.push(describe(divergence));
+	}
+	if (anchoring.unmatched > 0) {
+		messages.push(
+			`Severidade: ${anchoring.unmatched} finding(s) de regra sem casamento com as regras declaradas (valor emitido mantido).`,
+		);
+	}
+	return messages;
+}

package/src/core/storage/types.ts

@@ -122,6 +122,7 @@ export type ArtifactKind =
 	| "hunt"
 	| "prepare"
 	| "compare"
+	| "golden"
 	| "other";
 
 /** Artefato persistido de uma review. */

package/src/index.ts

@@ -214,6 +214,9 @@ export {
 } from "./core/findings-state";
 export type { GitResult, GitRunner } from "./core/git-runner";
 export type {
+	BusinessDecision,
+	CheckCoverage,
+	CheckVerdict,
 	HuntEvent,
 	HuntReport,
 	HuntRunnerOptions,
@@ -230,32 +233,51 @@ export type {
 	MakiRunRequest,
 	MakiRunResult,
 	MakiUsage,
+	ReviewCheck,
+	ReviewRule,
+	RuleCheck,
 } from "./core/hunt";
 export {
+	briefRules,
+	businessScore,
+	chooseBusinessSummary,
+	expectedReviewItems,
 	extractJsonObject,
 	HuntRunner,
 	houndsmanKeyEnvFor,
 	installMaki,
 	MAKI_API_KEY_ENV,
 	MAKI_DISALLOWED_TOOLS,
+	MAKI_REVIEW_SYSTEM_PROMPT,
 	makiArgs,
 	makiCurrentFile,
 	makiInstallDir,
 	makiSourceLabel,
 	makiToolsRoot,
 	mapPool,
+	mergeFindings,
+	mergeRuleChecks,
 	metricsFrom,
+	missingReviewItems,
+	missingRuleChecks,
 	parseMakiOutput,
+	parseReviewChecks,
+	parseRuleChecks,
 	probeMakiVersion,
 	readMakiInstall,
+	renderChecklistSuffix,
 	renderHuntPrompt,
+	renderResumeSuffix,
 	renderRetrySuffix,
 	requireMakiBinary,
 	requireMakiModel,
 	resolveMakiBinary,
 	resolveMakiModel,
 	SpawnMakiRunner,
+	summarizeChecks,
+	summarizeRuleChecks,
 	uninstallMaki,
+	withInferredRule,
 } from "./core/hunt";
 export {
 	CORE_DIR,

package/src/skill/OUTPUT-FORMAT.md

@@ -37,6 +37,7 @@ staging global da review:
       "evidence": "import { db } from '../db'",
       "scenario": "request autenticada em /orders executa a query na rota",
       "impact": "acoplamento e bypass das regras do service",
+      "impactClass": "flow-break",
       "confidence": 0.9,
       "basis": "logic"
     }
@@ -61,11 +62,26 @@ staging global da review:
 | `findings[].evidence` | string | — | Trecho que comprova o achado |
 | `findings[].scenario` | string | — | Gatilho concreto que expõe o gap (ex.: "renovação de assinatura Pix sem split") |
 | `findings[].impact` | string | — | Consequência observável (ex.: "cobrança recriada sem o split configurado") |
+| `findings[].impactClass` | `"flow-break" \| "contract-drift" \| "degradation" \| "cosmetic"` | emergente | Classe de impacto que define a severidade fora de regra |
 | `findings[].confidence` | number | — | Confiança do revisor (0–1) |
 | `findings[].basis` | `"rule" \| "logic" \| "domain"` | — | Origem do achado; inferida pelo prefixo `Lógica:`/`Domínio:` |
 
 ## Severidade
 
+A severidade é **derivada**, não escolhida pelo watchdog:
+
+| Origem do finding | Fonte da severidade |
+|---|---|
+| Regra do brief (`rule` copiada) | `severity` **declarada na regra** — outro valor é ignorado e corrigido pelo motor |
+| Emergente (`Lógica:`/`Domínio:`) | `impactClass`, pela tabela abaixo |
+
+| `impactClass` | Quando usar | Severidade |
+|---|---|---|
+| `flow-break` | o caminho não completa (criação/renovação/cancelamento) ou a capacidade declarada não é honrada | `blocking` (exige `scenario` + `evidence`) |
+| `contract-drift` | contrato, identificador ou estado divergente — mas o fluxo completa | `attention` |
+| `degradation` | funciona, mas com borda, erro, retry ou idempotência frágil | `suggestion` |
+| `cosmetic` | clareza, nome, detalhe cosmético | `nit` |
+
 | Severidade | Emoji | Bloqueia merge? |
 |---|---|---|
 | `blocking` | ❌ | Sim |
@@ -73,6 +89,9 @@ staging global da review:
 | `suggestion` | 💡 | Não |
 | `nit` | 🔎 | Não (detalhe/observação) |
 
+> Sem `impactClass` (relatório antigo), o motor mantém o valor emitido em `severity`.
+> Conflito de severidade numa mesma regra entre reviews deixa de existir: a regra é a fonte.
+
 ## Regras
 
 - Sem achados → `"findings": []` (arquivo **obrigatório**).
@@ -109,7 +128,7 @@ Demonstre o gap em três partes:
 
 **Severidade:** fora de regra, `blocking` só é aceito com `scenario` **e** `evidence`. Sem os
 dois, o motor rebaixa para `attention` (e registra um aviso). Regras explícitas mantêm a
-severidade declarada pelo watchdog.
+severidade declarada **na regra**.
 
 Os demais watchdogs podem usar os mesmos prefixos apenas quando declararem
 `allowEmergentFindings: true`.

package/src/skill/README.md

@@ -67,6 +67,7 @@ O CLI só substitui o despacho manual dos subagentes por processos maki headless
 | `houndsman --finalize` | Passo 3 — gravar a triagem e o resumo final (`--pr <n>` reusa o worktree) |
 | `houndsman hunt [--pr <n>]` | Harness local opcional (maki): prepare → watchdogs → finalize |
 | `houndsman compare` | Compara duas runs/variantes (`--list`, `--a`, `--b` ou dois slugs) |
+| `houndsman golden` | Avalia runs contra um golden set de defeitos (`recall`/`precisão`) |
 | `houndsman hunt install` | Baixa o maki fixado para `<HOUNDSMAN_HOME>/tools/maki` |
 | `houndsman worktree <ação>` | `list`/`add`/`remove`/`prune`/`path` dos worktrees |
 | `houndsman watchdog <id>` | Contexto de um watchdog (`--json`, `--rules`) |

package/src/skill/hunt.md

@@ -22,6 +22,66 @@ Os dois modos produzem os mesmos artefatos, usam o mesmo staging e o mesmo ciclo
 > maki e despacha outro harness. Siga os passos 0–3 normalmente; o comando CLI é para quem
 > quer rodar tudo no terminal.
 
+### Harness local (CLI) — profundidade por checklist
+
+`houndsman hunt` usa o mesmo `prepare`/`finalize`, mas cada watchdog roda headless. Para não
+trocar profundidade por velocidade:
+
+- o **`general` roda em três papéis separados** (sessões distintas): (1) **fluxo** — caça
+  achados sem devolver `checks`/`rules`; (2) **bookkeeping** — tarefa estreita, só vereditos
+  com `at` comprovado; (3) **adversarial** — sessão nova, com os achados já cobertos como
+  contexto, atacando as cinco classes (credencial/estado, capacidade, identificador,
+  idempotência, contrato). Antes, um único JSON de 60 KB misturava tudo e o revisor entregava
+  poucos achados com checklist “ok” sem lastro;
+- nos demais watchdogs, o prompt exige **uma verificação por fluxo/invariante** (`checks`:
+  `ok`/`gap`/`n/a` + `arquivo:linha`) e **uma por regra numerada** (`rules`);
+- **`n/a` não é cobertura**: só conta como verificado o `ok`/`gap` cujo `at` resolve para um
+  arquivo existente e uma linha dentro dele (e, quando o arquivo não está na raiz, não conta);
+- se a primeira resposta não cobrir o checklist, o harness **retoma a sessão** (`--resume`) e
+  pede só os vereditos pendentes; os achados das passadas são **unidos** (dedupe por
+  arquivo+linha+regra, maior severidade vence);
+- o prompt do `general` só pede o `businessSummary` quando o prepare **não** trouxe um modelo
+  da IA (gerar um resumo que seria rejeitado custava atenção do revisor);
+- o orçamento de exploração cresce com o tamanho do domínio (piso 6/10, teto 14/24 leituras);
+- a saída do maki concatena **todas** as mensagens do agente; o parser procura o último JSON
+  válido (bloco cercado ou objeto balanceado), não o primeiro `{`;
+- retry de saída inválida **retoma a mesma sessão** enviando só o schema — não refaz a
+  exploração inteira; e o system prompt do harness prioriza profundidade sobre economia de
+  tool calls;
+- `hunt-report.json` traz `rules`/`checks { expected, verified, missing, notApplicable, gaps }`,
+  `coverage` (`reviewed`/`skipped`/`undeclared`), o custo de cada passada extra (`checklist`,
+  `secondOpinion`) e a decisão sobre o modelo de intenção por watchdog. Desligue com
+  `--no-checklist`/`--no-second-opinion` (ou `hunt.checklist`/`hunt.secondOpinion: false`).
+
+### Golden set — medir em vez de contar
+
+Contagem de findings não mede profundidade: variantes diferentes amostram pontos diferentes do
+mesmo diff. O golden set **não gera** achados nem julga intenção — é uma lista de defeitos que
+você já confirmou no código (âncora), usada para dar nota a uma execução:
+
+- **recall** = quantos defeitos congelados a run encontrou;
+- **precisão** = quanto do que a run reportou cai num defeito congelado (o resto pode ser achado
+  legítimo ainda não triado — o relatório avisa);
+- **faltaram / fora do golden** = onde melhorar o brief/harness e o que ainda falta triar.
+
+```bash
+houndsman golden .houndsman/golden/<pr>.json              # todas as variantes da branch
+houndsman golden .houndsman/golden/<pr>.json --variant x  # uma variante
+```
+
+- formato: `{ "version": 1, "commit": "abc1234", "expected": [{ "id", "file", "line",
+  "tolerance", "match", "severity", "note" }] }`;
+- cada expectativa é uma **âncora** (arquivo + faixa de linha + trecho), nunca um fingerprint;
+  um finding comprova no máximo um defeito;
+- o `commit` é a referência do congelamento. Run que revisou **outro commit** é avaliada
+  normalmente, mas o relatório abre com **aviso** de commit divergente (não é erro): as linhas
+  podem ter se deslocado e a “falta” pode ser drift, não perda de profundidade — revalide o
+  golden antes de concluir;
+- `.houndsman/golden/` é massa local de avaliação (fica no `.gitignore` da camada), não
+  configuração do projeto;
+- saída gravada como `golden-<slug>.md|json` na run avaliada. Use para comparar
+  prompts/harness na **mesma** PR.
+
 ## Alvo da revisão
 
 Traduza o pedido do usuário para flags **antes** de começar:

package/src/skill/train.md

@@ -147,6 +147,9 @@ Cada informação tem o seu campo — não espelhe a regra em vários lugares:
 
 > Severidade não é aspiração: se o projeto só aplica o padrão em 15/72 lugares, é `suggestion`.
 
+> A severidade é **derivada**, não escolhida na revisão: finding de regra usa a severidade
+> declarada aqui; emergente usa `impactClass`. O motor corrige divergências no `--finalize`.
+
 ---
 
 ## Pré-análise Jev (opcional)

package/src/tests/__snapshots__/baseline.test.ts.snap

@@ -27,8 +27,14 @@ src/alpha/**
 
 ## Regras (por severidade)
 
-- ❌ **blocking** — Nunca usar \`any\`.
-- ⚠️ **attention** — Promover: validar a entrada.
+- 1. ❌ **blocking** — Nunca usar \`any\`.
+- 2. ⚠️ **attention** — Promover: validar a entrada.
+
+## Como declarar a severidade
+
+- **Finding de regra:** copie \`rule\` exatamente como no brief. A severidade é a **declarada na regra** — outro valor é ignorado e corrigido pelo motor.
+- **Finding emergente** (\`Lógica:\`/\`Domínio:\`): preencha \`impactClass\` — \`flow-break\` (fluxo/capacidade não honrada), \`contract-drift\` (contrato/estado divergente), \`degradation\` (borda/erro frágil) ou \`cosmetic\`.
+- \`blocking\` fora de regra continua exigindo \`scenario\` + \`evidence\`; sem os dois, o motor rebaixa para \`attention\`.
 
 ## Docs de contexto (carregar sob demanda)
 
@@ -307,10 +313,12 @@ houndsman --pr 456 --finalize
   ".houndsman/.gitignore": 
 "# Diretórios gerados pelo houndsman — \`core/\` é regenerado por \`houndsman update\`.
 # \`work/\` e \`worktrees/\` são runtime de revisão (staging e worktrees).
+# \`golden/\` é massa de avaliação local (defeitos congelados por commit).
 core/
 .runs/
 work/
 worktrees/
+golden/
 "
 ,
   ".houndsman/core/types.ts": 
@@ -625,11 +633,11 @@ exports[`baseline — camada gerada setup gera os mesmos arquivos e conteúdos 3
   },
   {
     "file": ".houndsman/core/skill/OUTPUT-FORMAT.md",
-    "sha256": "49d36854d10f795c",
+    "sha256": "8754e8faaf66c4f9",
   },
   {
     "file": ".houndsman/core/skill/README.md",
-    "sha256": "4d200cf9e5c1d748",
+    "sha256": "b9d5725a87365c06",
   },
   {
     "file": ".houndsman/core/skill/SETUP.md",
@@ -645,11 +653,11 @@ exports[`baseline — camada gerada setup gera os mesmos arquivos e conteúdos 3
   },
   {
     "file": ".houndsman/core/skill/hunt.md",
-    "sha256": "0a81003a5b39b84a",
+    "sha256": "10ecf846c3b6880e",
   },
   {
     "file": ".houndsman/core/skill/train.md",
-    "sha256": "d774215c68d15159",
+    "sha256": "e2742937c6f943a5",
   },
   {
     "file": ".houndsman/core/skill/verify.md",
@@ -893,8 +901,14 @@ index 0000000..f4082f0
 
 ## Regras (por severidade)
 
-- ❌ **blocking** — Nunca usar \`any\`.
-- ⚠️ **attention** — Promover: validar a entrada.
+- 1. ❌ **blocking** — Nunca usar \`any\`.
+- 2. ⚠️ **attention** — Promover: validar a entrada.
+
+## Como declarar a severidade
+
+- **Finding de regra:** copie \`rule\` exatamente como no brief. A severidade é a **declarada na regra** — outro valor é ignorado e corrigido pelo motor.
+- **Finding emergente** (\`Lógica:\`/\`Domínio:\`): preencha \`impactClass\` — \`flow-break\` (fluxo/capacidade não honrada), \`contract-drift\` (contrato/estado divergente), \`degradation\` (borda/erro frágil) ou \`cosmetic\`.
+- \`blocking\` fora de regra continua exigindo \`scenario\` + \`evidence\`; sem os dois, o motor rebaixa para \`attention\`.
 
 ## Docs de contexto (carregar sob demanda)
 
@@ -929,7 +943,8 @@ index 0000000..f4082f0
 `;
 
 exports[`baseline — artefatos de prepare/finalize gera classification, brief, manifest, resumo e state 2`] = `
-"Triagem: sqlite:<cwd>\\houndsman.db#<uuid> — 1 finding(s).
+"Severidade: 1 pela regra.
+Triagem: sqlite:<cwd>\\houndsman.db#<uuid> — 1 finding(s).
 Resumo: sqlite:<cwd>\\houndsman.db#<uuid> (review-resume.md) — 1 bloqueante(s), 0 atenção."
 `;
 

package/src/tests/compare.test.ts

@@ -121,6 +121,29 @@ describe("buildComparison", () => {
 		expect(markdown).toContain("## Severidade mudou (1)");
 		expect(markdown).toContain("## Só em B");
 	});
+
+	test("expõe checklist, cobertura e custo das passadas extras do harness", () => {
+		const withHarness: ReviewSnapshot = {
+			...snapshot("B", []),
+			harness: {
+				checksExpected: 8,
+				checksVerified: 6,
+				checksGaps: 2,
+				reviewedFiles: 11,
+				skippedFiles: 3,
+				undeclaredFiles: 4,
+				businessScore: 20,
+				extraCostUsd: 0.035,
+				secondOpinionFindings: 2,
+			},
+		};
+		const markdown = renderComparison(buildComparison(a, withHarness));
+		expect(markdown).toContain("| Checklist verificado | — | 6/8 | — |");
+		expect(markdown).toContain("| Arquivos sem declaração | — | 4 | — |");
+		expect(markdown).toContain("| Modelo de intenção (score) | — | 20 | — |");
+		expect(markdown).toContain("| Passadas extras (custo) | — | $0.0350 | — |");
+		expect(markdown).toContain("| Segunda opinião (findings) | — | 2 | — |");
+	});
 });
 
 describe("--variant", () => {

package/src/tests/findings-state.test.ts

@@ -33,6 +33,7 @@ function merged(
 	partial: Partial<MergedFinding> & { file: string; rule: string },
 ): MergedFinding {
 	return {
+		...partial,
 		rule: partial.rule,
 		severity: (partial.severity ?? "attention") as Severity,
 		file: partial.file,
@@ -209,6 +210,87 @@ describe("buildStateFromFindings", () => {
 			project.cleanup();
 		}
 	});
+
+	test("emergente sem impactClass mantém a severidade já triada", () => {
+		const project = makeProject({ "src/f.ts": DUPLICATED });
+		try {
+			const reader = fileReader(project.cwd);
+			const base = {
+				file: "src/f.ts",
+				rule: "Lógica: gap",
+				line: 2,
+				message: "gap",
+				basis: "logic" as const,
+			};
+			const first = buildStateFromFindings(
+				[merged({ ...base, severity: "blocking", scenario: "s", evidence: "x" })],
+				{ branch: "main", readFile: reader },
+			);
+			const second = buildStateFromFindings(
+				[merged({ ...base, severity: "suggestion" })],
+				{ branch: "main", readFile: reader, previous: first },
+			);
+			expect(Object.values(second.findings)[0].severity).toBe("blocking");
+		} finally {
+			project.cleanup();
+		}
+	});
+
+	test("emergente com impactClass acompanha o valor derivado", () => {
+		const project = makeProject({ "src/f.ts": DUPLICATED });
+		try {
+			const reader = fileReader(project.cwd);
+			const base = {
+				file: "src/f.ts",
+				rule: "Domínio: gap",
+				line: 2,
+				message: "gap",
+				basis: "domain" as const,
+			};
+			const first = buildStateFromFindings(
+				[merged({ ...base, severity: "suggestion", impactClass: "degradation" })],
+				{ branch: "main", readFile: reader },
+			);
+			const second = buildStateFromFindings(
+				[
+					merged({
+						...base,
+						severity: "attention",
+						impactClass: "contract-drift",
+					}),
+				],
+				{ branch: "main", readFile: reader, previous: first },
+			);
+			expect(Object.values(second.findings)[0].severity).toBe("attention");
+		} finally {
+			project.cleanup();
+		}
+	});
+
+	test("finding de regra sempre acompanha a severidade nova (config manda)", () => {
+		const project = makeProject({ "src/f.ts": DUPLICATED });
+		try {
+			const reader = fileReader(project.cwd);
+			const base = {
+				file: "src/f.ts",
+				rule: "Nunca usar any",
+				line: 2,
+				message: "any",
+				basis: "rule" as const,
+			};
+			const first = buildStateFromFindings(
+				[merged({ ...base, severity: "blocking" })],
+				{ branch: "main", readFile: reader },
+			);
+			const second = buildStateFromFindings(
+				[merged({ ...base, severity: "attention" })],
+				{ branch: "main", readFile: reader, previous: first },
+			);
+			expect(Object.values(second.findings)[0].severity).toBe("attention");
+		} finally {
+			project.cleanup();
+		}
+	});
 });
 
 describe("syncState", () => {