@payconductor/houndsman 0.10.0 → 0.12.0

package/src/tests/changed-scope.test.ts

@@ -0,0 +1,197 @@
+/**
+ * Escopo do diff — âncoras, símbolos alterados e fallback nos hunks.
+ *
+ * Congela a regra que impede o watchdog de reportar código pré-existente: só as
+ * faixas tocadas pela revisão (símbolo folha do AST ou hunk) são revisáveis.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { changedAnchors } from "../core/ast/diff";
+import type { AstAnalysis, AstFacts, AstSymbol } from "../core/ast/types";
+import {
+	buildChangedScope,
+	formatRanges,
+	formatSymbols,
+	isLineInScope,
+	mergeRanges,
+	summarizeScope,
+} from "../core/changed-scope";
+import type { DiffSource } from "../core/diff-source";
+
+/** Cabecalho padrão de um patch de arquivo. */
+function patch(body: string): string {
+	return `diff --git a/src/a.ts b/src/a.ts\n--- a/src/a.ts\n+++ b/src/a.ts\n${body}`;
+}
+
+function diffOf(patchText: string): DiffSource {
+	return {
+		byFile: new Map([["src/a.ts", patchText]]),
+		churn: new Map(),
+	};
+}
+
+function symbol(
+	overrides: Partial<AstSymbol> & Pick<AstSymbol, "name" | "kind">,
+): AstSymbol {
+	return {
+		exported: false,
+		startLine: 1,
+		endLine: 1,
+		...overrides,
+	};
+}
+
+function analysis(facts: AstFacts): AstAnalysis {
+	return { facts };
+}
+
+const FACTS: AstFacts = {
+	language: "typescript",
+	imports: [],
+	exports: [],
+	decorators: [],
+	hasSyntaxErrors: false,
+	symbols: [
+		symbol({ name: "Outer", kind: "class", startLine: 1, endLine: 20 }),
+		symbol({ name: "Outer.inner", kind: "method", startLine: 5, endLine: 10 }),
+		symbol({ name: "top", kind: "function", startLine: 25, endLine: 30 }),
+	],
+};
+
+describe("changedAnchors", () => {
+	test("adições e remoções apontam para o lado novo", () => {
+		const anchors = changedAnchors(
+			patch(
+				"@@ -10,3 +10,4 @@\n const before = 1;\n-const old = 2;\n+const current = 2;\n+const extra = 3;\n const after = 4;\n",
+			),
+		);
+
+		expect([...anchors.added].sort((a, b) => a - b)).toEqual([11, 12]);
+		expect([...anchors.deletedAt]).toEqual([11]);
+	});
+
+	test("remoção pura ancora no ponto do arquivo (sem consumir linha nova)", () => {
+		const anchors = changedAnchors(patch("@@ -10,2 +10,0 @@\n-a\n-b\n"));
+
+		expect([...anchors.added]).toEqual([]);
+		expect([...anchors.deletedAt]).toEqual([10]);
+	});
+});
+
+describe("buildChangedScope", () => {
+	const entries = [{ path: "src/a.ts", status: "modified" }];
+
+	test("âncora dentro de símbolo folha vira o intervalo do símbolo", () => {
+		const text = patch(
+			[
+				"@@ -2,0 +3,1 @@",
+				"+export const header = 1;",
+				"@@ -7,0 +8,1 @@",
+				"+  const inside = 1;",
+				"@@ -26,0 +27,1 @@",
+				"+  return 1;",
+				"",
+			].join("\n"),
+		);
+		const scope = buildChangedScope({
+			entries,
+			diff: diffOf(text),
+			ast: new Map([["src/a.ts", analysis(FACTS)]]),
+		});
+
+		const file = scope["src/a.ts"];
+		expect(file?.source).toBe("ast");
+		// `inner` (5-10) e `top` (25-30); o container `Outer` não expande.
+		expect(file?.symbols.map((item) => item.name)).toEqual(["Outer.inner", "top"]);
+		// Cabeçalho da classe (linha 3) fica como faixa avulsa.
+		expect(file?.ranges).toEqual([
+			{ start: 3, end: 3 },
+			{ start: 5, end: 10 },
+			{ start: 25, end: 30 },
+		]);
+	});
+
+	test("sem AST cai para os hunks do diff", () => {
+		const text = patch("@@ -10,0 +11,2 @@\n+a\n+b\n");
+		const scope = buildChangedScope({ entries, diff: diffOf(text) });
+
+		const file = scope["src/a.ts"];
+		expect(file?.source).toBe("hunks");
+		expect(file?.symbols).toEqual([]);
+		expect(file?.ranges).toEqual([{ start: 11, end: 12 }]);
+	});
+
+	test("rename/binário sem hunks fica sem faixas", () => {
+		const scope = buildChangedScope({
+			entries: [{ path: "src/a.ts", status: "renamed" }],
+			diff: diffOf(patch("")),
+		});
+
+		expect(scope["src/a.ts"]).toEqual({ ranges: [], symbols: [], source: "hunks" });
+	});
+
+	test("arquivo deletado nem entra no escopo", () => {
+		const scope = buildChangedScope({
+			entries: [{ path: "src/a.ts", status: "deleted" }],
+			diff: diffOf(patch("@@ -1,1 +0,0 @@\n-x\n")),
+		});
+
+		expect(scope["src/a.ts"]).toBeUndefined();
+	});
+});
+
+describe("helpers de escopo", () => {
+	test("isLineInScope respeita as faixas", () => {
+		const scope = {
+			"src/a.ts": {
+				ranges: [{ start: 5, end: 10 }],
+				symbols: [],
+				source: "hunks" as const,
+			},
+		};
+
+		expect(isLineInScope(scope, "src/a.ts", 7)).toBe(true);
+		expect(isLineInScope(scope, "src/a.ts", 11)).toBe(false);
+		expect(isLineInScope(scope, "src/b.ts", 7)).toBe(false);
+	});
+
+	test("mergeRanges une sobrepostos e adjacentes", () => {
+		expect(
+			mergeRanges([
+				{ start: 10, end: 12 },
+				{ start: 11, end: 15 },
+				{ start: 16, end: 18 },
+				{ start: 30, end: 30 },
+			]),
+		).toEqual([
+			{ start: 10, end: 18 },
+			{ start: 30, end: 30 },
+		]);
+	});
+
+	test("formatadores compactos", () => {
+		expect(formatRanges([])).toBe("sem linhas alteradas");
+		expect(
+			formatRanges([
+				{ start: 10, end: 14 },
+				{ start: 22, end: 22 },
+			]),
+		).toBe("10-14, 22");
+		expect(
+			formatSymbols([
+				{ name: "foo", kind: "function", startLine: 10, endLine: 14 },
+			]),
+		).toBe("`foo` (10-14)");
+		expect(
+			summarizeScope({
+				"src/a.ts": {
+					ranges: [{ start: 1, end: 2 }],
+					symbols: [
+						{ name: "foo", kind: "function", startLine: 1, endLine: 2 },
+					],
+					source: "ast",
+				},
+			}),
+		).toEqual({ files: 1, ranges: 1, symbols: 1 });
+	});
+});

package/src/tests/fallback.test.ts

@@ -1,16 +1,10 @@
-/**
- * Fallback de classificação e findings emergentes (lógica/domínio).
- */
+/** Fallback de classificação (arquivos sem dono). */
 
 import { describe, expect, test } from "bun:test";
 import { defineHoundsmanConfig } from "../core/config";
 import { classifyEntries } from "../core/file-classifier";
 import { checkRegistry } from "../core/registry-check";
 import { defineWatchdog } from "../core/types";
-import { AgentState } from "../harness/investigation/agent-state";
-import { EvidenceVerifier } from "../harness/investigation/evidence-verifier";
-import { FindingCritic } from "../harness/investigation/finding-critic";
-import { FindingValidator } from "../harness/validation/finding-validator";
 
 const alpha = defineWatchdog({
 	id: "alpha",
@@ -28,7 +22,6 @@ const fallback = defineWatchdog({
 	description: "Fallback de lógica/domínio.",
 	scope: "arquivos sem dono",
 	fallback: true,
-	allowEmergentFindings: true,
 	rules: [
 		{
 			severity: "attention",
@@ -82,91 +75,3 @@ describe("classificação com fallback", () => {
 		).toBe(true);
 	});
 });
-
-describe("findings emergentes", () => {
-	const file = "a.ts";
-	const content = "const x = 1;\n";
-	const state = new AgentState();
-	const evidence = state.addEvidence({
-		file,
-		startLine: 1,
-		endLine: 1,
-		snippet: content.trim(),
-		kind: "definition",
-		sourceTool: "test",
-		confidence: 0.9,
-	});
-	const draft = {
-		rule: "Lógica: a função fazA na verdade fazB",
-		severity: "blocking" as const,
-		file,
-		line: 1,
-		message: "comportamento diverge do nome",
-		action: "renomear ou corrigir",
-		evidenceIds: [evidence.id],
-		confidence: 0.9,
-	};
-	const verifier = new EvidenceVerifier({
-		allowedFiles: [file],
-		readFile: (path) => (path === file ? content : null),
-	});
-
-	test("crítico aceita e limita a severidade quando habilitado", () => {
-		const critic = new FindingCritic({
-			knownRules: new Set([fallback.rules[0]?.text ?? ""]),
-			verifier,
-			allowEmergentFindings: true,
-		});
-		const decision = critic.reviewOne(draft, state);
-		expect(decision.verdict).toBe("keep");
-		expect(decision.draft.severity).toBe("attention");
-	});
-
-	test("crítico descarta quando o opt-in está desligado", () => {
-		const critic = new FindingCritic({
-			knownRules: new Set([fallback.rules[0]?.text ?? ""]),
-			verifier,
-		});
-		const decision = critic.reviewOne(draft, state);
-		expect(decision.verdict).toBe("drop");
-		expect(decision.reason).toContain("desabilitado");
-	});
-
-	test("validador espelha a mesma regra", () => {
-		const report = {
-			watchdogId: "default",
-			reviewedFiles: [file],
-			skipped: [],
-			findings: [draft],
-		};
-		const allowed = new FindingValidator({
-			watchdogId: "default",
-			knownRules: new Set([fallback.rules[0]?.text ?? ""]),
-			allowedFiles: new Set([file]),
-			overflow: new Set(),
-			readFile: (path) => (path === file ? content : null),
-			allowEmergentFindings: true,
-		}).validate(report);
-		expect(allowed.report.findings[0]?.severity).toBe("attention");
-		expect(allowed.dropped).toHaveLength(0);
-
-		const denied = new FindingValidator({
-			watchdogId: "default",
-			knownRules: new Set([fallback.rules[0]?.text ?? ""]),
-			allowedFiles: new Set([file]),
-			overflow: new Set(),
-			readFile: (path) => (path === file ? content : null),
-		}).validate(report);
-		expect(denied.report.findings).toHaveLength(0);
-	});
-
-	test("finding emergente sem descrição é descartado", () => {
-		const critic = new FindingCritic({
-			knownRules: new Set([fallback.rules[0]?.text ?? ""]),
-			verifier,
-			allowEmergentFindings: true,
-		});
-		const decision = critic.reviewOne({ ...draft, rule: "Lógica:" }, state);
-		expect(decision.verdict).toBe("drop");
-	});
-});

package/src/tests/fixtures/fake-model-provider.ts

@@ -41,7 +41,6 @@ export class FakeModelProvider implements ModelProvider {
 		return {
 			output: output as T,
 			usage: fakeUsage(),
-			steps: 1,
 			finishReason: "stop",
 		};
 	}

package/src/tests/review-scope.test.ts

@@ -9,6 +9,7 @@ import { describe, expect, test } from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { AstService } from "../core/ast/service";
 import { ReviewScopeResolver, type ScopeOptions } from "../core/engine/review-scope";
 import type { FindingState, FindingsStateFile } from "../core/findings-state";
 import { defaultOptions, finalize, prepare, reviewContext } from "../core/orchestrator";
@@ -138,6 +139,35 @@ describe("ReviewScopeResolver", () => {
 			if (scope.kind !== "review") throw new Error("esperava review");
 			expect(scope.classification.mode).toBe("full");
 			expect(scope.classification.headSha).toBe(repo.head);
+			expect(scope.classification.changedScope?.["src/alpha/a.ts"]).toEqual({
+				ranges: [{ start: 1, end: 1 }],
+				symbols: [],
+				source: "hunks",
+			});
+		} finally {
+			process.chdir(originalCwd);
+			repo.cleanup();
+		}
+	});
+
+	test("escopo usa o símbolo AST quando disponível", async () => {
+		const repo = makeRepo();
+		const originalCwd = process.cwd();
+		try {
+			process.chdir(repo.cwd);
+			const ast = new AstService(fakeHoundsmanConfig);
+			const scope = await new ReviewScopeResolver(
+				options({ base: repo.base, full: true }),
+				fakeHoundsmanConfig,
+				ast,
+			).resolve(null, repo.head);
+
+			expect(scope.kind).toBe("review");
+			if (scope.kind !== "review") throw new Error("esperava review");
+			const file = scope.classification.changedScope?.["src/alpha/a.ts"];
+			expect(file?.source).toBe("ast");
+			expect(file?.symbols.map((symbol) => symbol.name)).toEqual(["a"]);
+			expect(file?.ranges).toEqual([{ start: 1, end: 1 }]);
 		} finally {
 			process.chdir(originalCwd);
 			repo.cleanup();
@@ -163,6 +193,9 @@ describe("ReviewScopeResolver", () => {
 			expect(scope.classification.mode).toBe("incremental");
 			expect(scope.classification.reviewedFrom).toBe(repo.base);
 			expect(Object.keys(scope.classification.files)).toEqual(["src/alpha/a.ts"]);
+			expect(scope.classification.changedScope?.["src/alpha/a.ts"]?.ranges).toEqual(
+				[{ start: 1, end: 1 }],
+			);
 			expect(scope.classification.carryover?.map((f) => f.file)).toEqual([
 				"src/alpha/keep.ts",
 			]);

package/src/tests/worktree.test.ts

@@ -24,9 +24,13 @@ import { createGitRunner } from "../core/git-runner";
 import { defaultOptions } from "../core/orchestrator";
 import type { GhRunner } from "../core/services/gh-client";
 import { GitRepository } from "../core/services/git-repository";
-import { parseWorktreeList, WorktreeManager } from "../core/services/worktree-manager";
+import {
+	parseWorktreeList,
+	syncProjectLayer,
+	syncProjectLayerForRoot,
+	WorktreeManager,
+} from "../core/services/worktree-manager";
 import { SQLiteStorageProvider } from "../core/storage/sqlite/sqlite-storage";
-import { parseHuntArgs } from "../harness/hunt/hunt-options";
 import { fakeHoundsmanConfig } from "./fixtures/fake-project";
 
 function git(cwd: string, args: string[]): string {
@@ -122,11 +126,10 @@ function fakeGh(
 }
 
 describe("flags de worktree", () => {
-	test("parse de review/hunt e exclusão mútua", () => {
+	test("parse de review e exclusão mútua", () => {
 		expect(parseReviewArgs(["--pr", "7"]).pr).toBe(7);
 		expect(parseReviewArgs(["--worktree", "/tmp/wt"]).worktree).toBe("/tmp/wt");
 		expect(() => parseReviewArgs(["--pr", "7", "--worktree", "/tmp/wt"])).toThrow();
-		expect(parseHuntArgs(["--pr", "8"]).pr).toBe(8);
 	});
 });
 
@@ -186,6 +189,71 @@ describe("nomes de diretório do worktree", () => {
 	});
 });
 
+describe("camada gerada no worktree", () => {
+	test("espelha `.houndsman/core` do clone principal e ignora origem ausente", () => {
+		const sandbox = makeSandbox();
+		try {
+			const worktree = join(sandbox.root, "wt-layer");
+			mkdirSync(worktree, { recursive: true });
+			mkdirSync(join(sandbox.repo, ".houndsman", "core"), { recursive: true });
+			writeFileSync(
+				join(sandbox.repo, ".houndsman", "core", "types.ts"),
+				"export {};\n",
+			);
+
+			expect(syncProjectLayer(sandbox.repo, worktree)).toBe(true);
+			expect(existsSync(join(worktree, ".houndsman", "core", "types.ts"))).toBe(
+				true,
+			);
+
+			// Sem camada na origem: no-op (fail-open).
+			const empty = join(sandbox.root, "empty");
+			mkdirSync(empty, { recursive: true });
+			expect(syncProjectLayer(empty, worktree)).toBe(false);
+		} finally {
+			sandbox.cleanup();
+		}
+	});
+
+	test("ensure copia a camada e o auto-reparo repõe num worktree existente", () => {
+		const sandbox = makeSandbox();
+		try {
+			mkdirSync(join(sandbox.repo, ".houndsman", "core"), { recursive: true });
+			writeFileSync(
+				join(sandbox.repo, ".houndsman", "core", "types.ts"),
+				"export {};\n",
+			);
+			const manager = new WorktreeManager(
+				new GitRepository(createGitRunner(sandbox.repo)),
+				{
+					repoKey: "path:fake",
+					repoRoot: sandbox.repo,
+					baseDir: sandbox.home,
+				},
+			);
+
+			const ensured = manager.ensure({
+				branch: "feature",
+				ref: sandbox.featureSha,
+			});
+			const layer = join(ensured.path, ".houndsman", "core", "types.ts");
+			expect(existsSync(layer)).toBe(true);
+
+			// Comando rodando no worktree (sem `--pr`) também se auto-repara.
+			rmSync(join(ensured.path, ".houndsman", "core"), {
+				recursive: true,
+				force: true,
+			});
+			expect(syncProjectLayerForRoot(ensured.path)).toBe(true);
+			expect(existsSync(layer)).toBe(true);
+
+			manager.remove("feature");
+		} finally {
+			sandbox.cleanup();
+		}
+	}, 20_000);
+});
+
 describe("WorktreeManager", () => {
 	test("cria detached, reusa o mesmo commit e remove", () => {
 		const sandbox = makeSandbox();

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

@@ -1,51 +0,0 @@
-/** Comando `hunt` — revisão nativa com IA (harness próprio). */
-
-import { resolveReviewWorkspace } from "../../core/engine/review-workspace";
-import { HuntHarness } from "../../harness";
-import { parseHuntArgs } from "../../harness/hunt/hunt-options";
-import type { CliContext, Command } from "./command";
-
-/** Executa o harness nativo. */
-export class HuntCommand implements Command {
-	readonly name = "hunt";
-
-	async run(args: string[], context: CliContext): Promise<number> {
-		const options = parseHuntArgs(args);
-		const config = await context.config();
-		const workspace = resolveReviewWorkspace(
-			{
-				cwd: context.cwd,
-				base: options.base,
-				head: options.head,
-				branch: options.branch,
-				pr: options.pr,
-				worktree: options.worktree,
-			},
-			{ worktreesLocation: config.worktrees?.location },
-		);
-		for (const message of workspace.messages) context.logger.info(message);
-
-		const engine = await context.engine({
-			root: workspace.root,
-			mainRoot: workspace.mainRoot,
-		});
-		const resolved = {
-			...options,
-			branch: workspace.branch,
-			base: workspace.base,
-			head: workspace.head,
-			pr: workspace.prNumber,
-			worktreePath: workspace.worktreePath,
-		};
-		try {
-			const harness = await HuntHarness.from(engine, resolved, context.logger);
-			const result = await harness.run();
-			for (const message of result.messages) context.logger.info(message);
-			if (result.status === "failed") return 1;
-			if (options.failOnBlocking && result.blockers > 0) return 1;
-			return 0;
-		} finally {
-			engine.close();
-		}
-	}
-}

package/src/harness/README.md

@@ -1,15 +0,0 @@
-# `src/harness` — harness nativo do houndsman
-
-Este diretório é o **runtime de agentes do próprio houndsman** (`houndsman hunt`):
-tools read-only, investigação, máquina de estados e o agente revisor.
-
-> O **harness externo** (skill `/houndsman` para ClaudeCode/Copilot/agents) continua em
-> `src/skill/`. Os dois coexistem; o nativo é opt-in.
-
-Regras de dependência:
-
-- `harness/` pode importar `core/` (inclusive `core/ai`).
-- `core/` **nunca** importa `harness/`.
-- `cli/` importa ambos.
-
-Documentação detalhada: [`docs/HARNESS.md`](../../docs/HARNESS.md).

package/src/harness/agent/agent-context.ts

@@ -1,33 +0,0 @@
-/**
- * Contexto de um agente de revisão (um watchdog).
- */
-
-import type { AstAnalysis, AstImpact } from "../../core/ast/types";
-import type { DiffSource } from "../../core/diff-source";
-import type { Watchdog } from "../../core/domain/watchdog";
-import type { WatchdogRenderContext } from "../../core/types";
-import type { RuleAnalysis } from "../investigation/rule-analyzer";
-
-/** Dados imutáveis entregues ao agente. */
-export type AgentContext = {
-	watchdog: Watchdog;
-	projectName: string;
-	branch: string;
-	/** Arquivos do domínio (dentro do orçamento). */
-	files: readonly string[];
-	/** Arquivos do domínio fora do orçamento (não ler; registrar em skipped). */
-	overflow: readonly string[];
-	deleted: readonly string[];
-	docs: readonly string[];
-	context?: WatchdogRenderContext | null;
-	ast: ReadonlyMap<string, AstAnalysis>;
-	impact?: AstImpact;
-	/** Caminho de saída do findings (staging). */
-	outputPath: string;
-	maxSteps: number;
-	maxCalls: number;
-	repoRoot: string;
-	diff: DiffSource;
-	/** Análises determinísticas das regras do watchdog. */
-	rules: readonly RuleAnalysis[];
-};

package/src/harness/agent/agent-errors.ts

@@ -1,30 +0,0 @@
-/**
- * Erros do harness nativo.
- */
-
-/** Falha de configuração/execução do agente. */
-export class AgentError extends Error {
-	constructor(
-		message: string,
-		readonly watchdogId?: string,
-	) {
-		super(message);
-		this.name = "AgentError";
-	}
-}
-
-/** Orçamento de IA/tools esgotado durante a investigação. */
-export class AgentBudgetError extends AgentError {
-	constructor(message: string, watchdogId?: string) {
-		super(message, watchdogId);
-		this.name = "AgentBudgetError";
-	}
-}
-
-/** Saída do modelo inválida após as tentativas permitidas. */
-export class AgentOutputError extends AgentError {
-	constructor(message: string, watchdogId?: string) {
-		super(message, watchdogId);
-		this.name = "AgentOutputError";
-	}
-}

package/src/harness/agent/agent-factory.ts

@@ -1,46 +0,0 @@
-/**
- * Factory de agentes — injeta provider, tools e limites resolvidos.
- */
-
-import type { ModelProvider } from "../../core/ai";
-import type { AstService } from "../../core/ast/service";
-import type { HarnessConfig } from "../config/harness-config";
-import type { ToolPolicy } from "../tools/tool-policy";
-import type { ToolRegistry } from "../tools/tool-registry";
-import type { AgentContext } from "./agent-context";
-import type { AgentReporter } from "./agent-reporter";
-import { ReviewAgent } from "./review-agent";
-
-/** Dependências compartilhadas por todos os agentes. */
-export type AgentFactoryDeps = {
-	provider: ModelProvider;
-	registry: ToolRegistry;
-	policy?: ToolPolicy;
-	reporter: AgentReporter;
-	config: HarnessConfig;
-	ast: AstService;
-	readFile?: (path: string) => string | null;
-};
-
-/** Cria `ReviewAgent`s a partir do contexto de cada watchdog. */
-export class AgentFactory {
-	constructor(private readonly deps: AgentFactoryDeps) {}
-
-	/** Instancia um agente para o contexto. */
-	create(context: AgentContext): ReviewAgent {
-		const { config } = this.deps;
-		return new ReviewAgent({
-			context,
-			provider: this.deps.provider,
-			registry: this.deps.registry,
-			policy: this.deps.policy,
-			reporter: this.deps.reporter,
-			maxOutputTokens: config.maxOutputTokensFor(context.watchdog.id),
-			temperature: config.temperature,
-			providerOptions: config.providerOptions,
-			timeoutMs: config.timeoutMs,
-			ast: this.deps.ast,
-			readFile: this.deps.readFile,
-		});
-	}
-}

package/src/harness/agent/agent-reporter.ts

@@ -1,34 +0,0 @@
-/**
- * Reporter de progresso de um agente.
- *
- * O journal é sempre coletado (`harness-transcript.json`); o console é opcional.
- */
-
-import type { LoggerLike } from "../../core/logging";
-import { ReviewJournal } from "../investigation/review-journal";
-
-/** Interface de progresso. */
-export interface AgentReporter {
-	readonly journal: ReviewJournal;
-	progress(message: string): void;
-}
-
-/** Reporter silencioso (testes). */
-export class SilentReporter implements AgentReporter {
-	readonly journal = new ReviewJournal();
-
-	progress(): void {
-		// intencionalmente silencioso
-	}
-}
-
-/** Reporter apoiado no logger único do CLI. */
-export class LoggerReporter implements AgentReporter {
-	readonly journal = new ReviewJournal();
-
-	constructor(private readonly logger: LoggerLike) {}
-
-	progress(message: string): void {
-		this.logger.progress(message);
-	}
-}