@payconductor/houndsman 0.11.0 → 0.12.0

package/src/tests/harness-agent.test.ts

@@ -1,141 +0,0 @@
-/**
- * ReviewAgent — máquina de estados com provider fake e tools reais.
- */
-
-import { afterAll, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { SilentReporter } from "../harness/agent/agent-reporter";
-import { ReviewAgent } from "../harness/agent/review-agent";
-import { fakeAgentContext, fakeAgentDeps } from "./fixtures/fake-investigation";
-import { FakeModelProvider } from "./fixtures/fake-model-provider";
-
-const RULE = "Nunca usar `any`.";
-
-const dir = mkdtempSync(join(tmpdir(), "houndsman-agent-"));
-mkdirSync(join(dir, "src/alpha"), { recursive: true });
-writeFileSync(join(dir, "src/alpha/a.ts"), "const x: any = 1;\nconsole.log(x);\n");
-afterAll(() => rmSync(dir, { recursive: true, force: true }));
-
-/** Provider que investiga com `read_file_range` e devolve um draft. */
-function investigatingProvider(options: { withEvidence?: boolean } = {}) {
-	return new FakeModelProvider(async (request, index) => {
-		if (index === 0) return { hypotheses: ["uso de any"] };
-		if (index === 1) return { taskIds: ["rule-0"] };
-		const tool = request.tools?.read_file_range;
-		if (!tool) throw new Error("tool read_file_range ausente");
-		const raw = await tool.execute({
-			path: "src/alpha/a.ts",
-			startLine: 1,
-			endLine: 2,
-		});
-		const parsed = JSON.parse(raw) as {
-			evidence?: { id: string }[];
-		};
-		const evidenceId = parsed.evidence?.[0]?.id;
-		return {
-			findingDrafts: [
-				{
-					rule: RULE,
-					severity: "blocking",
-					file: "src/alpha/a.ts",
-					line: 1,
-					message: "Uso de any.",
-					action: "Tipar o valor.",
-					evidenceIds:
-						options.withEvidence === false || !evidenceId ? [] : [evidenceId],
-					confidence: 0.9,
-				},
-			],
-			coverage: [
-				{ rule: RULE, status: "checked" },
-				{ rule: "Validar entrada do usuário.", status: "not_applicable" },
-				{ rule: "Evitar console.log.", status: "checked" },
-			],
-		};
-	});
-}
-
-function buildAgent(provider: FakeModelProvider): {
-	agent: ReviewAgent;
-	reporter: SilentReporter;
-} {
-	const reporter = new SilentReporter();
-	const deps = fakeAgentDeps(provider, {
-		context: fakeAgentContext({ repoRoot: dir }),
-		reporter,
-	});
-	return { agent: new ReviewAgent(deps), reporter };
-}
-
-describe("ReviewAgent", () => {
-	test("ORIENT→PLAN→INVESTIGATE→VERIFY→CONCLUDE com evidência", async () => {
-		const { agent, reporter } = buildAgent(investigatingProvider());
-		const result = await agent.run();
-		expect(result.status).toBe("done");
-		expect(result.report?.findings).toHaveLength(1);
-		expect(result.report?.findings[0]?.evidence).toContain("src/alpha/a.ts");
-		expect(result.report?.reviewedFiles).toContain("src/alpha/a.ts");
-		const transitions = reporter.journal.transitions.map((item) => item.to);
-		expect(transitions).toEqual(["PLAN", "INVESTIGATE", "VERIFY", "CONCLUDE"]);
-		expect(result.state.coverage.size).toBe(3);
-	});
-
-	test("VERIFY é obrigatório: draft sem evidência é descartado", async () => {
-		const { agent } = buildAgent(investigatingProvider({ withEvidence: false }));
-		const result = await agent.run();
-		expect(result.status).toBe("done");
-		expect(result.report?.findings).toHaveLength(0);
-		const coverage = result.state.coverageOf(RULE);
-		expect(coverage?.status).toBe("checked");
-		expect(coverage?.reason).toContain("refutado");
-	});
-
-	test("toda regra termina com cobertura (mesmo sem o modelo cobrir)", async () => {
-		const provider = new FakeModelProvider((_request, index) => {
-			if (index === 0) return { hypotheses: [] };
-			if (index === 1) return { taskIds: [] };
-			return { findingDrafts: [], coverage: [] };
-		});
-		const { agent } = buildAgent(provider);
-		const result = await agent.run();
-		expect(result.state.coverage.size).toBe(3);
-		expect(
-			[...result.state.coverage.values()].every(
-				(item) => item.status === "skipped",
-			),
-		).toBe(true);
-	});
-
-	test("falha do provider vira status failed", async () => {
-		const provider = new FakeModelProvider((_request, index) => {
-			if (index === 0) throw new Error("boom");
-			if (index === 1) throw new Error("boom");
-			throw new Error("429 rate limit");
-		});
-		const { agent } = buildAgent(provider);
-		const result = await agent.run();
-		expect(result.status).toBe("failed");
-		expect(result.error).toContain("429");
-	});
-
-	test("repassa providerOptions da config em toda chamada", async () => {
-		const provider = investigatingProvider();
-		const reporter = new SilentReporter();
-		const agent = new ReviewAgent(
-			fakeAgentDeps(provider, {
-				context: fakeAgentContext({ repoRoot: dir }),
-				reporter,
-				providerOptions: { deepseek: { thinking: { type: "disabled" } } },
-			}),
-		);
-		await agent.run();
-		expect(provider.requests.length).toBeGreaterThan(0);
-		for (const request of provider.requests) {
-			expect(request.providerOptions).toEqual({
-				deepseek: { thinking: { type: "disabled" } },
-			});
-		}
-	});
-});

package/src/tests/harness-investigation.test.ts

@@ -1,206 +0,0 @@
-/**
- * Investigação: planner, evidência, crítico e cobertura.
- */
-
-import { afterAll, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { AgentState } from "../harness/investigation/agent-state";
-import { EvidenceVerifier } from "../harness/investigation/evidence-verifier";
-import { FindingCritic } from "../harness/investigation/finding-critic";
-import { InvestigationPlanner } from "../harness/investigation/investigation-planner";
-import { RuleAnalyzer } from "../harness/investigation/rule-analyzer";
-
-const RULE = "Nunca usar `any`.";
-const analyses = new RuleAnalyzer().analyze([
-	{ severity: "suggestion", text: "Evitar console.log." },
-	{ severity: "blocking", text: RULE },
-	{ severity: "attention", text: "Validar entrada do usuário." },
-]);
-
-const dir = mkdtempSync(join(tmpdir(), "houndsman-evidence-"));
-const file = join(dir, "a.ts");
-writeFileSync(file, "const x: any = 1;\nconsole.log(x);\n");
-afterAll(() => rmSync(dir, { recursive: true, force: true }));
-
-function verifier(): EvidenceVerifier {
-	return new EvidenceVerifier({
-		allowedFiles: ["a.ts"],
-		readFile: (path) =>
-			path === "a.ts" ? "const x: any = 1;\nconsole.log(x);\n" : null,
-	});
-}
-
-describe("InvestigationPlanner", () => {
-	test("prioriza por severidade e calcula estimativa", () => {
-		const plan = new InvestigationPlanner().plan(
-			{ watchdogId: "alpha", files: ["a.ts"], symbols: [] },
-			analyses,
-		);
-		expect(plan.tasks[0]?.rule).toBe(RULE);
-		expect(plan.tasks[0]?.severity).toBe("blocking");
-		expect(plan.totalFiles).toBe(1);
-		expect(plan.estimatedToolCalls).toBeGreaterThan(0);
-	});
-
-	test("filtra arquivos por hint de path", () => {
-		const [analysis] = new RuleAnalyzer().analyze([
-			{
-				severity: "attention",
-				text: "Evitar: query no banco em rota.",
-				hints: { paths: ["^src/alpha/"] },
-			},
-		]);
-		const plan = new InvestigationPlanner().plan(
-			{
-				watchdogId: "alpha",
-				files: ["src/alpha/a.ts", "src/beta/b.ts"],
-				symbols: [],
-			},
-			analysis ? [analysis] : [],
-		);
-		expect(plan.tasks[0]?.files).toEqual(["src/alpha/a.ts"]);
-	});
-});
-
-describe("EvidenceVerifier", () => {
-	test("aceita snippet na linha e reancora quando deslocado", () => {
-		const state = new AgentState();
-		const exact = state.addEvidence({
-			file: "a.ts",
-			startLine: 1,
-			endLine: 1,
-			snippet: "const x: any = 1;",
-			kind: "definition",
-			sourceTool: "t",
-			confidence: 0.9,
-		});
-		const moved = state.addEvidence({
-			file: "a.ts",
-			startLine: 9,
-			endLine: 9,
-			snippet: "console.log(x);",
-			kind: "reference",
-			sourceTool: "t",
-			confidence: 0.7,
-		});
-		expect(verifier().verify(exact).valid).toBe(true);
-		const verdict = verifier().verify(moved);
-		expect(verdict.valid).toBe(true);
-		expect(verdict.startLine).toBe(2);
-	});
-
-	test("rejeita arquivo fora do domínio e snippet inexistente", () => {
-		const state = new AgentState();
-		const outside = state.addEvidence({
-			file: "b.ts",
-			startLine: 1,
-			endLine: 1,
-			snippet: "x",
-			kind: "definition",
-			sourceTool: "t",
-			confidence: 1,
-		});
-		const missing = state.addEvidence({
-			file: "a.ts",
-			startLine: 1,
-			endLine: 1,
-			snippet: "não existe",
-			kind: "definition",
-			sourceTool: "t",
-			confidence: 1,
-		});
-		expect(verifier().verify(outside).valid).toBe(false);
-		expect(verifier().verify(missing).valid).toBe(false);
-	});
-
-	test("draft sem evidência válida é inválido", () => {
-		const state = new AgentState();
-		const evidence = state.addEvidence({
-			file: "a.ts",
-			startLine: 1,
-			endLine: 1,
-			snippet: "const x: any = 1;",
-			kind: "definition",
-			sourceTool: "t",
-			confidence: 0.9,
-		});
-		const draft = {
-			rule: RULE,
-			severity: "blocking" as const,
-			file: "a.ts",
-			line: 1,
-			message: "m",
-			action: "a",
-			evidenceIds: [evidence.id],
-			confidence: 0.9,
-		};
-		expect(verifier().verifyDraft(draft, state).valid).toBe(true);
-		expect(
-			verifier().verifyDraft({ ...draft, evidenceIds: ["nope"] }, state).valid,
-		).toBe(false);
-	});
-});
-
-describe("FindingCritic", () => {
-	const state = new AgentState();
-	const evidence = state.addEvidence({
-		file: "a.ts",
-		startLine: 1,
-		endLine: 1,
-		snippet: "const x: any = 1;",
-		kind: "definition",
-		sourceTool: "t",
-		confidence: 0.9,
-	});
-	const critic = new FindingCritic({
-		knownRules: new Set([RULE]),
-		verifier: verifier(),
-	});
-	const draft = {
-		rule: RULE,
-		severity: "blocking" as const,
-		file: "a.ts",
-		line: 1,
-		message: "m",
-		action: "a",
-		evidenceIds: [evidence.id],
-		confidence: 0.9,
-	};
-
-	test("keep com evidência e confiança", () => {
-		expect(critic.reviewOne(draft, state).verdict).toBe("keep");
-	});
-
-	test("drop sem evidência, sem regra ou confiança baixa", () => {
-		expect(critic.reviewOne({ ...draft, evidenceIds: [] }, state).verdict).toBe(
-			"drop",
-		);
-		expect(critic.reviewOne({ ...draft, rule: "inexistente" }, state).verdict).toBe(
-			"drop",
-		);
-		expect(critic.reviewOne({ ...draft, confidence: 0.2 }, state).verdict).toBe(
-			"drop",
-		);
-	});
-
-	test("downgrade quando a confiança não sustenta a severidade", () => {
-		expect(critic.reviewOne({ ...draft, confidence: 0.5 }, state).verdict).toBe(
-			"downgrade",
-		);
-	});
-});
-
-describe("AgentState", () => {
-	test("cobertura e hipóteses sem duplicar", () => {
-		const state = new AgentState();
-		state.addHypothesis("a");
-		state.addHypothesis("a");
-		expect(state.hypotheses).toEqual(["a"]);
-		state.setCoverage(RULE, "skipped", "motivo");
-		expect(state.isCovered(RULE)).toBe(true);
-		state.setCoverage(RULE, "checked");
-		expect(state.coverageOf(RULE)?.status).toBe("checked");
-	});
-});

package/src/tests/harness-tools.test.ts

@@ -1,148 +0,0 @@
-/**
- * Tools do harness: path guard, limites, cache, budget e redaction.
- */
-
-import { afterAll, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { AstService } from "../core/ast/service";
-import { Watchdog } from "../core/domain/watchdog";
-import { SilentReporter } from "../harness/agent/agent-reporter";
-import { AgentState } from "../harness/investigation/agent-state";
-import type { ToolContext } from "../harness/tools/agent-tool";
-import { BuiltinToolsModule } from "../harness/tools/builtin";
-import { PathGuard } from "../harness/tools/path-guard";
-import { redactSecrets } from "../harness/tools/secret-redactor";
-import { ToolCache } from "../harness/tools/tool-cache";
-import { ToolCallBudget } from "../harness/tools/tool-call-budget";
-import { ToolMiddleware } from "../harness/tools/tool-middleware";
-import { ToolRegistry } from "../harness/tools/tool-registry";
-import { EchoTool } from "./fixtures/fake-agent-tools";
-import { fakeAgentContext } from "./fixtures/fake-investigation";
-import { fakeHoundsmanConfig } from "./fixtures/fake-project";
-
-const dir = mkdtempSync(join(tmpdir(), "houndsman-tools-"));
-mkdirSync(join(dir, "src/alpha"), { recursive: true });
-writeFileSync(
-	join(dir, "src/alpha/a.ts"),
-	"const x: any = 1;\nconsole.log(x);\nconst y = 2;\n",
-);
-afterAll(() => rmSync(dir, { recursive: true, force: true }));
-
-function context(): ToolContext {
-	const state = new AgentState();
-	return {
-		repoRoot: dir,
-		watchdog: new Watchdog(fakeHoundsmanConfig.watchdogs.alpha),
-		diff: { byFile: new Map(), churn: new Map() },
-		ast: new AstService(fakeHoundsmanConfig),
-		state,
-		budget: new ToolCallBudget(20, 10),
-		cache: new ToolCache(),
-		logger: new SilentReporter(),
-		agent: fakeAgentContext({ repoRoot: dir }),
-		rules: new Map(),
-	};
-}
-
-describe("PathGuard", () => {
-	test("bloqueia traversal, .git e .env", () => {
-		const guard = new PathGuard(dir);
-		expect(() => guard.resolvePath("../segredo")).toThrow();
-		expect(() => guard.resolvePath(".git/config")).toThrow();
-		expect(() => guard.resolvePath(".env")).toThrow();
-	});
-
-	test("aceita caminho interno", () => {
-		const guard = new PathGuard(dir);
-		expect(guard.resolvePath("src/alpha/a.ts")).toContain("a.ts");
-	});
-});
-
-describe("read_file_range", () => {
-	test("devolve faixa numerada + evidência com id", async () => {
-		const registry = new ToolRegistry();
-		registry.registerModule(new BuiltinToolsModule());
-		const middleware = new ToolMiddleware();
-		const ctx = context();
-		const result = await registry.execute(
-			"read_file_range",
-			{ path: "src/alpha/a.ts", startLine: 1, endLine: 2 },
-			ctx,
-			middleware,
-		);
-		expect(result.ok).toBe(true);
-		const data = result.data as { content: string };
-		expect(data.content).toContain("1\tconst x: any = 1;");
-		expect(data.content).toContain("2\tconsole.log(x);");
-		expect(result.evidence?.[0]?.id).toBeTruthy();
-		expect(ctx.state.evidence.size).toBe(1);
-	});
-
-	test("caminho fora do repo vira erro estruturado", async () => {
-		const registry = new ToolRegistry();
-		registry.registerModule(new BuiltinToolsModule());
-		const result = await registry.execute(
-			"read_file_range",
-			{ path: "../x", startLine: 1, endLine: 2 },
-			context(),
-			new ToolMiddleware(),
-		);
-		expect(result.ok).toBe(false);
-		expect(result.error).toContain("fora do repositório");
-	});
-});
-
-describe("ToolRegistry / middleware", () => {
-	test("nome duplicado falha no registro", () => {
-		const registry = new ToolRegistry();
-		registry.registerTool(new EchoTool());
-		expect(() => registry.registerTool(new EchoTool())).toThrow();
-	});
-
-	test("resultado em cache não consome budget", async () => {
-		const registry = new ToolRegistry();
-		registry.registerTool(new EchoTool());
-		const middleware = new ToolMiddleware();
-		const ctx = context();
-		await registry.execute("echo", { value: "a" }, ctx, middleware);
-		expect(ctx.budget.total).toBe(1);
-		await registry.execute("echo", { value: "a" }, ctx, middleware);
-		expect(ctx.budget.total).toBe(1);
-		await registry.execute("echo", { value: "b" }, ctx, middleware);
-		expect(ctx.budget.total).toBe(2);
-	});
-
-	test("input inválido vira erro (Zod)", async () => {
-		const registry = new ToolRegistry();
-		registry.registerTool(new EchoTool());
-		const result = await registry.execute(
-			"echo",
-			{ value: 1 },
-			context(),
-			new ToolMiddleware(),
-		);
-		expect(result.ok).toBe(false);
-		expect(result.error).toContain("input inválido");
-	});
-
-	test("budget esgotado interrompe", async () => {
-		const registry = new ToolRegistry();
-		registry.registerTool(new EchoTool());
-		const ctx = context();
-		ctx.budget = new ToolCallBudget(1, 1);
-		const middleware = new ToolMiddleware();
-		await registry.execute("echo", { value: "a" }, ctx, middleware);
-		const second = await registry.execute("echo", { value: "b" }, ctx, middleware);
-		expect(second.ok).toBe(false);
-		expect(second.error).toContain("Orçamento");
-	});
-});
-
-describe("redaction", () => {
-	test("remove tokens e chaves", () => {
-		expect(redactSecrets("token sk-abcdefgh123")).toContain("[REDACTED]");
-		expect(redactSecrets("api_key = segredo")).toContain("[REDACTED]");
-	});
-});

package/src/tests/hunt-command.test.ts

@@ -1,212 +0,0 @@
-/**
- * `hunt` — parser de flags, dry-run e fluxo completo com provider fake.
- */
-
-import { afterAll, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { defineHoundsmanConfig } from "../core/config";
-import { HoundsmanEngine } from "../core/engine/houndsman-engine";
-import { SilentLogger } from "../core/logging";
-import { defineWatchdog } from "../core/types";
-import { HuntHarness } from "../harness/hunt/hunt-harness";
-import { parseHuntArgs } from "../harness/hunt/hunt-options";
-import { FakeModelProvider } from "./fixtures/fake-model-provider";
-
-const RULE = "Nunca usar `any`.";
-
-const configBase = defineHoundsmanConfig({
-	projectName: "Hunt",
-	watchdogs: {
-		alpha: defineWatchdog({
-			id: "alpha",
-			name: "Alpha",
-			description: "Watchdog do hunt.",
-			scope: "src/alpha/**",
-			classify: [{ value: "^src/alpha/" }],
-			rules: [{ severity: "blocking", text: RULE }],
-			contextFiles: [],
-		}),
-	},
-	exclusions: [],
-	docMappings: [],
-});
-
-describe("parseHuntArgs", () => {
-	test("flags e defaults", () => {
-		const options = parseHuntArgs([
-			"--base",
-			"origin/main",
-			"--head",
-			"abc",
-			"--watchdog",
-			"alpha",
-			"--full",
-			"--no-ast",
-			"--resume",
-			"--allow-partial",
-			"--dry-run",
-			"--fail-on-blocking",
-			"--max-calls",
-			"7",
-			"--concurrency",
-			"3",
-			"--model",
-			"m",
-		]);
-		expect(options.base).toBe("origin/main");
-		expect(options.head).toBe("abc");
-		expect(options.watchdog).toBe("alpha");
-		expect(options.full).toBe(true);
-		expect(options.noAst).toBe(true);
-		expect(options.noJev).toBe(true);
-		expect(options.resume).toBe(true);
-		expect(options.allowPartial).toBe(true);
-		expect(options.dryRun).toBe(true);
-		expect(options.failOnBlocking).toBe(true);
-		expect(options.maxCalls).toBe(7);
-		expect(options.concurrency).toBe(3);
-		expect(options.model).toBe("m");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Repo git temporário
-// ---------------------------------------------------------------------------
-
-const cwd = mkdtempSync(join(tmpdir(), "houndsman-hunt-"));
-const originalCwd = process.cwd();
-const originalHome = process.env.HOUNDSMAN_HOME;
-const originalKey = process.env.HOUNDSMAN_DEEP_SEEK_API_KEY;
-let base = "";
-
-function git(args: string[]): string {
-	const result = Bun.spawnSync(["git", ...args], {
-		cwd,
-		stdout: "pipe",
-		stderr: "pipe",
-	});
-	if (result.exitCode !== 0) {
-		throw new Error(`git ${args.join(" ")}: ${result.stderr.toString()}`);
-	}
-	return result.stdout.toString();
-}
-
-function setupRepo(): void {
-	git(["init", "-b", "main"]);
-	git(["config", "user.email", "hunt@example.test"]);
-	git(["config", "user.name", "Hunt"]);
-	git(["config", "commit.gpgsign", "false"]);
-	mkdirSync(join(cwd, "src", "alpha"), { recursive: true });
-	writeFileSync(join(cwd, "src/alpha/a.ts"), "export const a = 1;\n");
-	git(["add", "."]);
-	git(["commit", "-m", "initial"]);
-	base = git(["rev-parse", "HEAD"]).trim();
-	writeFileSync(join(cwd, "src/alpha/a.ts"), "export const a: any = 1;\n");
-	git(["add", "-A"]);
-	git(["commit", "-m", "change"]);
-	process.env.HOUNDSMAN_HOME = join(cwd, ".home");
-	process.chdir(cwd);
-}
-
-function engine(): HoundsmanEngine {
-	return new HoundsmanEngine({
-		...configBase,
-		storage: { provider: "sqlite", path: join(cwd, "houndsman.db") },
-	});
-}
-
-setupRepo();
-afterAll(() => {
-	process.chdir(originalCwd);
-	if (originalHome === undefined) delete process.env.HOUNDSMAN_HOME;
-	else process.env.HOUNDSMAN_HOME = originalHome;
-	if (originalKey === undefined) delete process.env.HOUNDSMAN_DEEP_SEEK_API_KEY;
-	else process.env.HOUNDSMAN_DEEP_SEEK_API_KEY = originalKey;
-	rmSync(cwd, { recursive: true, force: true });
-});
-
-describe("hunt", () => {
-	test("dry-run lista watchdogs sem chamar IA", async () => {
-		const instance = engine();
-		try {
-			const harness = await HuntHarness.from(
-				instance,
-				parseHuntArgs(["--base", base, "--head", "HEAD", "--dry-run"]),
-				new SilentLogger(),
-			);
-			const result = await harness.run();
-			expect(result.status).toBe("dry-run");
-			expect(result.messages.join("\n")).toContain("alpha");
-		} finally {
-			instance.close();
-		}
-	});
-
-	test("sem chave e sem --dry-run falha com mensagem clara", async () => {
-		delete process.env.HOUNDSMAN_DEEP_SEEK_API_KEY;
-		const instance = engine();
-		try {
-			await expect(
-				HuntHarness.from(
-					instance,
-					parseHuntArgs(["--base", base, "--head", "HEAD"]),
-					new SilentLogger(),
-				),
-			).rejects.toThrow(/hunt exige IA configurada/);
-		} finally {
-			instance.close();
-		}
-	});
-
-	test("provider fake investiga, grava findings e finaliza", async () => {
-		const provider = new FakeModelProvider(async (request, index) => {
-			if (index === 0) return { hypotheses: ["any"] };
-			if (index === 1) return { taskIds: ["rule-0"] };
-			const tool = request.tools?.read_file_range;
-			if (!tool) throw new Error("read_file_range ausente");
-			const parsed = JSON.parse(
-				await tool.execute({ path: "src/alpha/a.ts", startLine: 1, endLine: 1 }),
-			) as { evidence?: { id: string }[] };
-			return {
-				findingDrafts: [
-					{
-						rule: RULE,
-						severity: "blocking",
-						file: "src/alpha/a.ts",
-						line: 1,
-						message: "any detectado",
-						action: "tipar",
-						evidenceIds: [parsed.evidence?.[0]?.id].filter(Boolean),
-						confidence: 0.9,
-					},
-				],
-				coverage: [{ rule: RULE, status: "checked" }],
-			};
-		});
-		const instance = engine();
-		try {
-			const harness = await HuntHarness.from(
-				instance,
-				parseHuntArgs(["--base", base, "--head", "HEAD"]),
-				new SilentLogger(),
-				provider,
-			);
-			const result = await harness.run();
-			expect(result.status).toBe("completed");
-			expect(result.blockers).toBe(1);
-			const review = instance.storage.readArtifact(result.reviewId, "review.md");
-			expect(review?.content).toContain("any detectado");
-			const transcript = instance.storage.readArtifact(
-				result.reviewId,
-				"harness-transcript.json",
-			);
-			expect(transcript?.content).toContain("VERIFY");
-			const usage = instance.storage.readArtifact(result.reviewId, "ai-usage.json");
-			expect(usage?.content).toContain('"calls"');
-		} finally {
-			instance.close();
-		}
-	});
-});