@payconductor/houndsman 0.14.0 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@payconductor/houndsman",
-	"version": "0.14.0",
+	"version": "0.16.0",
 	"description": "Orquestrador de revisão de Pull Requests: classifica o diff, despacha watchdogs especializados por domínio e consolida o relatório.",
 	"type": "module",
 	"license": "MIT",

package/src/cli/commands/golden-command.ts

@@ -0,0 +1,92 @@
+/**
+ * Comando `golden` — avalia as runs da branch contra defeitos congelados.
+ *
+ * Exemplo:
+ *   houndsman golden .houndsman/golden/asaas-split.json
+ *   houndsman golden .houndsman/golden/asaas-split.json --variant otimizado-4
+ */
+
+import { runGolden } from "../../core/commands/golden";
+import { ArgParser } from "../arg-parser";
+import type { CliContext, Command } from "./command";
+
+/** Flags com valor (não entram nos positionais). */
+const VALUE_FLAGS = new Set(["--branch", "--variant", "--slug", "--config"]);
+
+export const GOLDEN_HELP = `Uso: houndsman golden <arquivo.json> [flags]
+
+Avalia uma run (ou todas as variantes da branch) contra um golden set —
+defeitos já confirmados no código — e reporta recall/precisão.
+
+Flags:
+  --branch <nome>    Branch alvo (default: a atual do git)
+  --variant <rótulo> Avalia só uma variante
+  --slug <slug>      Avalia uma run específica
+  --json             Saída JSON (sem markdown)
+
+O relatório é gravado como \`golden-<slug>.md|json\` na run avaliada.
+
+Formato do arquivo:
+  { "version": 1, "title": "...", "commit": "abc1234",
+    "expected": [{ "id": "seller-api-key", "file": "src/a.ts",
+                   "line": 116, "tolerance": 30, "match": "sellerApiKey",
+                   "severity": "blocking", "note": "..." }] 1}
+
+Exemplos:
+  houndsman golden .houndsman/golden/asaas-split.json
+  houndsman golden .houndsman/golden/asaas-split.json --variant otimizado-5`;
+
+/** Primeiro argumento posicional (ignora flags com valor). */
+function positionalFile(args: readonly string[]): string | undefined {
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index];
+		if (arg.startsWith("--")) {
+			if (VALUE_FLAGS.has(arg)) index++;
+			continue;
+		}
+		return arg;
+	}
+	return undefined;
+}
+
+export class GoldenCommand implements Command {
+	readonly name = "golden";
+
+	async run(args: string[], context: CliContext): Promise<number> {
+		const parser = ArgParser.from(args);
+		if (parser.has("--help") || parser.has("-h")) {
+			context.logger.info(GOLDEN_HELP);
+			return 0;
+		}
+
+		const file = positionalFile(args);
+		if (!file) {
+			context.logger.info(GOLDEN_HELP);
+			return 1;
+		}
+
+		const engine = await context.engine();
+		try {
+			const result = runGolden(engine.storage, engine.repo, {
+				file,
+				branch: parser.value("--branch"),
+				variant: parser.value("--variant"),
+				slug: parser.value("--slug"),
+			});
+			if (parser.has("--json")) {
+				context.logger.info(result.json.trimEnd());
+			} else {
+				context.logger.info(result.markdown.trimEnd());
+				context.logger.success(
+					`Golden salvo em ${result.artifacts?.markdown} (run ${result.target.slug}).`,
+				);
+			}
+			return 0;
+		} catch (error) {
+			context.logger.error(error instanceof Error ? error.message : String(error));
+			return 1;
+		} finally {
+			engine.close();
+		}
+	}
+}

package/src/cli/commands/hunt-command.ts

@@ -57,6 +57,8 @@ Flags:
   --hunt-concurrency  Processos maki simultâneos
   --hunt-timeout      Timeout por watchdog (ms)
   --no-retry          Não repete saída inválida
+  --no-checklist      Sem a passada extra de fluxos/invariantes não verificados
+  --no-second-opinion Sem a passada adversarial do revisor de fluxo
   --fail-on-blocking  Exit 1 se houver bloqueantes
 
 Instalação:
@@ -237,6 +239,10 @@ export class HuntCommand implements Command {
 				concurrency,
 				timeoutMs,
 				retries,
+				checklist: parser.has("--no-checklist") ? false : project.huntChecklist,
+				secondOpinion: parser.has("--no-second-opinion")
+					? false
+					: project.huntSecondOpinion,
 				runner: new SpawnMakiRunner(binary.path),
 				onEvent: (event) => this.logEvent(board, event, context.logger),
 			});
@@ -267,6 +273,56 @@ export class HuntCommand implements Command {
 					`${report.totals.findings} finding(s), $${report.totals.costUsd.toFixed(4)}, ` +
 					`${Math.round(report.durationMs / 1000)}s.`,
 			);
+			const checklistCost = report.watchdogs.reduce(
+				(sum, watchdog) => sum + (watchdog.checklist?.costUsd ?? 0),
+				0,
+			);
+			const opinionCost = report.watchdogs.reduce(
+				(sum, watchdog) => sum + (watchdog.secondOpinion?.costUsd ?? 0),
+				0,
+			);
+			if (checklistCost + opinionCost > 0) {
+				context.logger.info(
+					`Passadas extras: checklist $${checklistCost.toFixed(4)} · ` +
+						`segunda opinião $${opinionCost.toFixed(4)}.`,
+				);
+			}
+			const unchecked = report.watchdogs.filter(
+				(watchdog) =>
+					(watchdog.checks?.missing ?? 0) + (watchdog.rules?.missing ?? 0) > 0,
+			);
+			if (unchecked.length > 0) {
+				context.logger.warn(
+					`Checklist de intenção/regras incompleto em ${unchecked.length} watchdog(s): ` +
+						unchecked
+							.map(
+								(watchdog) =>
+									`${watchdog.watchdogId} (itens ${watchdog.checks?.missing ?? 0}, regras ${watchdog.rules?.missing ?? 0})`,
+							)
+							.join(", "),
+				);
+			}
+			const businessReview = report.watchdogs.find(
+				(watchdog) => watchdog.business !== undefined,
+			)?.business;
+			if (businessReview && !businessReview.accepted) {
+				context.logger.info(
+					"Modelo de intenção devolvido pelo revisor foi descartado " +
+						`(inferior ao já gravado: ${report.business ?? "n/d"}).`,
+				);
+			}
+			const incomplete = report.watchdogs
+				.filter((watchdog) => (watchdog.coverage?.undeclared ?? 0) > 0)
+				.map(
+					(watchdog) =>
+						`${watchdog.watchdogId} ${watchdog.coverage?.reviewed ?? 0}/${watchdog.coverage?.total ?? 0}`,
+				);
+			if (incomplete.length > 0) {
+				context.logger.info(
+					`Cobertura declarada incompleta: ${incomplete.join(", ")} ` +
+						"(detalhe em `hunt-report.json`).",
+				);
+			}
 
 			const failed = report.watchdogs.filter(
 				(watchdog) => watchdog.status === "failed",
@@ -405,7 +461,9 @@ export class HuntCommand implements Command {
 			`harness: ${project.huntEnabled ? "ligado" : "desligado"} · ` +
 				`concorrência ${project.huntConcurrency} · ` +
 				`timeout ${Math.round(project.huntTimeoutMs / 1000)}s · ` +
-				`retries ${project.huntRetries}.`,
+				`retries ${project.huntRetries} · ` +
+				`checklist ${project.huntChecklist ? "on" : "off"} · ` +
+				`segunda opinião ${project.huntSecondOpinion ? "on" : "off"}.`,
 		);
 		return 0;
 	}
@@ -431,6 +489,32 @@ export class HuntCommand implements Command {
 			case "start":
 				board.add(event.watchdogId, "revisando");
 				return;
+			case "checklist":
+				if (event.status === "start") {
+					logger.step(
+						`${event.watchdogId}: ${event.missing} item(s) e ${event.missingRules} regra(s) sem verificação — passada de checklist…`,
+					);
+				} else if (event.status === "failed") {
+					logger.warn(
+						`${event.watchdogId}: checklist falhou (${event.error ?? "erro"}); relatório da primeira passada mantido.`,
+					);
+				}
+				return;
+			case "second-opinion":
+				if (event.status === "start") {
+					logger.step(
+						`${event.watchdogId}: passada adversarial (credencial/estado, capacidade, identificador, idempotência, contrato)…`,
+					);
+				} else if (event.status === "done") {
+					logger.info(
+						`${event.watchdogId}: segunda opinião adicionou ${event.findings ?? 0} finding(s).`,
+					);
+				} else {
+					logger.warn(
+						`${event.watchdogId}: segunda opinião falhou (${event.error ?? "erro"}); relatório anterior mantido.`,
+					);
+				}
+				return;
 			case "retry":
 				board.retry(
 					event.watchdogId,

package/src/cli/help.ts

@@ -6,6 +6,7 @@ Comandos:
   --finalize          Consolida os findings e grava o resumo final
   context             Coleta o contexto da PR via gh (Passo 0; --pr/--worktree)
   compare [a] [b]     Compara duas runs (A/B) por slug ou --branch/--a/--b
+  golden <arquivo>    Avalia as runs contra um golden set (recall/precisão)
   findings <sub>      Triagem/correção dos findings (list · show · set · done · reset · sync · summary · batch · verify · submit · path)
   hunt [flags]        Harness local (maki): prepare → watchdogs via maki → finalize
                       (a skill /houndsman hunt continua existindo p/ agentes externos)
@@ -43,6 +44,8 @@ Flags de hunt (harness local):
   --hunt-concurrency  Processos maki simultâneos
   --hunt-timeout      Timeout por watchdog (ms)
   --no-retry          Não repete saída inválida
+  --no-checklist      Sem a passada extra de fluxos/invariantes não verificados
+  --no-second-opinion Sem a passada adversarial do revisor de fluxo
 
 Flags de findings:
   --decision <d>      pending | execute | ignore

package/src/cli/index.ts

@@ -39,6 +39,7 @@ import { CompareCommand } from "./commands/compare-command";
 import { ContextCommand } from "./commands/context-command";
 import { DoctorCommand } from "./commands/doctor-command";
 import { FindingsCommand } from "./commands/findings-command";
+import { GoldenCommand } from "./commands/golden-command";
 import { HelpCommand } from "./commands/help-command";
 import { HuntCommand } from "./commands/hunt-command";
 import { CommandRegistry } from "./commands/registry";
@@ -63,6 +64,7 @@ function buildRegistry(): CommandRegistry {
 		.register(new HuntCommand())
 		.register(new ContextCommand())
 		.register(new CompareCommand())
+		.register(new GoldenCommand())
 		.register(new FindingsCommand())
 		.register(new StatusCommand())
 		.register(new WatchdogCommand())

package/src/core/brief.ts

@@ -40,22 +40,36 @@ export const PROCEDURE: readonly string[] = [
  * O diff já cobre o essencial; o resto é para chamador/contexto de um símbolo
  * citado. Sem teto, o subagente entrava em loop de leitura e cada brief levava
  * minutos — o `general` era o pior caso (PR inteira).
+ *
+ * O teto mínimo é o piso, não o valor fixo: um domínio com 37 arquivos não se
+ * revisa com 10 leituras (o `general` pulava 12 de 37 e perdia o rastreio de
+ * contrato). O tamanho do domínio define quantas leituras o brief concede.
  */
 const EXPLORATION_BUDGET = {
-	general: { reads: 10, searches: 10 },
-	domain: { reads: 6, searches: 6 },
+	general: { reads: 10, searches: 12, maxReads: 24, filesPerRead: 2 },
+	domain: { reads: 6, searches: 6, maxReads: 14, filesPerRead: 2 },
 } as const;
 
+/** Teto de leituras para o domínio (cresce com o nº de arquivos, até o máximo). */
+function readsFor(
+	budget: (typeof EXPLORATION_BUDGET)[keyof typeof EXPLORATION_BUDGET],
+	files: number,
+): number {
+	const needed = Math.ceil(files / budget.filesPerRead);
+	return Math.min(budget.maxReads, Math.max(budget.reads, needed));
+}
+
 /** Seção com o teto de leituras/buscas do brief (visível para o modelo). */
 function explorationSection(args: WatchdogRenderArgs): string[] {
 	const budget =
 		args.watchdogId === GENERAL_WATCHDOG_ID
 			? EXPLORATION_BUDGET.general
 			: EXPLORATION_BUDGET.domain;
+	const reads = readsFor(budget, args.files.length);
 	return [
 		"## Orçamento de exploração",
 		"",
-		`> O diff já está no brief. Limite **neste brief**: ${budget.reads} leitura(s) de arquivo`,
+		`> O diff já está no brief. Limite **neste brief**: ${reads} leitura(s) de arquivo`,
 		`> e ${budget.searches} busca(s) (grep).`,
 		"> Abra arquivo só para chamador/contexto de um símbolo citado nos trechos.",
 		"> Se a prova não estiver no brief nem nesse orçamento, **não é achado** —",
@@ -171,11 +185,24 @@ function codeItem(value: string): string {
 	return `- \`${value}\``;
 }
 
-/** Linha de regra com emoji de severidade. */
-function ruleItem(rule: Rule): string {
-	return `- ${SEVERITY_EMOJI[rule.severity]} **${rule.severity}** — ${rule.text}`;
+/** Linha de regra com número e emoji de severidade (o número é a identidade no checklist). */
+function ruleItem(rule: Rule, index: number): string {
+	return `- ${index}. ${SEVERITY_EMOJI[rule.severity]} **${rule.severity}** — ${rule.text}`;
 }
 
+/**
+ * Contrato de severidade do output — a severidade é derivada, não escolhida.
+ *
+ * Finding de regra carrega a severidade declarada em `Rule.severity`; emergente
+ * carrega `impactClass`, mapeado em `core/severity.ts`. Isso impede o mesmo
+ * código de sair `blocking` numa review e `attention` na seguinte.
+ */
+export const SEVERITY_GUIDE: readonly string[] = [
+	"- **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`.",
+];
+
 /** Seção opcional (`## <título>` + itens) — vazia se não houver itens. */
 function optionalList(title: string, items: readonly string[] | undefined): string[] {
 	if (!items || items.length === 0) return [];
@@ -587,9 +614,10 @@ export function defaultRenderBrief(
 		"",
 		...[...def.rules]
 			.sort((a, b) => severityRank(a.severity) - severityRank(b.severity))
-			.map(ruleItem),
+			.map((rule, index) => ruleItem(rule, index + 1)),
 		"",
 	);
+	lines.push("## Como declarar a severidade", "", ...SEVERITY_GUIDE, "");
 	lines.push(
 		"## Docs de contexto (carregar sob demanda)",
 		"",

package/src/core/commands/compare.ts

@@ -46,10 +46,42 @@ type ReportShape = { durationMs?: number };
 type HuntShape = {
 	model?: string;
 	durationMs?: number;
+	businessScore?: number;
 	totals?: { totalTokens?: number; costUsd?: number };
+	watchdogs?: {
+		checks?: {
+			expected?: number;
+			verified?: number;
+			missing?: number;
+			gaps?: number;
+		};
+		coverage?: { reviewed?: number; skipped?: number; undeclared?: number };
+		checklist?: { costUsd?: number };
+		secondOpinion?: { costUsd?: number; findings?: number };
+	}[];
 };
 type AiUsageShape = { total?: { totalTokens?: number } };
 
+/** Agrega o diagnóstico do `hunt-report.json` (checklist + cobertura declarada). */
+function harnessOf(hunt: HuntShape): NonNullable<ReviewSnapshot["harness"]> {
+	const watchdogs = hunt.watchdogs ?? [];
+	const sum = (pick: (item: (typeof watchdogs)[number]) => number | undefined) =>
+		watchdogs.reduce((total, item) => total + (pick(item) ?? 0), 0);
+	return {
+		checksExpected: sum((item) => item.checks?.expected),
+		checksVerified: sum((item) => item.checks?.verified),
+		checksGaps: sum((item) => item.checks?.gaps),
+		reviewedFiles: sum((item) => item.coverage?.reviewed),
+		skippedFiles: sum((item) => item.coverage?.skipped),
+		undeclaredFiles: sum((item) => item.coverage?.undeclared),
+		businessScore: hunt.businessScore,
+		extraCostUsd:
+			sum((item) => item.checklist?.costUsd) +
+			sum((item) => item.secondOpinion?.costUsd),
+		secondOpinionFindings: sum((item) => item.secondOpinion?.findings),
+	};
+}
+
 /** Resolve a run pelo slug dentro do repositório. */
 function bySlug(
 	storage: StorageProvider,
@@ -149,6 +181,7 @@ function snapshotOf(
 		model: hunt?.model ?? manifest?.ai?.model,
 		findings,
 		bySeverity: countBySeverity(findings),
+		harness: hunt ? harnessOf(hunt) : undefined,
 		coverage: {
 			watchdogs: watchdogs.length,
 			files: files.size,

package/src/core/commands/golden.ts

@@ -0,0 +1,176 @@
+/**
+ * Comando `golden` (biblioteca) — avalia runs contra defeitos congelados.
+ *
+ * A contagem de findings de duas variantes nunca é comparável: cada execução
+ * amostra pontos diferentes do mesmo diff. Com um golden set (arquivo do
+ * consumidor), a comparação vira recall/precisão sobre os defeitos que já
+ * foram confirmados no código.
+ */
+
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import {
+	commitMatches,
+	type GoldenFinding,
+	type GoldenRunScore,
+	type GoldenSet,
+	goldenToJson,
+	parseGoldenSet,
+	renderGoldenReport,
+	scoreGolden,
+} from "../golden";
+import { normalizePath } from "../hunt/review-checks";
+import { currentBranch } from "../pr-context";
+import type { RepoIdentity, ReviewRecord, StorageProvider } from "../storage/types";
+
+/** Seleção das runs a avaliar. */
+export type GoldenOptions = {
+	/** Caminho do arquivo de golden set. */
+	file: string;
+	/** Branch alvo (default: a atual). */
+	branch?: string;
+	/** Rótulo da variante; ausente = todas as runs da branch. */
+	variant?: string;
+	/** Slug explícito (vence `variant`). */
+	slug?: string;
+};
+
+/** Resultado do comando. */
+export type GoldenResult = {
+	markdown: string;
+	json: string;
+	set: GoldenSet;
+	runs: GoldenRunScore[];
+	/** Run onde o relatório foi gravado (a mais recente avaliada). */
+	target: ReviewRecord;
+	artifacts?: { markdown: string; json: string };
+};
+
+/** Lê e valida o arquivo de golden set. */
+export function loadGoldenSet(file: string): {
+	set: GoldenSet;
+	warnings: string[];
+} {
+	let content: string;
+	try {
+		content = readFileSync(resolve(file), "utf8");
+	} catch (error) {
+		throw new Error(
+			`Golden set ilegível: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+	let raw: unknown;
+	try {
+		raw = JSON.parse(content);
+	} catch {
+		throw new Error(`Golden set não é JSON válido: ${file}`);
+	}
+	const parsed = parseGoldenSet(raw);
+	if (!parsed.set) {
+		throw new Error(
+			`Golden set inválido (${file}): ${parsed.warnings.join(" ")}`.trim(),
+		);
+	}
+	return { set: parsed.set, warnings: parsed.warnings };
+}
+
+/** Findings presentes de uma run, no formato da avaliação. */
+export function goldenFindingsOf(
+	storage: StorageProvider,
+	review: ReviewRecord,
+): GoldenFinding[] {
+	const state = storage.readFindings(review.id);
+	return Object.values(state?.findings ?? {})
+		.filter((finding) => finding.present)
+		.map((finding) => ({
+			fingerprint: finding.fingerprint,
+			file: normalizePath(finding.file),
+			line: finding.line ?? undefined,
+			rule: finding.rule,
+			severity: finding.severity,
+			message: finding.message,
+			evidence: finding.evidence,
+			watchdogs: finding.watchdogIds,
+		}));
+}
+
+/** Runs alvo: slug > variante > todas as da branch. */
+function selectReviews(
+	storage: StorageProvider,
+	repo: RepoIdentity,
+	options: GoldenOptions,
+): ReviewRecord[] {
+	const reviews = storage.listReviews(repo.key);
+	if (options.slug) {
+		const found = reviews.find((review) => review.slug === options.slug);
+		if (!found) {
+			throw new Error(`Nenhuma run com slug '${options.slug}' neste repositório.`);
+		}
+		return [found];
+	}
+
+	const branch = options.branch ?? currentBranch();
+	const ofBranch = reviews.filter((review) => review.branch === branch);
+	const variant = options.variant?.trim();
+	const selected = variant
+		? ofBranch.filter((review) => review.variant === variant)
+		: ofBranch;
+	if (selected.length === 0) {
+		throw new Error(
+			`Nenhuma revisão para '${branch}'${variant ? ` (variante '${variant}')` : ""}.`,
+		);
+	}
+	return selected;
+}
+
+/** Rótulo curto da run (`otimizado-4` ou `principal`). */
+function labelOf(review: ReviewRecord): string {
+	return review.variant?.trim() || "principal";
+}
+
+/** Executa a avaliação e grava o relatório na run mais recente selecionada. */
+export function runGolden(
+	storage: StorageProvider,
+	repo: RepoIdentity,
+	options: GoldenOptions,
+): GoldenResult {
+	const { set } = loadGoldenSet(options.file);
+	const reviews = selectReviews(storage, repo, options);
+	const runs: GoldenRunScore[] = reviews.map((review) => {
+		const findings = goldenFindingsOf(storage, review);
+		const commit = review.headSha ?? review.reviewedSha;
+		return {
+			slug: review.slug,
+			label: labelOf(review),
+			variant: review.variant,
+			scope: review.branch,
+			commit,
+			commitMismatch: !commitMatches(set.commit, commit),
+			findings: findings.length,
+			score: scoreGolden(set, findings),
+		};
+	});
+
+	const markdown = renderGoldenReport(set, runs);
+	const json = goldenToJson(set, runs);
+	const target = reviews[0];
+	const base = `golden-${target.slug}`;
+	storage.writeArtifact(target.id, {
+		name: `${base}.md`,
+		kind: "golden",
+		content: markdown,
+	});
+	storage.writeArtifact(target.id, {
+		name: `${base}.json`,
+		kind: "golden",
+		content: json,
+	});
+	return {
+		markdown,
+		json,
+		set,
+		runs,
+		target,
+		artifacts: { markdown: `${base}.md`, json: `${base}.json` },
+	};
+}

package/src/core/commands/scaffold.ts

@@ -426,10 +426,12 @@ export const DOC_MAPPINGS: readonly (readonly [RegExp, readonly string[]])[] = [
 
 const PROJECT_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/
 `;
 
 // ---------------------------------------------------------------------------

package/src/core/compare.ts

@@ -38,6 +38,23 @@ export type ReviewSnapshot = {
 	prepareMs?: number;
 	/** Duração do harness maki (`hunt-report.json`). */
 	huntMs?: number;
+	/**
+	 * Diagnóstico do harness local: checklist de intenção e cobertura declarada.
+	 * Ausente no modo skill (não há `hunt-report.json`).
+	 */
+	harness?: {
+		checksExpected?: number;
+		checksVerified?: number;
+		checksGaps?: number;
+		reviewedFiles?: number;
+		skippedFiles?: number;
+		undeclaredFiles?: number;
+		businessScore?: number;
+		/** Custo somado das passadas extras (checklist + segunda opinião). */
+		extraCostUsd?: number;
+		/** Findings adicionados pela segunda opinião. */
+		secondOpinionFindings?: number;
+	};
 	tokens?: number;
 	costUsd?: number;
 };
@@ -123,6 +140,22 @@ function formatMs(ms: number | undefined): string {
 	return `${minutes}m${String(Math.round(seconds % 60)).padStart(2, "0")}s`;
 }
 
+/** Contagem simples (`—` quando não medida). */
+function formatCount(value: number | undefined): string {
+	return value === undefined || !Number.isFinite(value) ? "—" : String(value);
+}
+
+/** Razão verificada/esperada (`4/6`). */
+function formatRatio(verified: number | undefined, expected: number | undefined): string {
+	if (verified === undefined || expected === undefined) return "—";
+	return `${verified}/${expected}`;
+}
+
+/** Custo em dólar (`$0.1234`). */
+function formatCost(value: number | undefined): string {
+	return value === undefined || !Number.isFinite(value) ? "—" : `$${value.toFixed(4)}`;
+}
+
 function formatDelta(
 	a: number | undefined,
 	b: number | undefined,
@@ -206,6 +239,40 @@ export function renderComparison(comparison: ReviewComparison): string {
 		metricRow("Duração total", formatMs(a.durationMs), formatMs(b.durationMs)),
 		metricRow("Prepare", formatMs(a.prepareMs), formatMs(b.prepareMs)),
 		metricRow("Harness", formatMs(a.huntMs), formatMs(b.huntMs)),
+		...(a.harness || b.harness
+			? [
+					metricRow(
+						"Checklist verificado",
+						formatRatio(a.harness?.checksVerified, a.harness?.checksExpected),
+						formatRatio(b.harness?.checksVerified, b.harness?.checksExpected),
+					),
+					metricRow(
+						"Arquivos revisados (declarado)",
+						formatCount(a.harness?.reviewedFiles),
+						formatCount(b.harness?.reviewedFiles),
+					),
+					metricRow(
+						"Arquivos sem declaração",
+						formatCount(a.harness?.undeclaredFiles),
+						formatCount(b.harness?.undeclaredFiles),
+					),
+					metricRow(
+						"Modelo de intenção (score)",
+						formatCount(a.harness?.businessScore),
+						formatCount(b.harness?.businessScore),
+					),
+					metricRow(
+						"Passadas extras (custo)",
+						formatCost(a.harness?.extraCostUsd),
+						formatCost(b.harness?.extraCostUsd),
+					),
+					metricRow(
+						"Segunda opinião (findings)",
+						formatCount(a.harness?.secondOpinionFindings),
+						formatCount(b.harness?.secondOpinionFindings),
+					),
+				]
+			: []),
 		metricRow(
 			"Tokens",
 			a.tokens !== undefined ? String(a.tokens) : "—",

package/src/core/config.ts

@@ -146,6 +146,16 @@ export type HoundsmanHunt = {
 	timeoutMs?: number;
 	/** Tentativas extras quando a saída do watchdog é inválida (default: 1). */
 	retries?: number;
+	/**
+	 * Passada extra por watchdog para cobrir fluxos/invariantes/regras que a
+	 * primeira resposta não verificou (default: ligada).
+	 */
+	checklist?: boolean;
+	/**
+	 * Passada adversarial do `general` nas 5 classes (credencial/estado,
+	 * capacidade, identificador, idempotência, contrato). Default: ligada.
+	 */
+	secondOpinion?: boolean;
 	/** Caminho explícito do binário (`HOUNDSMAN_MAKI_PATH` tem precedência). */
 	binaryPath?: string;
 };