@payconductor/houndsman 0.13.0 → 0.16.0

package/src/core/commands/review.ts

@@ -22,10 +22,16 @@ export function parseReviewArgs(args: string[]): ReviewOptions {
 	const branch = parser.value("--branch");
 	const pr = parser.value("--pr");
 	const worktree = parser.value("--worktree");
+	const variant = parser.value("--variant");
 	if (base) opts.base = base;
 	if (head) opts.head = head;
 	if (branch) opts.branch = branch;
 	if (worktree) opts.worktree = worktree;
+	if (variant !== undefined) {
+		const label = variant.trim();
+		if (!label) throw new Error("--variant não pode ser vazio.");
+		opts.variant = label;
+	}
 	if (pr) {
 		const number = Number.parseInt(pr, 10);
 		if (!Number.isFinite(number) || number <= 0) {

package/src/core/commands/scaffold.ts

@@ -98,6 +98,15 @@ export const houndsmanConfig = {
 	watchdogs: WATCHDOG_DEFINITIONS,
 	exclusions: EXCLUSION_PATTERNS,
 	docMappings: DOC_MAPPINGS,
+	// Prioridade por caminho (opcional): "linhas de churn equivalentes".
+	// \`bonus\` promove caminho crítico; \`maxRiskFromChurn\` satura o superchurn de
+	// caminho de baixa criticidade (risco = min(churn, teto) + bonus).
+	// A primeira regra que casar vence; sem regra, o risco é o churn puro.
+	// priorities: [
+	//   { pattern: /^src\\/(db|repositories)\\//, bonus: 300 },
+	//   { pattern: /^src\\/(services|domain)\\//, bonus: 200 },
+	//   { pattern: /^src\\/(components|styles)\\//, maxRiskFromChurn: 120 },
+	// ],
 } satisfies HoundsmanConfig;
 
 export default houndsmanConfig;
@@ -215,6 +224,7 @@ export type AiProviderOptions = Record<string, Record<string, unknown>>;
 /** Features de IA do fluxo normal (todas fail-open). */
 export type HoundsmanAiFeatures = {
 	context?: boolean;
+	business?: boolean;
 	brief?: boolean;
 	technical?: boolean;
 	classification?: boolean;
@@ -252,6 +262,18 @@ export type HoundsmanHunt = {
 	binaryPath?: string;
 };
 
+/**
+ * Prioridade por caminho.
+ *
+ * \`bonus\` promove (linhas de churn equivalentes) e \`maxRiskFromChurn\` satura o
+ * superchurn de caminhos de baixa criticidade.
+ */
+export type HoundsmanPriority = {
+	pattern: RegExp;
+	bonus?: number;
+	maxRiskFromChurn?: number;
+};
+
 /** Contrato de configuração do motor. */
 export type HoundsmanConfig<TId extends string = string> = {
 	projectName: string;
@@ -260,6 +282,8 @@ export type HoundsmanConfig<TId extends string = string> = {
 	watchdogs: Record<TId, WatchdogDefinition>;
 	exclusions: readonly RegExp[];
 	docMappings: readonly (readonly [RegExp, readonly string[]])[];
+	/** Prioridade por caminho (opcional; a primeira regra que casar vence). */
+	priorities?: readonly HoundsmanPriority[];
 	alwaysIncludeDocs?: readonly string[];
 	budgets?: HoundsmanBudgets;
 	concurrency?: HoundsmanConcurrency;
@@ -365,6 +389,9 @@ import { exampleWatchdog } from "./example";
 /**
  * Definições dos watchdogs — as chaves definem o union \`WatchdogId\`.
  * Adicionar um watchdog = criar \`<id>.ts\` e registrá-lo aqui.
+ *
+ * NÃO declare um watchdog com id \`general\`: ele é reservado pelo motor
+ * (revisor de fluxo obrigatório) e é injetado em todo ciclo.
  */
 export const WATCHDOG_DEFINITIONS = {
 	default: defaultWatchdog,
@@ -399,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/commands/status.ts

@@ -33,11 +33,14 @@ function findReview(
 	storage: StorageProvider,
 	repo: RepoIdentity,
 	branch?: string,
+	variant?: string,
 ): ReviewRecord {
 	const target = branch ?? currentBranch();
-	const review = storage.findReview(repo.key, target);
+	const review = storage.findReview(repo.key, target, variant);
 	if (!review) {
-		throw new Error(`Nenhuma revisão para '${target}'.`);
+		throw new Error(
+			`Nenhuma revisão para '${target}'${variant ? ` (variante '${variant}')` : ""}.`,
+		);
 	}
 	return review;
 }
@@ -47,8 +50,9 @@ export function readStatus(
 	storage: StorageProvider,
 	repo: RepoIdentity,
 	branch?: string,
+	variant?: string,
 ): StatusResult {
-	return toResult(findReview(storage, repo, branch));
+	return toResult(findReview(storage, repo, branch, variant));
 }
 
 /** Renova o heartbeat de uma execução ativa (`reviewing`/`fixing`). */
@@ -56,8 +60,9 @@ export function pingStatus(
 	storage: StorageProvider,
 	repo: RepoIdentity,
 	branch?: string,
+	variant?: string,
 	now?: string,
 ): StatusResult {
-	const review = findReview(storage, repo, branch);
+	const review = findReview(storage, repo, branch, variant);
 	return toResult(touchRunStatus(storage, review.id, now));
 }

package/src/core/compare.ts

@@ -0,0 +1,310 @@
+/**
+ * Comparação A/B de duas revisões da mesma branch (funções puras).
+ *
+ * O objetivo é responder "o que mudou entre as duas execuções?" sem tentar
+ * eleger um vencedor: conta achados por severidade, cobertura, tempo e tokens,
+ * e lista o que apareceu/sumiu entre A e B.
+ */
+
+import { SEVERITY_ORDER, type Severity } from "./types";
+
+/** Finding normalizado para a comparação. */
+export type ComparisonFinding = {
+	fingerprint: string;
+	rule: string;
+	severity: Severity;
+	file: string;
+	line?: number;
+	message: string;
+	watchdogs: readonly string[];
+};
+
+/** Snapshot de uma execução (uma das pontas do A/B). */
+export type ReviewSnapshot = {
+	/** Rótulo exibido (`A`, `B` ou a variante). */
+	label: string;
+	slug: string;
+	branch: string;
+	variant?: string;
+	headSha?: string;
+	model?: string;
+	/** Achados presentes no último relatório. */
+	findings: readonly ComparisonFinding[];
+	bySeverity: Record<Severity, number>;
+	coverage: { watchdogs: number; files: number; overflow: number };
+	/** Duração do ciclo (`startedAt` → `reviewedAt`), quando medida. */
+	durationMs?: number;
+	/** Duração do prepare (`prepare-report.json`). */
+	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;
+};
+
+/** Resultado da comparação. */
+export type ReviewComparison = {
+	branch: string;
+	headSha?: string;
+	a: ReviewSnapshot;
+	b: ReviewSnapshot;
+	onlyA: readonly ComparisonFinding[];
+	onlyB: readonly ComparisonFinding[];
+	common: readonly { a: ComparisonFinding; b: ComparisonFinding }[];
+	severityChanged: readonly { a: ComparisonFinding; b: ComparisonFinding }[];
+};
+
+/** Conta os achados por severidade. */
+export function countBySeverity(
+	findings: readonly ComparisonFinding[],
+): Record<Severity, number> {
+	const counts: Record<Severity, number> = {
+		blocking: 0,
+		attention: 0,
+		suggestion: 0,
+		nit: 0,
+	};
+	for (const finding of findings) counts[finding.severity]++;
+	return counts;
+}
+
+/** Compara dois snapshots (ordem estável por severidade e caminho). */
+export function buildComparison(a: ReviewSnapshot, b: ReviewSnapshot): ReviewComparison {
+	const aByKey = new Map(a.findings.map((finding) => [finding.fingerprint, finding]));
+	const bByKey = new Map(b.findings.map((finding) => [finding.fingerprint, finding]));
+	const onlyA = a.findings.filter((finding) => !bByKey.has(finding.fingerprint));
+	const onlyB = b.findings.filter((finding) => !aByKey.has(finding.fingerprint));
+	const common: { a: ComparisonFinding; b: ComparisonFinding }[] = [];
+	const severityChanged: { a: ComparisonFinding; b: ComparisonFinding }[] = [];
+
+	for (const finding of a.findings) {
+		const other = bByKey.get(finding.fingerprint);
+		if (!other) continue;
+		common.push({ a: finding, b: other });
+		if (finding.severity !== other.severity) {
+			severityChanged.push({ a: finding, b: other });
+		}
+	}
+
+	const sortFindings = (items: ComparisonFinding[]): ComparisonFinding[] =>
+		[...items].sort(
+			(x, y) =>
+				SEVERITY_ORDER.indexOf(x.severity) - SEVERITY_ORDER.indexOf(y.severity) ||
+				x.file.localeCompare(y.file) ||
+				(x.line ?? 0) - (y.line ?? 0) ||
+				x.rule.localeCompare(y.rule),
+		);
+
+	return {
+		branch: a.branch,
+		headSha: a.headSha ?? b.headSha,
+		a,
+		b,
+		onlyA: sortFindings(onlyA),
+		onlyB: sortFindings(onlyB),
+		common,
+		severityChanged: severityChanged.sort(
+			(x, y) =>
+				SEVERITY_ORDER.indexOf(x.a.severity) -
+					SEVERITY_ORDER.indexOf(y.a.severity) ||
+				x.a.file.localeCompare(y.a.file),
+		),
+	};
+}
+
+/** Duração legível (`820ms`, `12.3s`, `2m05s`). */
+function formatMs(ms: number | undefined): string {
+	if (ms === undefined || !Number.isFinite(ms)) return "—";
+	const safe = Math.max(0, Math.round(ms));
+	if (safe < 1_000) return `${safe}ms`;
+	const seconds = safe / 1_000;
+	if (seconds < 60) return `${seconds.toFixed(1)}s`;
+	const minutes = Math.floor(seconds / 60);
+	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,
+	format: (value: number) => string,
+): string {
+	if (a === undefined || b === undefined) return "—";
+	const delta = b - a;
+	return `${delta > 0 ? "+" : ""}${format(delta)}`;
+}
+
+/** Linha da tabela de métricas. */
+function metricRow(label: string, a: string, b: string, delta = "—"): string {
+	return `| ${label} | ${a} | ${b} | ${delta} |`;
+}
+
+/** Lista compacta de um conjunto de achados. */
+function findingList(title: string, findings: readonly ComparisonFinding[]): string[] {
+	if (findings.length === 0) return [`## ${title}`, "", "_Nenhum._", ""];
+	const shown = findings.slice(0, 20);
+	const lines = [`## ${title} (${findings.length})`, ""];
+	for (const finding of shown) {
+		const line = finding.line !== undefined ? `:${finding.line}` : "";
+		lines.push(
+			`- **${finding.severity}** · \`${finding.file}${line}\` — ${finding.message}`,
+		);
+	}
+	if (findings.length > shown.length) {
+		lines.push(`- … +${findings.length - shown.length} achado(s)`);
+	}
+	lines.push("");
+	return lines;
+}
+
+/** Renderiza a comparação em Markdown (artefato e stdout). */
+export function renderComparison(comparison: ReviewComparison): string {
+	const { a, b } = comparison;
+	const severityDelta = SEVERITY_ORDER.map((severity) =>
+		metricRow(
+			severity,
+			String(a.bySeverity[severity]),
+			String(b.bySeverity[severity]),
+			formatDelta(a.bySeverity[severity], b.bySeverity[severity], (value) =>
+				String(value),
+			),
+		),
+	);
+	const totalA = a.findings.length;
+	const totalB = b.findings.length;
+	const lines = [
+		`# Comparação A/B — \`${comparison.branch}\``,
+		"",
+		`**A:** ${labelOf(a)} · **B:** ${labelOf(b)}`,
+		...(comparison.headSha
+			? [`**Commit:** \`${comparison.headSha.slice(0, 7)}\``]
+			: []),
+		"",
+		"> Compara o que apareceu/sumiu entre as execuções. Não é veredito: confirme",
+		"> cada achado novo no código antes de considerá-lo ganho ou perda.",
+		"",
+		"## Métricas",
+		"",
+		`| Métrica | A | B | Δ |`,
+		`| --- | --- | --- | --- |`,
+		metricRow(
+			"Findings (presentes)",
+			String(totalA),
+			String(totalB),
+			formatDelta(totalA, totalB, (value) => String(value)),
+		),
+		...severityDelta,
+		metricRow(
+			"Cobertura (arquivos)",
+			String(a.coverage.files),
+			String(b.coverage.files),
+		),
+		metricRow(
+			"Watchdogs",
+			String(a.coverage.watchdogs),
+			String(b.coverage.watchdogs),
+		),
+		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) : "—",
+			b.tokens !== undefined ? String(b.tokens) : "—",
+		),
+		metricRow(
+			"Custo",
+			a.costUsd !== undefined ? `$${a.costUsd.toFixed(4)}` : "—",
+			b.costUsd !== undefined ? `$${b.costUsd.toFixed(4)}` : "—",
+		),
+		"",
+		...findingList("Só em B (novos)", comparison.onlyB),
+		...findingList("Só em A (não apareceram em B)", comparison.onlyA),
+	];
+	if (comparison.severityChanged.length > 0) {
+		lines.push(`## Severidade mudou (${comparison.severityChanged.length})`, "");
+		for (const item of comparison.severityChanged.slice(0, 20)) {
+			lines.push(
+				`- \`${item.a.file}\` — ${item.a.rule}: **${item.a.severity} → ${item.b.severity}**`,
+			);
+		}
+		lines.push("");
+	}
+	return `${lines.join("\n").trimEnd()}\n`;
+}
+
+/** JSON estável da comparação (artefato para automação). */
+export function comparisonToJson(comparison: ReviewComparison): string {
+	return `${JSON.stringify(comparison, null, 2)}\n`;
+}
+
+function labelOf(snapshot: ReviewSnapshot): string {
+	const variant = snapshot.variant ? ` (variante \`${snapshot.variant}\`)` : "";
+	return `\`${snapshot.slug}\`${variant} · ${snapshot.findings.length} finding(s)`;
+}

package/src/core/concurrency.ts

@@ -0,0 +1,30 @@
+/**
+ * Pool de concorrência mínimo (biblioteca).
+ *
+ * Mantém no máximo `limit` promessas ativas e preserva a ordem dos resultados.
+ * Não trata erros: o chamador decide se cada item falha isoladamente.
+ */
+
+/** Executa `mapper` para cada item com concorrência limitada. */
+export async function mapPool<T, R>(
+	items: readonly T[],
+	limit: number,
+	mapper: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+	const results = new Array<R>(items.length);
+	if (items.length === 0) return results;
+
+	let next = 0;
+	const workers = Array.from(
+		{ length: Math.max(1, Math.min(limit, items.length)) },
+		async () => {
+			while (true) {
+				const index = next++;
+				if (index >= items.length) return;
+				results[index] = await mapper(items[index], index);
+			}
+		},
+	);
+	await Promise.all(workers);
+	return results;
+}

package/src/core/config.ts

@@ -72,6 +72,8 @@ export type AiProviderOptions = Record<string, Record<string, unknown>>;
 export type HoundsmanAiFeatures = {
 	/** Resume o contexto da PR (`context-summary`) quando o subagente não gerou. */
 	context?: boolean;
+	/** Reconstrói a intenção da PR (`business-summary`) antes dos watchdogs. */
+	business?: boolean;
 	/** Enriquece os briefs com um plano de revisão sugerido. */
 	brief?: boolean;
 	/** Gera os pontos técnicos estruturais do resumo final. */
@@ -99,7 +101,7 @@ export type HoundsmanAi = {
 	model?: string;
 	/** Base URL customizada do provider. */
 	baseURL?: string;
-	/** Chamadas simultâneas (default: 2). */
+	/** Chamadas simultâneas (default: 4). */
 	concurrency?: number;
 	/** Opções do AI SDK por provider (repassadas sem interpretação). */
 	providerOptions?: AiProviderOptions;
@@ -130,7 +132,7 @@ export type HoundsmanWorktrees = {
  * Harness local da capability `hunt` (`houndsman hunt`) — opcional.
  *
  * Sem esta config, o comando usa defaults seguros: modelo derivado de `ai`,
- * 4 processos simultâneos e timeout de 15 min por watchdog. A skill
+ * 8 processos simultâneos (uma onda) e timeout de 15 min por watchdog. A skill
  * `/houndsman hunt` (harness externo) não depende deste bloco.
  */
 export type HoundsmanHunt = {
@@ -138,12 +140,22 @@ export type HoundsmanHunt = {
 	enabled?: boolean;
 	/** Modelo no formato do maki (`provider/model-id`). Default: derivado de `ai`. */
 	model?: string;
-	/** Processos maki simultâneos (default: 4). */
+	/** Processos maki simultâneos (default: 8). */
 	concurrency?: number;
 	/** Timeout por watchdog em ms (default: 900_000). */
 	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;
 };
@@ -162,6 +174,27 @@ export type HoundsmanStorage = {
 	path?: string;
 };
 
+/**
+ * Regra de prioridade por caminho (ordenada; a primeira que casar vence).
+ *
+ * O risco do arquivo é `min(churn, maxRiskFromChurn) + bonus`. O `bonus` promove
+ * caminhos críticos (em linhas de churn equivalentes) e o `maxRiskFromChurn`
+ * satura o superchurn de caminhos de baixa criticidade: um frontend que
+ * reformatou 2.000 linhas não escala além do teto, mas um ajuste pequeno no
+ * mesmo caminho mantém o peso natural.
+ */
+export type HoundsmanPriority = {
+	/** Padrão sobre o caminho relativo (ex.: `/^server\\/src\\/db\\//`). */
+	pattern: RegExp;
+	/** Peso em linhas de churn equivalentes (≥ 0; default: 0). */
+	bonus?: number;
+	/**
+	 * Teto do churn considerado no risco (em linhas equivalentes). Acima dele os
+	 * arquivos do caminho empatam e só o `bonus` diferencia. Default: sem teto.
+	 */
+	maxRiskFromChurn?: number;
+};
+
 /**
  * Configuração completa do motor de revisão para um projeto.
  *
@@ -185,6 +218,11 @@ export type HoundsmanConfig<TId extends string = string> = {
 	exclusions: readonly RegExp[];
 	/** Mapeamentos path → documentação relevante. */
 	docMappings: readonly (readonly [RegExp, readonly string[]])[];
+	/**
+	 * Prioridade por caminho (opcional). Ordena arquivos no orçamento, no rateio
+	 * do diff e no recorte do `general` — a primeira regra que casar vence.
+	 */
+	priorities?: readonly HoundsmanPriority[];
 	/** Docs sempre incluídos nos briefs (default: `DEFAULT_ALWAYS_INCLUDE_DOCS`). */
 	alwaysIncludeDocs?: readonly string[];
 	/** Limites de triage para PRs grandes (default: `DEFAULT_MAX_FILES_PER_BRIEF`). */

package/src/core/defaults.ts

@@ -38,8 +38,13 @@ export const DEFAULT_AI_PROVIDER = "deepseek" as const;
 /** Modelo default da camada de IA. */
 export const DEFAULT_AI_MODEL = "deepseek-v4-pro";
 
-/** Concorrência default das chamadas de IA. */
-export const DEFAULT_AI_CONCURRENCY = 2;
+/**
+ * Concorrência default das chamadas de IA do prepare.
+ *
+ * Vale principalmente para os planos de brief (1 chamada por watchdog): com 4,
+ * 8 watchdogs fecham em 2 rodadas em vez de 4.
+ */
+export const DEFAULT_AI_CONCURRENCY = 4;
 
 /** Timeout default de uma chamada de modelo (ms). */
 export const DEFAULT_AI_TIMEOUT_MS = 120_000;
@@ -47,12 +52,53 @@ export const DEFAULT_AI_TIMEOUT_MS = 120_000;
 /** Teto default de chamadas de IA por review. */
 export const DEFAULT_AI_MAX_CALLS_PER_REVIEW = 40;
 
-/** Processos maki simultâneos no harness local (`houndsman hunt`). */
-export const DEFAULT_HUNT_CONCURRENCY = 4;
+/**
+ * Processos maki simultâneos no harness local (`houndsman hunt`).
+ *
+ * 8 = uma onda para os watchdogs usuais (domínios + `general`), em vez de 2.
+ */
+export const DEFAULT_HUNT_CONCURRENCY = 8;
 
 /** Timeout default de um watchdog no harness local (15 min). */
 export const DEFAULT_HUNT_TIMEOUT_MS = 900_000;
 
+/**
+ * Trechos alterados injetados no brief (watchdog de domínio).
+ *
+ * Substituem a leitura do arquivo inteiro: o subagente começa pelo diff e só
+ * abre o arquivo para contexto adjacente. O orçamento é distribuído entre os
+ * arquivos (metade em partes iguais, o resto por churn) — antes, os primeiros
+ * arquivos consumiam o teto e o subagente lia os demais à mão.
+ */
+export const DEFAULT_BRIEF_SNIPPET_CHARS = 24_000;
+export const DEFAULT_BRIEF_SNIPPET_CHARS_PER_FILE = 4_000;
+
+/** Mesmos limites para o revisor de fluxo (`general`), que vê todos os arquivos. */
+export const GENERAL_BRIEF_SNIPPET_CHARS = 32_000;
+export const GENERAL_BRIEF_SNIPPET_CHARS_PER_FILE = 5_000;
+
+/** Fração do teto dividida igualmente entre os arquivos (o resto vai por churn). */
+export const BRIEF_SNIPPET_FLOOR_RATIO = 0.5;
+
+/** Piso de chars por arquivo no rateio igual (evita trechos inúteis). */
+export const BRIEF_SNIPPET_MIN_PER_FILE = 120;
+
+/**
+ * A partir daqui o `general` revisa por **fluxo** em vez de amostrar arquivos.
+ *
+ * Em PRs grandes, 40 arquivos com ~800 chars cada viram amostragem: melhor ver
+ * os arquivos que participam dos fluxos do modelo de intenção (com diff de
+ * verdade) e declarar o resto em `skipped`.
+ */
+export const GENERAL_FLOW_MIN_FILES = 40;
+export const GENERAL_FLOW_MIN_LINES = 2_000;
+
+/** Arquivos do recorte de fluxo do `general`. */
+export const GENERAL_FLOW_MAX_FILES = 15;
+
+/** Diff por arquivo no recorte de fluxo — profundidade em vez de cobertura. */
+export const GENERAL_FLOW_SNIPPET_CHARS_PER_FILE = 2_000;
+
 /** Retentativas default quando a saída do watchdog é inválida. */
 export const DEFAULT_HUNT_RETRIES = 1;