/**
 * The agent-callable `ask_jev` tool.
 *
 * The tool is driven the way the model drives it: one call carrying its own
 * prose, the paths it wants read, one command, and a question block. Tests
 * assert what the agent observes — the state Jev was sent, the answers that come
 * back, and what never leaves the process — never private helper order.
 */
import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
import type { AssistantMessage } from "@earendil-works/pi-ai";

const state = vi.hoisted(() => ({
	settingsPath: "",
	commands: new Map<string, { output: string; exitCode: number }>(),
}));

vi.mock("@selesai/code", () => ({
	getSettingsPath: () => state.settingsPath,
	// jev_find runs the real ripgrep on PATH against the temp repo.
	ensureTool: async () => "rg",
	// The same local shell backend the bash tool uses, scripted per command.
	createLocalBashOperations: () => ({
		exec: async (command: string, _cwd: string, options: { onData: (data: Buffer) => void }) => {
			const scripted = state.commands.get(command);
			if (!scripted) return { exitCode: 127 };
			options.onData(Buffer.from(scripted.output, "utf-8"));
			return { exitCode: scripted.exitCode };
		},
	}),
}));

import jevAskToolExtension, {
	askPath,
	childDirectory,
	FIND_BATCH,
	FIND_MAX_REQUESTS,
	FIND_MAX_SOURCE_BYTES,
	FindRequests,
	fitJudgePayloads,
	MAX_ASK_QUESTIONS,
	renderSourceBlocks,
	runJevFind,
	unitView,
} from "./jev-ask-tool.ts";
import { chunkUnits, loadTypeScript, splitSourceUnits } from "./jev-find-source.ts";
import {
	JEV_ROUTING_EVENT,
	type JevAbstainReason,
	type JevFailureDiagnostic,
	serializeJevRequest,
} from "./jev/decisions.ts";
import { jevResponse, providerTemplate } from "./jev/test-support.ts";

const FILE_SENTINEL = "FILE_BODY_MUST_RETURN_TO_JE ONLY";
const COMMAND_SENTINEL = "FAIL rounding test at round.ts:12";

let root: string;
let repo: string;

beforeAll(() => {
	root = mkdtempSync(join(tmpdir(), "jev-ask-tool-"));
	repo = join(root, "repo");
	mkdirSync(join(repo, "src"), { recursive: true });
	writeFileSync(join(repo, "src", "round.ts"), `export const round = () => ${FILE_SENTINEL};\n`, "utf-8");
	state.settingsPath = join(root, "agent", "settings.json");
	mkdirSync(join(root, "agent"), { recursive: true });
});

afterAll(() => rmSync(root, { recursive: true, force: true }));

beforeEach(() => {
	state.commands.clear();
});

/** The answers envelope Jev returns, with either verdict field per question. */
function answerText(answers: Record<string, unknown>): string {
	return JSON.stringify({ answers });
}

interface ToolDefinition {
	name: string;
	description: string;
	promptSnippet?: string;
	promptGuidelines?: string[];
	execute: (
		id: string,
		params: Record<string, unknown>,
		signal: AbortSignal | undefined,
		onUpdate: undefined,
		ctx: unknown,
	) => Promise<{ content: Array<{ type: string; text: string }>; details: Record<string, unknown> }>;
}

interface AskHarness {
	tool: ToolDefinition;
	complete: ReturnType<typeof vi.fn>;
	telemetry: Record<string, unknown>[];
	/** Warnings shown to the user. */
	notices: string[];
	/** The live active-tool loadout the extension may trim or restore. */
	active: string[];
	/** Fire the extension's `before_agent_start` hook, as the session does before every run. */
	beforeRun(): Promise<void>;
	/** Swap credential availability mid-session, as `/tokenin add` would. */
	setCredential(available: boolean): void;
	ask(params: Record<string, unknown>, signal?: AbortSignal): Promise<{ text: string; details: Record<string, unknown> }>;
	/** The decision request Jev was sent, parsed. */
	sent(): Record<string, unknown> | undefined;
	/** Every tool the extension registered, by name. */
	tools: Record<string, ToolDefinition>;
	ctx: unknown;
}

function harness(
	options: { enabled?: boolean; credential?: boolean; template?: boolean; payloadBytes?: number } = {},
): AskHarness {
	writeFileSync(
		state.settingsPath,
		JSON.stringify({
			jevAdvisory: {
				routes: {
					ask: {
						enabled: options.enabled ?? true,
						...(options.payloadBytes === undefined ? {} : { payloadBytes: options.payloadBytes }),
					},
				},
			},
		}),
		"utf-8",
	);
	const telemetry: Record<string, unknown>[] = [];
	const notices: string[] = [];
	const active = ["read", "bash", "ask_jev"];
	const hooks: Record<string, (event: unknown, ctx: unknown) => unknown> = {};
	let credential = options.credential !== false;
	const complete = vi.fn(async () => jevResponse(answerText({})));
	const tools: Record<string, ToolDefinition> = {};
	jevAskToolExtension({
		registerTool: (definition: ToolDefinition) => {
			tools[definition.name] = definition;
		},
		on: (event: string, handler: (event: unknown, ctx: unknown) => unknown) => {
			hooks[event] = handler;
		},
		getActiveTools: () => [...active],
		setActiveTools: (names: string[]) => {
			active.splice(0, active.length, ...names);
		},
		events: {
			emit: (channel: string, data: unknown) => {
				if (channel === JEV_ROUTING_EVENT) telemetry.push(data as Record<string, unknown>);
			},
		},
	} as never);
	const ctx = {
		cwd: repo,
		hasUI: true,
		ui: { notify: (message: string) => notices.push(message) },
		modelRegistry: {
			getAll: () => (options.template === false ? [] : [providerTemplate()]),
			getApiKeyAndHeaders: async () =>
				credential ? { ok: true, apiKey: "key", headers: {} } : { ok: false, error: "no key" },
			complete,
		},
	};
	const tool = tools.ask_jev as ToolDefinition;
	return {
		tool,
		tools,
		ctx,
		complete,
		telemetry,
		notices,
		active,
		async beforeRun() {
			await hooks.before_agent_start?.({ prompt: "x" }, ctx);
		},
		setCredential(available) {
			credential = available;
		},
		async ask(params, signal) {
			const result = await tool.execute("call-1", params, signal, undefined, ctx);
			const content = result.content[0];
			return { text: content?.type === "text" ? content.text : "", details: result.details };
		},
		sent() {
			const call = complete.mock.calls.at(-1) as unknown[] | undefined;
			const content = (call?.[1] as { messages?: Array<{ content?: string }> } | undefined)?.messages?.[0]?.content;
			return typeof content === "string" ? (JSON.parse(content) as Record<string, unknown>) : undefined;
		},
	};
}

function sentBytes(complete: ReturnType<typeof vi.fn>): number {
	const call = complete.mock.calls.at(-1) as unknown[] | undefined;
	const content = (call?.[1] as { messages?: Array<{ content?: string }> } | undefined)?.messages?.[0]?.content;
	return Buffer.byteLength(content ?? "", "utf-8");
}

const CHOICE = {
	type: "choice",
	instructions: "What kind of failure is this?",
	criteria: { bug_in_code: "The code is wrong.", flaky_test: "The test is nondeterministic.", environment: "The setup is wrong." },
};
const NOUL = { type: "noul", instructions: "Do the tests pass?", criteria: { true: "They pass.", false: "They do not." } };
const SCORE = { type: "score", instructions: "How risky is this diff?", criteria: ["safe", "needs review", "dangerous"] };

const TYPICAL = {
	state: "The tests are red and I have not read anything yet.",
	paths: ["src/round.ts"],
	command: "npm test",
	questions: { failure_kind: CHOICE, tests_pass: NOUL },
};

describe("registration", () => {
	it("registers one ask_jev tool carrying its question schema and the prompt nudge", () => {
		const { tool } = harness();
		expect(tool.name).toBe("ask_jev");
		for (const schemaPart of ["choice", "score", "noul", "criteria"]) {
			expect(tool.description).toContain(schemaPart);
		}
		expect(tool.description).toContain("answers only");
		expect(tool.promptSnippet).toBeTruthy();
		expect(tool.promptGuidelines?.[0]).toContain("ask_jev");
	});
});

describe("one state, one call", () => {
	it("assembles prose, code, and command output into one state and returns answers only", async () => {
		state.commands.set("npm test", { output: COMMAND_SENTINEL, exitCode: 1 });
		const session = harness();
		session.complete.mockResolvedValue(
			jevResponse(answerText({ failure_kind: { choice: "bug_in_code", confidence: 0.99 }, tests_pass: { noul: 0.04 } })),
		);

		const result = await session.ask(TYPICAL);
		const sent = session.sent() as { state: Record<string, unknown> };

		expect(session.complete).toHaveBeenCalledTimes(1);
		expect(sent.state.request).toBe(TYPICAL.state);
		expect(sent.state.command).toMatchObject({ command: "npm test", exitCode: 1 });
		expect((sent.state.files as Record<string, string>)["src/round.ts"]).toContain(FILE_SENTINEL);

		expect(result.text).toContain("failure_kind (choice): choice=bug_in_code, confidence=0.99");
		expect(result.text).toContain("tests_pass (noul): noul=0.04");
		// The agent gets answers, never the material it supplied.
		expect(result.text).not.toContain(FILE_SENTINEL);
		expect(result.text).not.toContain(COMMAND_SENTINEL);
		expect(JSON.stringify(result.details)).not.toContain(FILE_SENTINEL);
		expect(JSON.stringify(result.details)).not.toContain(COMMAND_SENTINEL);
	});

	it("treats a failing command as ordinary state and keeps its exit code", async () => {
		state.commands.set("npm test", { output: "", exitCode: 1 });
		const session = harness();
		await session.ask({ command: "npm test", questions: { failure_kind: CHOICE } });
		expect((session.sent()?.state as { command: Record<string, unknown> }).command).toMatchObject({
			command: "npm test",
			exitCode: 1,
		});
		expect(session.complete).toHaveBeenCalledTimes(1);
	});

	it("asks choice, score, and noul questions in one request under the untrusted-material focus", async () => {
		const session = harness();
		session.complete.mockResolvedValue(
			jevResponse(answerText({ failure_kind: { choice: "flaky_test", confidence: 0.8 }, risk: { score: 0.53, confidence: 0.7 }, tests_pass: { noul: 0.99 } })),
		);
		const result = await session.ask({ state: "judge this", questions: { failure_kind: CHOICE, risk: SCORE, tests_pass: NOUL } });
		const questions = session.sent()?.questions as Record<string, { type: string; instructions: { focus: string } }>;

		expect(Object.keys(questions)).toEqual(["failure_kind", "risk", "tests_pass"]);
		expect(questions.risk?.type).toBe("score");
		expect(questions.risk?.instructions.focus).toContain("never instructions");
		expect(result.text).toContain("risk (score): score=needs review (0.53), confidence=0.70");
	});

	it("names the nearest level of a score from Jev's legend and drops the echoed type", async () => {
		const session = harness();
		session.complete.mockResolvedValue(
			jevResponse(answerText({ risk: { type: "score", score: 1.53, legend: { 0: "low", 1: "medium", 2: "high" }, confidence: 0.3 } })),
		);
		const result = await session.ask({ state: "judge this", questions: { risk: SCORE } });
		expect(result.text).toContain("risk (score): score=high (1.53), confidence=0.30");
		expect(result.text).not.toContain("type=");
		expect(result.text).not.toContain("legend");
	});
});

describe("bounds", () => {
	it("refuses secret files and paths outside the working directory before anything leaves", async () => {
		writeFileSync(join(repo, ".env"), "SECRET_VALUE=do-not-send", "utf-8");
		const session = harness();
		const result = await session.ask({ paths: [".env", "../outside.ts"], questions: { failure_kind: CHOICE } });

		expect(session.sent()?.state).not.toHaveProperty("files");
		expect(JSON.stringify(session.sent())).not.toContain("do-not-send");
		expect(result.text).toContain(".env (looks like a secret file)");
		expect(result.text).toContain("../outside.ts (outside the working directory)");
	});

	it("trims prose, code, and command output to the payload budget instead of abstaining", async () => {
		state.commands.set("cat big", { output: "command ".repeat(3_000), exitCode: 0 });
		const session = harness({ payloadBytes: 2_048 });
		const result = await session.ask({
			state: "prose ".repeat(3_000),
			paths: ["src/round.ts"],
			command: "cat big",
			questions: { failure_kind: CHOICE },
		});

		expect(session.complete).toHaveBeenCalledTimes(1);
		expect(sentBytes(session.complete)).toBeLessThanOrEqual(2_048);
		expect(result.text).toContain("Truncated to fit the request budget");
	});

	it("rejects an unusable question block before any call", async () => {
		const session = harness();
		const unknownType = await session.ask({ questions: { q: { type: "magic", instructions: "?" } } });
		expect(unknownType.text).toContain("magic");

		const missingCriteria = await session.ask({ questions: { q: { type: "choice", instructions: "pick one" } } });
		expect(missingCriteria.text).toContain("criteria");

		const tooMany = await session.ask({
			questions: Object.fromEntries(Array.from({ length: MAX_ASK_QUESTIONS + 1 }, (_, i) => [`q${i}`, CHOICE])),
		});
		expect(tooMany.text).toContain(`At most ${MAX_ASK_QUESTIONS}`);

		expect(session.complete).not.toHaveBeenCalled();
	});
});

describe("unavailability", () => {
	it("stays silent while the route is disabled", async () => {
		const session = harness({ enabled: false });
		const result = await session.ask(TYPICAL);
		expect(result.text).toContain("disabled");
		expect(session.complete).not.toHaveBeenCalled();
	});

	it("reports an abstention rather than failing when Jev is unavailable", async () => {
		const noCredential = harness({ credential: false });
		const credentialless = await noCredential.ask({ state: "x", questions: { failure_kind: CHOICE } });
		expect(noCredential.complete).not.toHaveBeenCalled();
		expect(credentialless.text).toContain("no-credential");
		expect(credentialless.details.failure).toBe("no-credential");
		expect(credentialless.text).toContain("failure_kind: no answer (no-credential)");

		const noTemplate = harness({ template: false });
		expect((await noTemplate.ask({ state: "x", questions: { failure_kind: CHOICE } })).text).toContain("no-template");
	});
});

describe("telemetry", () => {
	it("names the unanswered questions and reports decisions without any content", async () => {
		const session = harness();
		session.complete.mockResolvedValue(jevResponse(answerText({ failure_kind: { choice: "flaky_test", confidence: 0.8 } })));
		const result = await session.ask({ state: "SENTINEL_STATE", questions: { failure_kind: CHOICE, tests_pass: NOUL } });

		expect(result.text).toContain("tests_pass: no answer (missing)");
		expect(session.telemetry.at(-1)).toMatchObject({
			event: "decision",
			route: "ask",
			outcome: "jev",
			candidates: 2,
			confidence: "medium",
		});
		const serialized = JSON.stringify(session.telemetry);
		expect(serialized).not.toContain("SENTINEL_STATE");
		expect(serialized).not.toContain("flaky_test");
	});
});

describe("without a reachable Jev", () => {
	it("neither reads the files nor runs the command, and warns once per session", async () => {
		const session = harness({ credential: false });
		const marker = join(repo, "command-ran.txt");
		const result = await session.ask({ state: "x", paths: ["src/round.ts"], command: `touch ${marker}`, questions: { failure_kind: CHOICE } });

		expect(result.text).toContain("Nothing was read, run, or sent");
		expect(existsSync(marker)).toBe(false);
		expect(session.complete).not.toHaveBeenCalled();

		await session.ask({ state: "x", questions: { failure_kind: CHOICE } });
		expect(session.notices).toHaveLength(1);
		expect(session.notices[0]).toContain("/tokenin add");
	});

	it("drops ask_jev from the loadout while Jev is out of reach and restores it once it is back", async () => {
		const session = harness({ credential: false });
		await session.beforeRun();
		expect(session.active).not.toContain("ask_jev");
		// Hiding is silent: a user without a subscription is not nagged every session.
		expect(session.notices).toEqual([]);

		session.setCredential(true);
		await session.beforeRun();
		expect(session.active).toContain("ask_jev");
	});

	it("hides the tool when the route is turned off, and never re-adds a tool it did not remove", async () => {
		const disabled = harness({ enabled: false });
		await disabled.beforeRun();
		expect(disabled.active).not.toContain("ask_jev");

		const trimmed = harness();
		trimmed.active.splice(trimmed.active.indexOf("ask_jev"), 1);
		await trimmed.beforeRun();
		expect(trimmed.active).not.toContain("ask_jev");
	});
});

describe("missing material", () => {
	it("leads with a warning when none of the passed files reached Jev, and says why each was skipped", async () => {
		const session = harness();
		session.complete.mockResolvedValue(jevResponse(answerText({ failure_kind: { choice: "bug_in_code", confidence: 0.7 } })));
		const result = await session.ask({ state: "x", paths: ["src/missing.ts", "src"], questions: { failure_kind: CHOICE } });

		const lines = result.text.split("\n");
		expect(lines[1]).toContain("WARNING: Jev answered without any of the 2 files you passed");
		expect(lines[1]).toContain("src/missing.ts (not found)");
		expect(lines[1]).toContain("src (not a file)");
		expect(lines[1]).toContain(repo);
	});

	it("names partly skipped files before the answers, without the all-missing warning", async () => {
		const session = harness();
		session.complete.mockResolvedValue(jevResponse(answerText({ failure_kind: { choice: "bug_in_code", confidence: 0.7 } })));
		const result = await session.ask({ state: "x", paths: ["src/round.ts", "src/missing.ts"], questions: { failure_kind: CHOICE } });

		expect(result.text.split("\n")[1]).toBe("Not sent to Jev: src/missing.ts (not found).");
		expect(result.text).not.toContain("WARNING");
	});
});

describe("jev_find", () => {
	const find = async (session: AskHarness, params: Record<string, unknown>) => {
		const result = await session.tools.jev_find.execute("call-f", params, undefined, undefined, session.ctx);
		return { text: result.content[0]?.text ?? "", details: result.details };
	};

	type Stage = "directories" | "files" | "units";
	/**
	 * A fake Jev for `runJevFind`: it reads each request the way Jev would (state keyed by stage,
	 * one noul per quoted key) and answers with `decide`, refusing an oversized request exactly as
	 * the real transport does. `fail` scripts whole-request failures by stage and attempt.
	 */
	function fakeJev(
		decide: (stage: Stage, key: string) => number | undefined,
		options: {
			maxBytes?: number;
			fail?: (stage: Stage, attempt: number) => JevAbstainReason | undefined;
			diagnostic?: JevFailureDiagnostic;
		} = {},
	) {
		const calls: Array<{ stage: Stage; keys: string[]; bytes: number; payload: Record<string, unknown> }> = [];
		const ask = async (payload: Record<string, unknown>) => {
			const state = payload.state as Record<string, unknown>;
			const stage = (["directories", "files", "units"] as const).find((key) => key in state) as Stage;
			const questions = payload.questions as Record<string, { instructions: { question: string } }>;
			const keys = Object.values(questions).map((q) => /"([^"]+)"/.exec(q.instructions.question)?.[1] ?? "");
			const bytes = Buffer.byteLength(JSON.stringify(payload), "utf-8");
			calls.push({ stage, keys, bytes, payload });
			if (serializeJevRequest(payload, options.maxBytes ?? 32 * 1024) === undefined) {
				return { failure: "overflow" as const, elapsedMs: 0 };
			}
			const failure = options.fail?.(stage, calls.filter((call) => call.stage === stage).length);
			if (failure) return { failure, ...(options.diagnostic ? { diagnostic: options.diagnostic } : {}), elapsedMs: 1 };
			const answers: Record<string, unknown> = {};
			Object.keys(questions).forEach((name, index) => {
				const noul = decide(stage, keys[index]);
				if (noul !== undefined) answers[name] = { noul };
			});
			return { answers, elapsedMs: 1 };
		};
		return { ask, calls, keys: (stage: Stage) => calls.filter((call) => call.stage === stage).flatMap((call) => call.keys) };
	}

	let tree: string;
	const RETRY_SOURCE = [
		'import { x } from "./x";',
		"",
		"/** Doubles the delay on every retry. */",
		"export function retryBackoff(attempt: number) {",
		"\treturn 100 * 2 ** attempt;",
		"}",
		"",
		"export const unrelated = x; // not the retry path",
		"",
	].join("\n");

	beforeAll(() => {
		writeFileSync(join(repo, "src", "other.ts"), "// mentions round only in passing\nexport const x = 1;\n", "utf-8");
		writeFileSync(join(repo, ".env"), "round=SECRET_ENV_VALUE\n", "utf-8");
		// 86 files: alpha/ (30), beta/core/ (30), beta/extra/ (25), and README.md at the root.
		tree = join(root, "tree");
		for (const [dir, count] of [["alpha", 30], ["beta/core", 30], ["beta/extra", 25]] as const) {
			mkdirSync(join(tree, dir), { recursive: true });
			for (let i = 0; i < count; i += 1) writeFileSync(join(tree, dir, `f${i}.ts`), `export const v${i} = ${i};\n`, "utf-8");
		}
		writeFileSync(join(tree, "beta/core/f3.ts"), RETRY_SOURCE, "utf-8");
		writeFileSync(join(tree, "README.md"), "# Tree\n\nA fixture.\n", "utf-8");
	});

	const QUESTION = "how is the retry backoff computed";
	const TREE_VERDICTS = (stage: Stage, key: string): number | undefined => {
		if (stage === "directories") return ({ "alpha/": 0.1, "beta/": 0.9, "beta/core/": 0.8, "beta/extra/": 0.2 } as Record<string, number>)[key];
		if (stage === "files") return key === "beta/core/f3.ts" ? 0.95 : 0.05;
		return key.includes("retryBackoff") ? 0.9 : 0.1;
	};

	describe("directory descent", () => {
		it("prunes a rejected directory and recurses into a kept one, judging root files alongside", async () => {
			const jev = fakeJev(TREE_VERDICTS);
			const result = await runJevFind({ rg: "rg", cwd: tree, root: ".", question: QUESTION, maxBytes: 32 * 1024, model: "jev-test", ask: jev.ask });

			expect(jev.keys("directories")).toEqual(["beta/", "alpha/", "beta/core/", "beta/extra/"]);
			// The kept directory is described by its most promising files and keyword hits.
			const betaState = (jev.calls[0].payload.state as { directories: Record<string, string> }).directories["beta/"];
			expect(betaState).toMatch(/^55 file\(s\): core\/f3\.ts/);
			expect(betaState).toContain("Keyword hits:\ncore/f3.ts L3: /** Doubles the delay on every retry. */");
			const judgedFiles = jev.keys("files");
			expect(judgedFiles).toHaveLength(31);
			expect(judgedFiles).toContain("README.md");
			expect(judgedFiles.some((path) => path.startsWith("alpha/") || path.startsWith("beta/extra/"))).toBe(false);

			expect(result.text).toMatch(/^jev_find: 1 relevant file\(s\) \(judged 31 of 86 candidates via jev-test in \d+ms\)$/m);
			expect(result.text).toContain("Jev ruled out 2 directories holding 55 file(s).");
			expect(result.text).toContain("- beta/core/f3.ts (0.95) — reading leads: retryBackoff lines 3-6");
			expect(result.text.trimEnd().endsWith("End context.")).toBe(true);
			expect(result.details).toMatchObject({ total: 86, judged: 31, relevant: 1 });
		});

		it("keeps directories whose question failed, as unknown rather than rejected", async () => {
			const jev = fakeJev(TREE_VERDICTS, { fail: (stage) => (stage === "directories" ? "timeout" : undefined) });
			const result = await runJevFind({ rg: "rg", cwd: tree, root: ".", question: QUESTION, maxBytes: 32 * 1024, model: "jev-test", ask: jev.ask });

			const judgedFiles = jev.keys("files");
			expect(judgedFiles).toHaveLength(86);
			expect(judgedFiles).toContain("alpha/f0.ts");
			expect(result.text).not.toContain("ruled out");
			expect(result.text).toMatch(/directories were kept unjudged \(timeout\)/);
			expect(result.text).toContain('Source block "beta/core/f3.ts" lines 3-6:');
		});

		it("stops free descent at the directory depth limit", async () => {
			const deepTree = join(root, "deep-tree");
			for (const branch of ["one", "two"]) {
				const dir = join(deepTree, "a", "b", "c", "d", "e", branch);
				mkdirSync(dir, { recursive: true });
				for (let i = 0; i < 30; i += 1) writeFileSync(join(dir, `backoff${i}.ts`), `export const backoff${i} = ${i};\n`, "utf-8");
			}
			const jev = fakeJev(() => 0.9);
			const result = await runJevFind({
				rg: "rg",
				cwd: deepTree,
				root: ".",
				question: "backoff",
				maxBytes: 32 * 1024,
				model: "jev-test",
				ask: jev.ask,
			});

			expect(jev.keys("directories")).toEqual([]);
			expect(jev.keys("files")).toHaveLength(60);
			expect(result.details.requests).toBeLessThanOrEqual(FIND_MAX_REQUESTS);
		});

		it("names the next directory level below a root", () => {
			expect(childDirectory("src/a/b.ts", ".")).toBe("src");
			expect(childDirectory("src/a/b.ts", "src")).toBe("src/a");
			expect(childDirectory("src/b.ts", "src")).toBeUndefined();
		});
	});

	describe("source units", () => {
		it("splits TypeScript into statements, merged imports, and class members that keep their header", async () => {
			const ts = await loadTypeScript();
			expect(ts).toBeDefined();
			const filler = Array.from({ length: 40 }, (_, i) => `\t\tconst step${i} = ${i};`);
			const text = [
				'import { a } from "a";', // 1
				'import { b } from "b";', // 2
				"", // 3
				"// ---- section banner ----", // 4
				"", // 5
				"/** Adds one. */", // 6
				"export function add(x: number) {", // 7
				"\treturn x + a + b;", // 8
				"}", // 9
				"", // 10
				"export class Big {", // 11
				"\t/** The first step. */", // 12
				"\tfirst() {", // 13
				...filler, // 14-53
				"\t}", // 54
				"\tsecond() { return 2; } // trailing note", // 55
				"}", // 56
				"",
			].join("\n");
			expect(splitSourceUnits("x.ts", text, ts)).toEqual([
				{ name: "imports", start: 1, end: 2 },
				{ name: "add", start: 6, end: 9 },
				{ name: "Big.first", start: 12, end: 54, header: 11 },
				{ name: "Big.second", start: 55, end: 55, header: 11 },
			]);
		});

		it("chunks other files, and scripts when TypeScript is missing, by blank lines into at most 40 lines", () => {
			const long = Array.from({ length: 45 }, (_, i) => `line ${i}`);
			const text = ["# Title", "intro", "", "## Setup", "run it", "", ...long, ""].join("\n");
			expect(splitSourceUnits("README.md", text, undefined)).toEqual([
				{ name: "# Title", start: 1, end: 5 },
				{ name: "line 0", start: 7, end: 46 },
				{ name: "line 40", start: 47, end: 51 },
			]);
			expect(splitSourceUnits("x.ts", RETRY_SOURCE, undefined)).toEqual(chunkUnits(RETRY_SOURCE));
		});

		it("returns accepted units verbatim with their own line numbers", async () => {
			const jev = fakeJev(TREE_VERDICTS);
			const result = await runJevFind({
				rg: "rg",
				cwd: tree,
				root: "beta/core",
				question: QUESTION,
				maxBytes: 32 * 1024,
				model: "jev-test",
				ask: jev.ask,
			});
			const block = result.text.split('Source block "beta/core/f3.ts" lines 3-6:\n')[1]?.split("\n").slice(0, 4);
			expect(block).toEqual(RETRY_SOURCE.split("\n").slice(2, 6).map((line, i) => `${i + 3}: ${line}`));
			// Only the unit Jev accepted is returned; the rejected one is not.
			expect(jev.keys("units")).toContain("beta/core/f3.ts lines 8-8 (unrelated)");
			expect(result.text).not.toContain("8: export const unrelated");
		});

		it("falls back to the matching source unit when Jev cannot judge the units", async () => {
			const jev = fakeJev(TREE_VERDICTS, { fail: (stage) => (stage === "units" ? "timeout" : undefined) });
			const result = await runJevFind({ rg: "rg", cwd: tree, root: "beta/core", question: QUESTION, maxBytes: 32 * 1024, model: "jev-test", ask: jev.ask });

			expect(result.text).toContain("- beta/core/f3.ts (0.95) — reading leads: retryBackoff lines 3-6");
			expect(result.text).toContain("Jev did not judge the source units of 1 file(s) (timeout); matching source units or keyword windows are shown instead.");
			expect(result.text).toContain('Source block "beta/core/f3.ts" lines 3-6:\n3: /** Doubles the delay on every retry. */');
			expect(result.text).not.toContain("1: import { x }");
		});

		it("keeps the returned source within the output budget", async () => {
			const big = join(root, "big");
			mkdirSync(big, { recursive: true });
			const fn = (n: number) => [
				`export function retry${n}() {`,
				...Array.from({ length: 58 }, (_, i) => `\tconst backoff${i} = "${"x".repeat(60)}";`),
				"}",
				"",
			];
			writeFileSync(join(big, "big.ts"), Array.from({ length: 8 }, (_, n) => fn(n)).flat().join("\n"), "utf-8");
			const jev = fakeJev(() => 0.9);
			const result = await runJevFind({ rg: "rg", cwd: big, root: ".", question: QUESTION, maxBytes: 32 * 1024, model: "jev-test", ask: jev.ask });

			expect(result.details.sourceBytes).toBeLessThanOrEqual(FIND_MAX_SOURCE_BYTES);
			expect(result.details.sourceBytes).toBeGreaterThan(FIND_MAX_SOURCE_BYTES / 2);
			expect(result.text).toMatch(/source block\(s\) left out to stay within 16 KB/);
			// Every numbered line is the file's own line under its own number.
			const rows = readFileSync(join(big, "big.ts"), "utf-8").split("\n");
			for (const match of result.text.matchAll(/^(\d+): (.*)$/gm)) expect(rows[Number(match[1]) - 1]).toBe(match[2]);
		});

		it("clips a block to the byte budget and leaves out one that cannot show three lines", () => {
			const rows = Array.from({ length: 20 }, (_, i) => `row ${i + 1}`);
			const unit = { name: "u", start: 1, end: 20 };
			const rendered = renderSourceBlocks(
				[
					{ path: "a.txt", unit, view: unitView(unit, undefined), rows },
					{ path: "b.txt", unit, view: unitView(unit, undefined), rows },
				],
				60,
			);
			expect(rendered.bytes).toBeLessThanOrEqual(60);
			expect(rendered.lines).toEqual(['', 'Source block "a.txt" lines 1-20:', "1: row 1", "2: row 2", "3: row 3", "4: row 4", "5: row 5", "6: row 6", "…"]);
			expect(rendered.omitted).toBe(1);
		});

		it("shows a long unit around its best keyword line", () => {
			expect(unitView({ name: "f", start: 10, end: 200 }, 150, 20)).toEqual([10, 0, ...Array.from({ length: 19 }, (_, i) => 140 + i), 0]);
			expect(unitView({ name: "m", start: 30, end: 31, header: 5 }, undefined)).toEqual([5, 0, 30, 31]);
		});
	});

	describe("reliability", () => {
		it("retries a transport failure once and then judges", async () => {
			const jev = fakeJev((stage, key) => (stage === "files" ? (key.endsWith("round.ts") ? 0.9 : 0.1) : 0.9), {
				fail: (stage, attempt) => (stage === "files" && attempt === 1 ? "transport" : undefined),
			});
			const result = await runJevFind({ rg: "rg", cwd: repo, root: "src", question: "rounding", maxBytes: 32 * 1024, model: "jev-test", ask: jev.ask });

			expect(jev.calls.filter((call) => call.stage === "files")).toHaveLength(2);
			expect(result.details).toMatchObject({ judged: 2, retried: 1 });
			expect(result.text).toContain("- src/round.ts (0.90)");
		});

		it("retries only once, then still returns ripgrep-ranked source", async () => {
			const jev = fakeJev(() => 0.9, { fail: () => "transport" });
			const result = await runJevFind({ rg: "rg", cwd: repo, root: "src", question: "rounding", maxBytes: 32 * 1024, model: "jev-test", ask: jev.ask });

			expect(jev.calls).toHaveLength(2);
			expect(result.text).toMatch(/^jev_find: Jev did not judge \(transport\); 2 candidate file\(s\), ranked by ripgrep:/);
			expect(result.text).toContain('Source block "src/round.ts" lines 1-1:');
		});

		it("reports sanitized provider status and returns the matching source unit on transport failure", async () => {
			const jev = fakeJev(TREE_VERDICTS, {
				fail: () => "transport",
				diagnostic: { kind: "provider-error", httpStatus: 503 },
			});
			const result = await runJevFind({
				rg: "rg",
				cwd: tree,
				root: "beta/core",
				question: QUESTION,
				pattern: "retry",
				maxBytes: 32 * 1024,
				model: "jev-test",
				ask: jev.ask,
			});

			expect(result.text).toContain("Diagnostic: Jev provider request failed (HTTP 503).");
			expect(result.details).toMatchObject({ failure: "transport", diagnostic: { kind: "provider-error", httpStatus: 503 } });
			expect(result.text).toContain("retryBackoff lines 3-6");
			expect(result.text).toContain('Source block "beta/core/f3.ts" lines 3-6:\n3: /** Doubles the delay on every retry. */');
		});

		it("never sends more than the request cap", async () => {
			const asked: number[] = [];
			const requests = new FindRequests(async () => {
				asked.push(1);
				return { failure: "transport", elapsedMs: 0 };
			}, 3);
			const results = await requests.sendAll([{}, {}, {}, {}, {}], 5);
			expect(asked).toHaveLength(3);
			expect(results.slice(3)).toEqual([undefined, undefined]);
			expect(requests.left).toBe(0);
		});

		it("fits every payload in every stage within maxBytes (the overflow regression)", async () => {
			// The old fit gave up once snippets hit 64 bytes and sent the rest oversized: the questions, paths,
			// and scaffolding of a full batch alone can outgrow a small budget.
			const long = `src/${"deeply/nested/".repeat(12)}file.ts`;
			const items = Array.from({ length: FIND_BATCH }, (_, i) => ({ key: `${long}${i}`, text: '"\n\t\\'.repeat(500), question: `Is "${long}${i}" relevant?` }));
			const stage = { request: "q", stateKey: "files", criteria: { true: "yes", false: "no" } };
			const fitted = fitJudgePayloads(stage, items, 4 * 1024);
			expect(fitted.dropped).toEqual([]);
			expect(fitted.payloads.flatMap((entry) => entry.items).sort((a, b) => a - b)).toEqual(items.map((_, i) => i));
			for (const entry of fitted.payloads) expect(serializeJevRequest(entry.payload, 4 * 1024)).toBeDefined();
			// An item that cannot fit alone is dropped, never sent oversized.
			expect(fitJudgePayloads(stage, [{ key: "k", text: "", question: "x".repeat(5_000) }], 4 * 1024)).toEqual({ payloads: [], dropped: [0] });

			const maxBytes = 6 * 1024;
			const descent = fakeJev(TREE_VERDICTS, { maxBytes });
			await runJevFind({ rg: "rg", cwd: tree, root: ".", question: `${QUESTION} ${"really ".repeat(2_000)}`, maxBytes, model: "jev-test", ask: descent.ask });
			const units = fakeJev(TREE_VERDICTS, { maxBytes });
			await runJevFind({ rg: "rg", cwd: tree, root: "beta/core", question: QUESTION, maxBytes, model: "jev-test", ask: units.ask });
			const calls = [...descent.calls, ...units.calls];
			expect(new Set(calls.map((call) => call.stage))).toEqual(new Set(["directories", "files", "units"]));
			for (const call of calls) expect(call.bytes).toBeLessThanOrEqual(maxBytes);
			expect(descent.calls.length).toBeLessThanOrEqual(FIND_MAX_REQUESTS);
		});
	});

	it("registers jev_find as a finder that returns source, pointing subagents at it", () => {
		const tool = harness().tools.jev_find;
		expect(tool.description).toContain("verbatim");
		expect(tool.description).not.toMatch(/never contents|pointers only/i);
		expect(tool.description).toContain(".gitignore");
		expect(tool.promptSnippet).toContain("source");
		expect(tool.promptGuidelines?.join("\n")).toContain("subagent");
	});

	it("ranks files, returns the accepted source verbatim, and never sends secret files", async () => {
		const session = harness();
		// Jev: anything naming round.ts is relevant, the rest are not.
		session.complete.mockImplementation(async (_model: unknown, request: { messages: Array<{ content: string }> }) => {
			const sent = JSON.parse(request.messages[0].content) as { questions: Record<string, { instructions: { question: string } }> };
			const answers = Object.fromEntries(
				Object.entries(sent.questions).map(([name, q]) => [name, { noul: q.instructions.question.includes("round.ts") ? 0.93 : 0.08 }]),
			);
			return jevResponse(answerText(answers));
		});
		const result = await find(session, { question: "where is rounding implemented", pattern: "round", ignoreCase: true });

		expect(result.text).toMatch(/^jev_find: 1 relevant file\(s\) \(judged 2 of 2 candidates via jev-1\.13 in \d+ms\)/);
		// The sentinel line is not valid TypeScript; the parser recovers and still names the declaration.
		expect(result.text).toMatch(/^- src\/round\.ts \(0\.93\) — reading leads: round\b.* lines 1-1$/m);
		expect(result.text).toContain(`Source block "src/round.ts" lines 1-1:\n1: export const round = () => ${FILE_SENTINEL};`);
		expect(result.text).not.toContain("- src/other.ts");
		const everything = JSON.stringify(session.complete.mock.calls);
		expect(everything).toContain("src/other.ts");
		expect(everything).not.toContain("SECRET_ENV_VALUE");
		expect(session.telemetry.at(-1)).toMatchObject({ route: "find", outcome: "jev" });
	});

	it("still returns ripgrep-ranked files and their source when Jev is unreachable", async () => {
		const session = harness({ credential: false });
		const result = await find(session, { question: "rounding", path: "src", glob: "*.ts" });

		expect(session.complete).not.toHaveBeenCalled();
		const lines = result.text.split("\n");
		expect(lines[0]).toBe("jev_find: Jev did not judge (no-credential); 2 candidate file(s), ranked by ripgrep:");
		// The question word in the path orders the unjudged listing.
		expect(lines[1]).toBe("- src/round.ts — file head lines 1-1");
		expect(result.text).toContain(`Source block "src/round.ts" lines 1-1:\n1: export const round = () => ${FILE_SENTINEL};`);
		expect(result.text.trimEnd().endsWith("End context.")).toBe(true);
		expect(session.telemetry.at(-1)).toMatchObject({ route: "find", outcome: "fallback", reason: "no-credential" });
	});

	it("refuses a search root outside the working directory", async () => {
		const result = await find(harness(), { question: "x", path: ".." });
		expect(result.text).toContain("outside the working directory");
	});
});

describe("askPath symlinks", () => {
	it("refuses links that escape the working directory or point at a secret", () => {
		const root = mkdtempSync(join(tmpdir(), "ask-path-"));
		const cwd = join(root, "repo");
		mkdirSync(cwd);
		writeFileSync(join(root, "outside.txt"), "x");
		writeFileSync(join(cwd, ".env"), "SECRET=1");
		writeFileSync(join(cwd, "ok.ts"), "x");
		symlinkSync(join(root, "outside.txt"), join(cwd, "escape.txt"));
		symlinkSync(root, join(cwd, "up"));
		symlinkSync(join(cwd, ".env"), join(cwd, "notes.txt"));
		try {
			expect(askPath("escape.txt", cwd)).toEqual({ refused: "outside the working directory" });
			expect(askPath("up/outside.txt", cwd)).toEqual({ refused: "outside the working directory" });
			expect(askPath("notes.txt", cwd)).toEqual({ refused: "looks like a secret file" });
			expect(askPath("ok.ts", cwd)).toEqual({ full: join(cwd, "ok.ts") });
			expect(askPath("missing.ts", cwd)).toEqual({ full: join(cwd, "missing.ts") });
		} finally {
			rmSync(root, { recursive: true, force: true });
		}
	});
});