Skip to content

A one-of-a-kind resume builder that keeps your privacy in mind. Completely secure, customizable, portable, open-source and free forever. Try it out today!

83.2 KB
Raw Blame
import type { ProposeEditsOutput } from "@reactive-resume/ai/tools/agent-tool-contracts";
import type { UIMessage } from "ai";
import type { AddressInfo } from "node:net";
import { randomUUID } from "node:crypto";
import { readdir, readFile } from "node:fs/promises";
import { createServer } from "node:http";
import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vite-plus/test";
import { createRouterClient } from "@orpc/server";
import { generateText, stepCountIs, streamText, tool } from "ai";
import { strFromU8, unzipSync, zipSync, strToU8 } from "fflate";
import { Pool } from "pg";
import { z } from "zod";
import { letterDraftSystemPrompt } from "@reactive-resume/ai/prompts";
import { aiDestination } from "@reactive-resume/ai/types";
import { db, withDatabasePool } from "@reactive-resume/db/client";
import * as tables from "@reactive-resume/db/schema";
import { coverLetterTextToHtml } from "@reactive-resume/resume/cover-letter";
import { aiOperationIds } from "@reactive-resume/schema/ai-usage";
import { sampleResumeData } from "@reactive-resume/schema/resume/sample";
import { buildAccountZip } from "@reactive-resume/utils/account-zip";
import { loadDocument } from "../agent/document";
import { upsertAssistantUiMessage } from "../agent/messages-persistence";
import { agentRouter } from "../agent/router";
import { aiProvidersService } from "../ai-providers/service";
import { aiRouter as applicationAiRouter } from "../applications/ai";
import { applicationsRouter } from "../applications/router";
import { authRouter } from "../auth/router";
import { authService } from "../auth/service";
import { careerRouter } from "../career/router";
import { coverLettersRouter } from "../cover-letters/router";
import { assertDocumentVersion } from "../documents/ownership";
import { documentsRouter } from "../documents/router";
import { resumeRouter } from "../resume/router";
import { webAccessService } from "../web-access/credentials";
import { aiRouter } from "./router";
import { getModel } from "./service";
import { createAiUsage, readAiUsage, readWeeklyAiUsage } from "./usage";

vi.mock("@reactive-resume/env/server", async (original) => {
	const actual = await original<typeof import("@reactive-resume/env/server")>();
	return {
		env: {
			...actual.env,
			AI_PROVIDER: undefined,
			AI_MODEL: undefined,
			AI_API_KEY: undefined,
			AI_BASE_URL: undefined,
			FLAG_ALLOW_UNSAFE_AI_BASE_URL: true,
		},
	};
});

const databaseUrl = process.env.INTEGRATIONS_TEST_DATABASE_URL;
describe.skipIf(!databaseUrl)("AI request metering through installed SDK, protected routers and PostgreSQL", () => {
	const namespace = `rx207_usage_${randomUUID().replaceAll("-", "")}`;
	const admin = new Pool({ connectionString: databaseUrl });
	let pool: Pool;
	let baseURL: string;
	let user: typeof tables.user.$inferSelect;
	let mode:
		| "score"
		| "score-hold"
		| "prepare"
		| "text"
		| "retry"
		| "tools"
		| "stream"
		| "failure"
		| "hold"
		| "reply"
		| "answer"
		| "writing"
		| "resume"
		| "agent"
		| "letter"
		| "tailoring"
		| "improve"
		| "native-search";
	let failLetter = false;
	let agentChanges: unknown[] = [];
	let agentStep = 0;
	let release = () => {};
	let arrived = () => {};
	let disconnected = () => {};
	let requests: { model: string; path: string }[] = [];
	let requestMessages: unknown[][] = [];
	const server = createServer((req, res) => {
		const onDisconnect = disconnected;
		res.once("close", () => {
			if (!res.writableEnded) onDisconnect();
		});
		let raw = "";
		req.on("data", (chunk) => {
			raw += chunk;
		});
		req.on("end", () => {
			void (async () => {
				const body = JSON.parse(raw) as { model: string; messages?: unknown[]; stream?: boolean; input?: unknown };
				requests.push({ model: body.model, path: req.url ?? "" });
				requestMessages.push(body.messages ?? []);
				arrived();
				if (mode === "native-search") {
					if (req.url === "/v1/firecrawl") {
						res.writeHead(401, { "content-type": "application/json" });
						res.end(JSON.stringify({ success: false, error: "Fictional rejected web key" }));
						return;
					}
					if (!body.stream) {
						res.writeHead(200, { "content-type": "application/json" });
						res.end(
							JSON.stringify({
								id: "source",
								object: "response",
								created_at: 1,
								model: body.model,
								status: "completed",
								output: [
									{
										type: "web_search_call",
										id: "search",
										status: "completed",
										action: { type: "search", query: "Fictional engineer" },
									},
									{
										type: "message",
										id: "source-message",
										role: "assistant",
										status: "completed",
										content: [
											{
												type: "output_text",
												text: "Retrieved fictional role",
												annotations: [
													{
														type: "url_citation",
														url: "https://jobs.example.com/engineer",
														title: "Fictional role",
														start_index: 0,
														end_index: 10,
													},
												],
											},
										],
									},
								],
								usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 },
							}),
						);
						return;
					}
					const events: unknown[] = [
						{ type: "response.created", response: { id: "chat", created_at: 1, model: body.model } },
					];
					if (!JSON.stringify(body.input).includes("function_call_output")) {
						const args = JSON.stringify({ query: "Fictional engineer" });
						const item = {
							type: "function_call",
							id: "fc-search",
							call_id: "call-search",
							name: "search_web",
							arguments: "",
						};
						events.push(
							{ type: "response.output_item.added", output_index: 0, item },
							{ type: "response.function_call_arguments.delta", item_id: "fc-search", output_index: 0, delta: args },
							{
								type: "response.output_item.done",
								output_index: 0,
								item: { ...item, arguments: args, status: "completed" },
							},
						);
					} else {
						const item = { type: "message", id: "reply" };
						events.push(
							{ type: "response.output_item.added", output_index: 0, item },
							{ type: "response.output_text.delta", item_id: "reply", output_index: 0, delta: "Research complete." },
							{ type: "response.output_item.done", output_index: 0, item },
						);
					}
					events.push({
						type: "response.completed",
						response: { usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } },
					});
					res.writeHead(200, { "content-type": "text/event-stream" });
					res.end(events.map((event) => `data: ${JSON.stringify(event)}\n\n`).join(""));
					return;
				}
				if (mode === "hold" || mode === "score-hold")
					await new Promise<void>((resolve) => {
						release = resolve;
					});
				if (mode === "failure" || (mode === "retry" && requests.length === 1)) {
					res.writeHead(503, { "content-type": "application/json", "retry-after": "0" });
					res.end(JSON.stringify({ error: { message: "Synthetic provider failure" } }));
					return;
				}
				if (
					mode === "agent" ||
					((mode === "tailoring" || mode === "prepare") &&
						body.stream &&
						!JSON.stringify(body.messages).includes("The letter's language"))
				) {
					const step = agentStep++;
					if (step === 2 && mode === "agent")
						await new Promise<void>((resolve) => {
							release = resolve;
						});
					res.writeHead(200, { "content-type": "text/event-stream" });
					const delta =
						step < 2
							? {
									tool_calls: [
										{
											index: 0,
											id: `agent-call-${step}`,
											type: "function",
											function: {
												name: step === 0 ? "read_resume" : "propose_edits",
												arguments: JSON.stringify(
													step === 0
														? {}
														: {
																title: "Fictional rewrite",
																changes: agentChanges,
																...(mode === "tailoring"
																	? { requirements: [{ text: "Build fictional reliable services.", status: "edited" }] }
																	: {}),
															},
												),
											},
										},
									],
								}
							: { content: "Fictional proposal ready." };
					res.write(
						`data: ${JSON.stringify({ id: "agent", created: 1, model: body.model, choices: [{ index: 0, delta, finish_reason: null }] })}\n\n`,
					);
					res.end(
						`data: ${JSON.stringify({ id: "agent", created: 1, model: body.model, choices: [{ index: 0, delta: {}, finish_reason: step < 2 ? "tool_calls" : "stop" }] })}\n\ndata: [DONE]\n\n`,
					);
					return;
				}
				if ((mode === "letter" || mode === "prepare") && body.stream) {
					if (failLetter) {
						res.writeHead(503, { "content-type": "application/json" });
						res.end(JSON.stringify({ error: { message: "Synthetic letter failure" } }));
						return;
					}
					res.writeHead(200, { "content-type": "text/event-stream" });
					res.write(
						`data: ${JSON.stringify({ id: "letter", created: 1, model: body.model, choices: [{ index: 0, delta: { content: "done" }, finish_reason: null }] })}\n\n`,
					);
					res.end(
						`data: ${JSON.stringify({ id: "letter", created: 1, model: body.model, choices: [{ index: 0, delta: {}, finish_reason: "stop" }] })}\n\ndata: [DONE]\n\n`,
					);
					return;
				}
				if (mode === "stream") {
					res.writeHead(200, { "content-type": "text/event-stream" });
					for (let index = 0; index < 50; index++)
						res.write(
							`data: ${JSON.stringify({ id: "stream", created: 1, model: body.model, choices: [{ index: 0, delta: { content: "x" }, finish_reason: null }] })}\n\n`,
						);
					res.end(
						`data: ${JSON.stringify({ id: "stream", created: 1, model: body.model, choices: [{ index: 0, delta: {}, finish_reason: "stop" }] })}\n\ndata: [DONE]\n\n`,
					);
					return;
				}
				const callsTool = mode === "tools" && requests.length === 1;
				const text =
					mode === "score" || mode === "score-hold"
						? JSON.stringify({ score: 73, gaps: ["Evidence not shown"], strengths: ["Fictional services"] })
						: mode === "tailoring"
							? JSON.stringify({ summary: "<p>Generated fictional tailored summary.</p>" })
							: mode === "improve"
								? JSON.stringify({
										text: "Led fictional reliable delivery.",
										why: "Uses a direct verb.",
										addsFacts: false,
									})
								: mode === "resume"
									? JSON.stringify(sampleResumeData)
									: mode === "writing"
										? JSON.stringify({
												summary: "Fictional saved wording review",
												strengths: [],
												suggestions: [],
												jdAlignment: null,
											})
										: mode === "answer" || mode === "prepare"
											? JSON.stringify({ text: "Built a fictional reporting workflow.", factIds: [], note: null })
											: mode === "reply"
												? JSON.stringify({
														title: "Reply",
														asks: [],
														unconfirmed: [],
														reply: "Thank you.",
														changes: [],
														offer: null,
													})
												: "done";
				res.writeHead(200, { "content-type": "application/json" });
				res.end(
					JSON.stringify({
						id: "fixture",
						created: 1,
						model: body.model,
						choices: [
							{
								index: 0,
								message: callsTool
									? {
											role: "assistant",
											content: null,
											tool_calls: [
												{ id: "read-1", type: "function", function: { name: "read_owned", arguments: "{}" } },
											],
										}
									: { role: "assistant", content: text },
								finish_reason: callsTool ? "tool_calls" : "stop",
							},
						],
					}),
				);
			})();
		});
	});
	const run = (operation: () => Promise<void>) => withDatabasePool(pool, operation);
	const client = (
		permissions: ("read" | "write" | "delete")[] = ["read", "write", "delete"],
		reqHeaders = new Headers(),
	) =>
		createRouterClient(
			{
				ai: aiRouter,
				agent: agentRouter,
				auth: authRouter,
				career: careerRouter,
				letters: coverLettersRouter,
				resume: resumeRouter,
				documents: documentsRouter,
				applicationAi: applicationAiRouter,
				applications: applicationsRouter,
			},
			{
				context: {
					locale: "en-US",
					reqHeaders,
					authentication: { user, method: "apiKey", permissions },
				},
			},
		);
	const reviewFixture = async () => {
		const connection = await provider();
		const api = client();
		const data = structuredClone(sampleResumeData);
		data.summary.content = "<p>Built fictional reliable services.</p>";
		data.metadata.notes = "PRIVATE_FICTIONAL_RESUME_NOTES";
		const resumeId = await api.resume.import({ data });
		const loaded = await loadDocument(user.id, { kind: "resume", id: resumeId });
		const passage = loaded.passages.find((entry) => entry.target.sectionId === "summary");
		if (!passage) throw new Error("Missing fictional passage");
		agentChanges = [
			{
				kind: "text",
				sectionId: "summary",
				passageId: passage.id,
				text: "Built reliable fictional services.",
				why: "Clearer wording",
				evidence: [passage.id],
			},
		];
		const id = await api.applications.create({
			company: "Fictional Cedar",
			role: "Engineer",
			status: "saved",
			resumeId,
			jobDescription: "Build fictional reliable services.",
			notes: "PRIVATE_FICTIONAL_APPLICATION_NOTES",
		});
		return { connection, api, data, resumeId, id };
	};
	it("preserves numeric compatibility, private context exclusion and saved provider/model sources", () =>
		run(async () => {
			const { api, id, data, connection } = await reviewFixture();
			mode = "score";
			const score = await api.applicationAi.matchScore({ id });
			expect(score).toMatchObject({ score: 73, gaps: ["Evidence not shown"], strengths: ["Fictional services"] });
			expect(JSON.stringify(requestMessages)).not.toContain(data.metadata.notes);
			expect(JSON.stringify(requestMessages)).not.toContain("PRIVATE_FICTIONAL_APPLICATION_NOTES");
			const saved = await api.applications.getById({ id });
			expect(saved.aiMetadata).toMatchObject({
				matchScore: { score: 73, gaps: ["Evidence not shown"], strengths: ["Fictional services"] },
				aiUsage: { requests: 1, models: [expect.objectContaining({ providerId: connection.id, model: "main-model" })] },
			});
			await aiProvidersService.delete({ userId: user.id, id: connection.id });
			expect((await api.applications.getById({ id })).aiMetadata).toEqual(saved.aiMetadata);
			expect(JSON.stringify((await api.auth.exportData({})).applications)).toContain(saved.aiMetadata?.aiOperationId);
			expect(requests).toHaveLength(1);
		}));
	it.each(["application", "resume"] as const)(
		"refuses stale numeric results after %s edits during provider transport",
		(owner) =>
			run(async () => {
				const { api, id, resumeId } = await reviewFixture();
				mode = "score-hold";
				const arrival = new Promise<void>((resolve) => {
					arrived = resolve;
				});
				const pending = api.applicationAi.matchScore({ id });
				try {
					await arrival;
					if (owner === "application")
						await api.applications.update({ id, jobDescription: "Changed fictional posting" });
					else {
						const before = await api.resume.getById({ id: resumeId });
						await api.resume.update({
							id: resumeId,
							expectedUpdatedAt: before.updatedAt,
							data: { ...before.data, summary: { ...before.data.summary, content: "<p>Changed factual summary.</p>" } },
						});
					}
					release();
					await expect(pending).rejects.toMatchObject({ code: "CONFLICT" });
					expect((await api.applications.getById({ id })).matchScore).toBeNull();
					expect(requests).toHaveLength(1);
				} finally {
					release();
				}
			}),
	);
	it.each(["active", "forgotten", "excluded", "corrected"] as const)(
		"reviewed Fit evidence respects %s source state",
		(state) =>
			run(async () => {
				const { api, id } = await reviewFixture();
				const fact = await api.career.saveFact({
					applicationId: id,
					text: "Built fictional services for five teams.",
					category: "accomplishment",
					source: { kind: "manual", id: "fictional-evidence", quote: "Built fictional services for five teams." },
				});
				if (!fact) throw new Error("Missing fixture fact");
				await expect(api.applicationAi.proposeEvidence({ id, factId: fact.id })).rejects.toMatchObject({
					code: "NOT_FOUND",
				});
				const workspace = await api.career.workspace({ applicationId: id });
				await api.career.saveWorkspace({
					applicationId: id,
					evidence: { requirement: fact.id },
					expected: { evidence: workspace.evidence },
				});
				mode = "tailoring";
				const result = await api.applicationAi.proposeEvidence({ id, factId: fact.id });
				expect(result.generationStatus).toBe("ready");
				expect(result.conversation?.thread.workingResumeId).toBe(result.resumeId);
				expect((await api.resume.getById({ id: result.resumeId })).data.summary.content).toBe(
					"<p>Built fictional reliable services.</p>",
				);
				expect(JSON.stringify(requestMessages)).toContain(fact.text);
				expect(requests).toHaveLength(3);
				if (state === "forgotten") await api.career.forgetFact({ id: fact.id });
				else if (state === "excluded") await api.career.updateFact({ id: fact.id, status: "excluded" });
				else if (state === "corrected")
					await api.career.updateFact({ id: fact.id, text: "Corrected fictional account of work." });
				const proposed = result.conversation?.messages
					.flatMap((message) => message.parts)
					.find((part) => part.type === "tool-propose_edits") as { output?: ProposeEditsOutput } | undefined;
				const edit = proposed?.output?.edits[0];
				if (!edit) throw new Error("Missing saved Fit proposal");
				const before = await api.resume.getById({ id: result.resumeId });
				const acceptance = api.resume.update({
					id: before.id,
					expectedUpdatedAt: before.updatedAt,
					data: { ...before.data, summary: { ...before.data.summary, content: edit.after } },
					proposalApplications: { [edit.id]: edit.after },
					proposalSafety: "v1",
				});
				if (state === "active") {
					const accepted = await acceptance;
					expect(accepted.data.summary.content).toBe(edit.after);
					expect(accepted.aiUsage?.requests).toBe(3);
					return;
				}
				await expect(acceptance).rejects.toMatchObject({ code: "RESUME_VERSION_CONFLICT" });
				expect((await api.resume.getById({ id: before.id })).data).toEqual(before.data);

				if (state !== "corrected")
					await expect(api.applicationAi.proposeEvidence({ id, factId: fact.id })).rejects.toMatchObject({
						code: "NOT_FOUND",
					});
				const conversation = await api.agent.threads.get({ id: result.conversation?.thread.id ?? "missing" });
				expect(
					conversation.messages.some((message) => message.parts.some((part) => part.type === "tool-propose_edits")),
				).toBe(false);
				expect(requests).toHaveLength(3);
			}),
	);
	it.each([false, true])(
		"prepares all three real draft owners; letter failure=%s retains completed proposals and answers",
		(failure) =>
			run(async () => {
				const { api, id, resumeId, data } = await reviewFixture();
				mode = "prepare";
				failLetter = failure;
				const result = await api.applicationAi.prepare({ id, questions: ["Describe work you led.", "Why this role?"] });
				expect(result.sets[0]?.edits[0]?.status).toBe("pending");
				expect(result.threadId).toEqual(expect.any(String));
				expect(result.answers).toHaveLength(2);
				expect(result.answers.map((answer) => answer.question)).toEqual(["Describe work you led.", "Why this role?"]);
				expect(result.failed).toEqual(failure ? ["letter"] : []);
				expect((await api.resume.getById({ id: resumeId })).data.summary.content).toBe(data.summary.content);
				expect((await api.resume.getById({ id: result.resume.id })).data.summary.content).toBe(data.summary.content);
				expect((await api.career.workspace({ applicationId: id })).answers).toEqual([]);
				if (failure) expect(result.letter).toBeNull();
				else {
					expect(result.letter?.text).toBe("done");
					expect(result.letter?.document.content).toBe("");
					const letter = await api.letters.update({
						id: result.letter?.document.id ?? "missing",
						expectedRevision: result.letter?.document.revision ?? 0,
						content: coverLetterTextToHtml(result.letter?.text ?? ""),
						aiOperationIds: result.letter?.aiOperationIds ?? [],
					});
					expect(letter.aiUsage?.requests).toBe(1);
				}
				const first = result.answers[0];
				if (!first) throw new Error("Missing generated answer");
				await api.career.saveWorkspace({
					applicationId: id,
					answers: [{ id: "approved-question", question: first.question, ...first.answer }],
					expected: { answers: [] },
				});
				expect((await api.career.workspace({ applicationId: id })).answers[0]?.aiOperationIds).toEqual(
					first.answer.aiOperationIds,
				);
				const groups = (await api.ai.usage({})).groups;
				expect(groups).toEqual(
					expect.arrayContaining([
						expect.objectContaining({ action: "tailor-resume", requests: 3, model: "capable-model" }),
						expect.objectContaining({ action: "draft-letter", requests: 1, model: "capable-model" }),
						expect.objectContaining({ action: "answer", requests: 2, model: "main-model" }),
					]),
				);
				expect(requests).toHaveLength(6);
				expect(JSON.stringify(requestMessages.slice(0, 3))).not.toContain("PRIVATE_FICTIONAL_APPLICATION_NOTES");
				expect(JSON.stringify(requestMessages)).not.toContain(data.metadata.notes);
			}),
	);
	it("rejects invalid, declined and read-only Prepare before any copy or model request", () =>
		run(async () => {
			const { api, id } = await reviewFixture();
			await expect(client(["read"]).applicationAi.prepare({ id, questions: [] })).rejects.toMatchObject({
				code: "FORBIDDEN",
			});
			await expect(
				client(undefined, new Headers({ "x-ai-destination": "none" })).applicationAi.prepare({ id, questions: [] }),
			).rejects.toMatchObject({ code: "CONFLICT" });
			await expect(api.applicationAi.prepare({ id, questions: Array(6).fill("Question") })).rejects.toMatchObject({
				code: "BAD_REQUEST",
			});
			await expect(api.applicationAi.prepare({ id, questions: ["x".repeat(2001)] })).rejects.toMatchObject({
				code: "BAD_REQUEST",
			});
			expect(requests).toHaveLength(0);
			expect(await api.resume.list({})).toHaveLength(1);
		}));

	it.each(["saved", "applied"] as const)("keeps %s MCP/REST tailoring pending until reviewed", (stage) =>
		run(async () => {
			const connection = await provider();
			const api = client();
			const data = structuredClone(sampleResumeData);
			data.summary.content = "<p>Built fictional reliable services.</p>";
			data.metadata.notes = "Private fictional resume note must stay out.";
			const sourceId = await api.resume.import({ data });
			const loaded = await loadDocument(user.id, { kind: "resume", id: sourceId });
			const passage = loaded.passages.find((entry) => entry.target.sectionId === "summary");
			if (!passage) throw new Error("Missing fictional summary passage");
			agentChanges = [
				{
					kind: "text",
					sectionId: "summary",
					passageId: passage.id,
					text: "Built reliable fictional services.",
					why: "Clearer wording for the posting",
					requirement: "Build fictional reliable services.",
					evidence: [passage.id],
				},
			];
			const [application] = await db
				.insert(tables.application)
				.values({
					userId: user.id,
					company: "Fictional Cedar",
					role: "Engineer",
					status: "saved",
					resumeId: sourceId,
					jobDescription: "Build fictional reliable services.",
					notes: "Private fictional application note must stay out.",
				})
				.returning();
			if (!application) throw new Error("Missing fictional application");
			if (stage === "applied") await api.applications.update({ id: application.id, status: "applied" });
			const before = await api.applications.getById({ id: application.id });
			mode = "tailoring";
			const result = await api.applicationAi.tailorResume({ id: application.id });
			const source = await api.resume.getById({ id: sourceId });
			const copy = await api.resume.getById({ id: result.resumeId });
			expect(source.data.summary.content).toBe(data.summary.content);
			expect(copy.id).not.toBe(sourceId);
			expect(requests.length).toBeGreaterThan(0);
			const link = await pool.query("select resume_id from application where id=$1", [application.id]);
			expect(link.rows[0]?.resume_id).toBe(stage === "saved" ? copy.id : sourceId);
			if (stage === "applied") {
				expect(before.sentResumeVersionId).not.toBeNull();
				expect((await api.applications.getById({ id: application.id })).sentResumeVersionId).toBe(
					before.sentResumeVersionId,
				);
			}
			expect(copy.data.summary.content).toBe(data.summary.content);
			expect(result).toMatchObject({ reviewRequired: true, generationStatus: "ready" });
			expect(result.conversation?.thread.workingResumeId).toBe(copy.id);
			const message = result.conversation?.messages.find((entry) => entry.role === "assistant");
			const output = message?.parts.find((part) => part.type === "tool-propose_edits") as
				| { output?: ProposeEditsOutput }
				| undefined;
			const edit = output?.output?.edits[0];
			if (!edit) throw new Error("Missing canonical tailoring proposal");
			expect(edit.status).toBe("pending");
			expect(output?.output?.tailoredFor).toBe(application.id);
			expect(requests).toHaveLength(3);
			expect(requests.every((request) => request.model === "capable-model")).toBe(true);
			expect(JSON.stringify(requestMessages)).not.toContain(data.metadata.notes);
			expect(JSON.stringify(requestMessages)).not.toContain(application.notes);
			const accepted = await api.resume.update({
				id: copy.id,
				data: { ...copy.data, summary: { ...copy.data.summary, content: edit.after } },
				expectedUpdatedAt: copy.updatedAt,
				proposalApplications: { [edit.id]: true },
				proposalSafety: "v1",
			});
			expect(accepted.data.summary.content).toBe(edit.after);
			expect(accepted.aiOperationIds).toEqual(aiOperationIds(message?.metadata));
			expect(accepted.aiUsage?.requests).toBe(3);
			expect((await api.ai.usage({})).groups).toEqual([
				expect.objectContaining({ action: "tailor-resume", requests: 3, model: "capable-model" }),
			]);
			expect(requests).toHaveLength(3);
			await aiProvidersService.delete({ userId: user.id, id: connection.id });
			const reloaded = await api.resume.getById({ id: copy.id });
			expect(reloaded.aiUsage).toEqual(accepted.aiUsage);
			expect(reloaded.aiOperationIds).toEqual(accepted.aiOperationIds);
		}),
	);

	it("refuses unauthorized, declined and already-cancelled tailoring before creating a copy or sending data", () =>
		run(async () => {
			await provider();
			const api = client();
			const sourceId = await api.resume.import({ data: structuredClone(sampleResumeData) });
			const id = await api.applications.create({
				company: "Fictional Cedar",
				role: "Engineer",
				resumeId: sourceId,
				jobDescription: "Build fictional services.",
			});
			const [foreign] = await db
				.insert(tables.application)
				.values({ userId: "usage-bob", company: "Fictional Birch", role: "Engineer" })
				.returning();
			if (!foreign) throw new Error("Missing fictional application");
			await expect(client(["read"]).applicationAi.tailorResume({ id })).rejects.toMatchObject({ code: "FORBIDDEN" });
			await expect(
				client(undefined, new Headers({ "x-ai-destination": "none" })).applicationAi.tailorResume({ id }),
			).rejects.toMatchObject({ code: "CONFLICT" });
			await expect(api.applicationAi.tailorResume({ id: foreign.id })).rejects.toMatchObject({ code: "NOT_FOUND" });
			const controller = new AbortController();
			controller.abort();
			await expect(api.applicationAi.tailorResume({ id }, { signal: controller.signal })).rejects.toThrow();
			expect(requests).toHaveLength(0);
			expect((await pool.query("select id from resume where user_id=$1", [user.id])).rows).toEqual([{ id: sourceId }]);
			expect(await db.select({ id: tables.agentThread.id }).from(tables.agentThread)).toEqual([]);
			expect((await api.applications.getById({ id })).resumeId).toBe(sourceId);
		}));

	it("returns the accessible unchanged copy and interrupted conversation after a failed canonical tailoring reply", () =>
		run(async () => {
			await provider();
			const api = client();
			const sourceId = await api.resume.import({ data: structuredClone(sampleResumeData) });
			const original = await api.resume.getById({ id: sourceId });
			const id = await api.applications.create({
				company: "Fictional Cedar",
				role: "Engineer",
				resumeId: sourceId,
				jobDescription: "Build fictional services.",
			});
			mode = "failure";
			const result = await api.applicationAi.tailorResume({ id });
			expect(result).toMatchObject({ reviewRequired: true, generationStatus: "interrupted" });
			expect(result.conversation?.interrupted).toHaveLength(1);
			expect(result.conversation?.thread.activeRunId).toBeNull();
			const copy = await api.resume.getById({ id: result.resumeId });
			expect(copy.id).not.toBe(sourceId);
			expect(copy.data).toEqual(original.data);
			expect(copy.aiOperationIds).toEqual([]);
			expect((await api.resume.getById({ id: sourceId })).data).toEqual(original.data);
			expect(requests).toHaveLength(1);
			expect((await api.ai.usage({})).groups).toEqual([
				expect.objectContaining({ action: "tailor-resume", requests: 1 }),
			]);
		}));

	it("cancels actual tailoring transport, keeps its unchanged copy and counts the dispatched request", () =>
		run(async () => {
			await provider();
			const api = client();
			const sourceId = await api.resume.import({ data: structuredClone(sampleResumeData) });
			const original = await api.resume.getById({ id: sourceId });
			const id = await api.applications.create({
				company: "Fictional Cedar",
				role: "Engineer",
				resumeId: sourceId,
				jobDescription: "Build fictional services.",
			});
			mode = "hold";
			const held = new Promise<void>((resolve) => {
				arrived = resolve;
			});
			const closed = new Promise<void>((resolve) => {
				disconnected = resolve;
			});
			const controller = new AbortController();
			const pending = api.applicationAi.tailorResume({ id }, { signal: controller.signal });
			try {
				await held;
				controller.abort();
				await expect(pending).rejects.toThrow();
				await closed;
				const copies = await pool.query("select id from resume where user_id=$1 and id<>$2", [user.id, sourceId]);
				expect(copies.rows).toHaveLength(1);
				const copy = await api.resume.getById({ id: copies.rows[0].id });
				expect(copy.data).toEqual(original.data);
				expect(copy.aiOperationIds).toEqual([]);
				expect(requests).toHaveLength(1);
				expect((await api.ai.usage({})).groups).toEqual([
					expect.objectContaining({ action: "tailor-resume", requests: 1 }),
				]);
			} finally {
				release();
			}
		}));

	it("does not let public assistant callers reclassify usage as tailoring", () =>
		run(async () => {
			await provider();
			const api = client();
			const id = await api.resume.import({ data: structuredClone(sampleResumeData) });
			const thread = await api.agent.threads.start({ resumeId: id });
			mode = "letter";
			const stream = await api.agent.messages.send({
				threadId: thread.id,
				message: {
					id: "fictional-question",
					role: "user",
					parts: [{ type: "text", text: "Read this fictional resume." }],
				},
				usageAction: "tailor-resume",
			} as never);
			for await (const _chunk of stream) {
				/* Consume the actual streamed reply. */
			}
			expect((await api.ai.usage({})).groups).toEqual([expect.objectContaining({ action: "assistant", requests: 1 })]);
		}));

	const provider = async (ownerId = user.id) => {
		const created = await aiProvidersService.create({
			userId: ownerId,
			label: "Fictional connection",
			provider: "openai-compatible",
			model: "main-model",
			fastModel: "fast-model",
			capableModel: "capable-model",
			baseURL,
			apiKey: "synthetic-key-207",
		});
		await pool.query("update ai_providers set enabled=true,test_status='success' where id=$1", [created.id]);
		return aiProvidersService.getRunnableById({ userId: ownerId, id: created.id });
	};
	beforeAll(async () => {
		await admin.query(`create schema ${namespace}`);
		pool = new Pool({
			connectionString: databaseUrl,
			options: `-c search_path=${namespace} -c statement_timeout=10000`,
		});
		const migrations = new URL("../../../../../migrations/", import.meta.url);
		for (const directory of (await readdir(migrations)).filter((name) => /^\d+_/.test(name)).sort())
			await pool.query(
				(await readFile(new URL(`${directory}/migration.sql`, migrations), "utf8")).replaceAll('"public".', ""),
			);
		await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
		baseURL = `http://127.0.0.1:${(server.address() as AddressInfo).port}/v1`;
	}, 30000);
	beforeEach(async () => {
		release();
		arrived = () => {};
		disconnected = () => {};
		requests = [];
		requestMessages = [];
		agentStep = 0;
		agentChanges = [];
		mode = "text";
		failLetter = false;
		await pool.query('truncate "user" cascade');
		await withDatabasePool(pool, async () => {
			const nonce = randomUUID().slice(0, 8);
			const users = await db
				.insert(tables.user)
				.values([
					{
						id: "usage-alice",
						name: "Alice Example",
						email: "[email protected]",
						username: `${namespace}-${nonce}-alice`,
						displayUsername: `${namespace}-${nonce}-alice`,
						timezone: "Europe/Berlin",
					},
					{
						id: "usage-bob",
						name: "Bob Example",
						email: "[email protected]",
						username: `${namespace}-${nonce}-bob`,
						displayUsername: `${namespace}-${nonce}-bob`,
						timezone: "UTC",
					},
				])
				.returning();
			const owner = users[0];
			if (!owner) throw new Error("Missing fixture user");
			user = owner;
		});
	});
	afterAll(async () => {
		release();
		server.closeAllConnections();
		await new Promise<void>((resolve) => server.close(() => resolve()));
		await pool?.end();
		await admin.query(`drop schema if exists ${namespace} cascade`);
		await admin.end();
	});

	it("counts actual retries with selected model provenance, without request content or credentials", () =>
		run(async () => {
			const connection = await provider();
			const usage = createAiUsage(user.id, "improve", connection);
			mode = "retry";
			const result = await generateText({
				model: getModel({ ...connection, model: "fast-model", usage }),
				prompt: "Private synthetic prompt marker",
				maxRetries: 1,
			});
			expect(result.text).toBe("done");
			expect(requests).toHaveLength(2);
			expect(await readAiUsage(user.id, [usage.operationId, usage.operationId])).toEqual({
				requests: 2,
				models: [
					{ providerId: connection.id, label: connection.label, provider: connection.provider, model: "fast-model" },
				],
			});
			const records = (await pool.query("select * from ai_request")).rows;
			expect(records).toHaveLength(2);
			expect(JSON.stringify(records)).not.toMatch(
				/Private synthetic|synthetic-key|api_key|base_url|recipient_version|tokens|cost/,
			);
		}));

	it("counts each tool-loop dispatch and one streamed request, independent of chunks or repeat reads", () =>
		run(async () => {
			const connection = await provider();
			const usage = createAiUsage(user.id, "assistant", connection);
			mode = "tools";
			let tools = 0;
			await generateText({
				model: getModel({ ...connection, model: "capable-model", usage }),
				prompt: "Read owned fixture",
				maxRetries: 0,
				stopWhen: stepCountIs(3),
				tools: {
					read_owned: tool({
						inputSchema: z.object({}),
						execute: async () => {
							tools++;
							return "owned";
						},
					}),
				},
			});
			expect(tools).toBe(1);
			expect(requests).toHaveLength(2);
			expect((await readAiUsage(user.id, [usage.operationId]))?.requests).toBe(2);
			mode = "stream";
			const streamedUsage = createAiUsage(user.id, "draft-letter", connection);
			const streamed = streamText({
				model: getModel({ ...connection, usage: streamedUsage }),
				prompt: "Stream fixture",
				maxRetries: 0,
			});
			expect(await streamed.text).toBe("x".repeat(50));
			expect(await streamed.text).toBe("x".repeat(50));
			expect(requests).toHaveLength(3);
			expect((await readAiUsage(user.id, [streamedUsage.operationId]))?.requests).toBe(1);
		}));

	it("records failed and cancelled dispatches, but not an already aborted request", () =>
		run(async () => {
			const connection = await provider();
			mode = "failure";
			await expect(
				generateText({
					model: getModel({ ...connection, usage: createAiUsage(user.id, "fit", connection) }),
					prompt: "Failure",
					maxRetries: 0,
				}),
			).rejects.toThrow();
			expect(requests).toHaveLength(1);
			const abort = new AbortController();
			mode = "hold";
			const accepted = new Promise<void>((resolve) => {
				arrived = resolve;
			});
			const pending = generateText({
				model: getModel({ ...connection, usage: createAiUsage(user.id, "fit", connection) }),
				prompt: "Cancellation",
				maxRetries: 0,
				abortSignal: abort.signal,
			});
			await accepted;
			abort.abort();
			await expect(pending).rejects.toThrow();
			release();
			mode = "text";
			await expect(
				generateText({
					model: getModel({ ...connection, usage: createAiUsage(user.id, "fit", connection) }),
					prompt: "Already stopped",
					maxRetries: 0,
					abortSignal: AbortSignal.abort(),
				}),
			).rejects.toThrow();
			expect(requests).toHaveLength(2);
			expect((await client().ai.usage({})).requests).toBe(2);
		}));

	it.each(["disabled", "untested", "foreign", "deleted-account"] as const)(
		"refuses %s before recording or transmitting",
		(kind) =>
			run(async () => {
				const connection = await provider();
				const usage = createAiUsage(kind === "foreign" ? "usage-bob" : user.id, "improve", connection);
				const model = getModel({ ...connection, usage });
				if (kind === "disabled") await pool.query("update ai_providers set enabled=false where id=$1", [connection.id]);
				if (kind === "untested")
					await aiProvidersService.update({ userId: user.id, id: connection.id, model: "replacement" });
				if (kind === "deleted-account") await pool.query('delete from "user" where id=$1', [user.id]);
				await expect(generateText({ model, prompt: "Must not leave", maxRetries: 0 })).rejects.toThrow();
				expect(requests).toEqual([]);
				expect((await pool.query("select * from ai_request")).rows).toEqual([]);
			}),
	);

	it("checks shared document versions at transport and fails closed when meter persistence fails", () =>
		run(async () => {
			const connection = await provider();
			const [resume] = await db
				.insert(tables.resume)
				.values({ userId: user.id, name: "Fictional resume", slug: "fixture", data: sampleResumeData })
				.returning();
			if (!resume) throw new Error("Missing fixture resume");
			const usage = createAiUsage(user.id, "assistant", connection, (reader) =>
				assertDocumentVersion(reader, user.id, { kind: "resume", ...resume }),
			);
			const model = getModel({ ...connection, usage });
			await pool.query("update resume set updated_at=updated_at+interval '1 millisecond' where id=$1", [resume.id]);
			await expect(generateText({ model, prompt: "Stale document", maxRetries: 0 })).rejects.toThrow();
			await pool.query("alter table ai_request add constraint reject_meter_fixture check(false)");
			try {
				await expect(
					generateText({
						model: getModel({ ...connection, usage: createAiUsage(user.id, "improve", connection) }),
						prompt: "Meter unavailable",
						maxRetries: 0,
					}),
				).rejects.toThrow();
			} finally {
				await pool.query("alter table ai_request drop constraint reject_meter_fixture");
			}
			expect(requests).toEqual([]);
			expect((await pool.query("select * from ai_request")).rows).toEqual([]);
		}));

	it.each([
		{ now: "2026-03-29T12:00:00Z", start: "2026-03-22T23:00:00Z", end: "2026-03-29T22:00:00Z", hours: 167 },
		{ now: "2026-10-25T12:00:00Z", start: "2026-10-18T22:00:00Z", end: "2026-10-25T23:00:00Z", hours: 169 },
	])(
		"uses account-local Monday boundaries and isolates accounts across $hours-hour DST weeks",
		({ now, start, end, hours }) =>
			run(async () => {
				const connection = await provider();
				const common = {
					operationId: "boundary",
					action: "improve" as const,
					providerId: connection.id,
					label: connection.label,
					provider: connection.provider,
					model: "fast-model",
				};
				await db.insert(tables.aiRequest).values([
					{ ...common, userId: user.id, createdAt: new Date(new Date(start).getTime() - 1) },
					{ ...common, userId: user.id, createdAt: new Date(start) },
					{
						...common,
						userId: user.id,
						action: "assistant",
						model: "capable-model",
						createdAt: new Date(new Date(end).getTime() - 1),
					},
					{ ...common, userId: user.id, createdAt: new Date(end) },
					{ ...common, userId: "usage-bob", createdAt: new Date(now) },
				]);
				const report = await readWeeklyAiUsage(user.id, new Date(now));
				expect(report).toMatchObject({
					start: new Date(start),
					end: new Date(end),
					timezone: "Europe/Berlin",
					requests: 2,
				});
				expect((report.end.getTime() - report.start.getTime()) / 3_600_000).toBe(hours);
				expect(report.groups).toEqual(
					expect.arrayContaining([
						expect.objectContaining({ action: "improve", model: "fast-model", requests: 1 }),
						expect.objectContaining({ action: "assistant", model: "capable-model", requests: 1 }),
					]),
				);
				expect(report.groups).toHaveLength(2);
				expect((await readAiUsage("usage-bob", [common.operationId]))?.requests).toBe(1);
			}),
	);

	it("authorizes and meters native search when an approved Coach tool runs before the next model step", () =>
		run(async () => {
			const connection = await aiProvidersService.create({
				userId: user.id,
				label: "Fictional direct connection",
				provider: "openai",
				model: "gpt-4.1-mini",
				apiKey: "fictional-direct-key",
			});
			await pool.query("update ai_providers set enabled=true,test_status='success' where id=$1", [connection.id]);
			const [current] = await aiProvidersService.list({ userId: user.id });
			if (!current) throw new Error("Missing direct fixture connection");
			await webAccessService.save(user.id, "firecrawl", "fictional-web-key");
			const failedConnection = await webAccessService.resolve(user.id, true);
			await webAccessService.recordTest(user.id, failedConnection, {
				search: { success: false, error: "auth" },
				read: { success: false, error: "auth" },
			});
			expect(await webAccessService.resolve(user.id)).toBeNull();
			mode = "native-search";
			const original = globalThis.fetch;
			vi.stubGlobal("fetch", async (input: RequestInfo | URL, init?: RequestInit) => {
				const request = new Request(input, init);
				const url = new URL(request.url);
				if (url.origin !== "https://api.openai.com" && url.origin !== "https://api.firecrawl.dev")
					return original(input, init);
				return original(url.origin === "https://api.firecrawl.dev" ? `${baseURL}/firecrawl` : `${baseURL}/responses`, {
					method: request.method,
					headers: request.headers,
					body: await request.arrayBuffer(),
					signal: request.signal,
				});
			});
			try {
				const api = client(
					undefined,
					new Headers({ "x-ai-native-search": "1", "x-ai-destination": aiDestination(current) }),
				);
				const thread = await api.agent.threads.start({ scope: "career", aiProviderId: current.id });
				const send = async (message: UIMessage) => {
					const stream = await api.agent.messages.send({
						threadId: thread.id,
						message,
						context: { web: true, memory: true, application: true },
					});
					for await (const chunk of stream) expect(typeof chunk).toBe("string");
					return api.agent.threads.get({ id: thread.id });
				};
				const pending = await send({
					id: "query",
					role: "user",
					parts: [{ type: "text", text: "Find fictional engineer roles" }],
				});
				const approval = pending.messages.find((message) =>
					message.parts.some((part) => part.type === "tool-search_web"),
				);
				if (!approval) throw new Error("Missing exact query approval");
				expect(requests.map((request) => request.path)).toEqual(["/v1/responses"]);
				const answered = structuredClone(approval) as UIMessage;
				for (const part of answered.parts) {
					const tool = part as typeof part & { state?: string; approval?: { id: string; approved?: boolean } };
					if (tool.type === "tool-search_web" && tool.approval) {
						tool.state = "approval-responded";
						tool.approval.approved = true;
					}
				}
				const completed = await send(answered);
				expect(JSON.stringify(completed.messages)).toContain("https://jobs.example.com/engineer");
				expect(requests.map((request) => request.path)).toEqual([
					"/v1/responses",
					"/v1/firecrawl",
					"/v1/responses",
					"/v1/responses",
				]);
				const report = await api.ai.usage({ includeWebSearch: true });
				expect(report.groups).toEqual([expect.objectContaining({ action: "career-chat", requests: 3 })]);
				expect((await webAccessService.status(user.id)).testResult?.search).toEqual({ success: false, error: "auth" });
			} finally {
				vi.unstubAllGlobals();
			}
		}));

	it("aggregates native-search attempts compatibly for old clients and separates opted-in reports without losing account isolation", () =>
		run(async () => {
			const connection = await provider();
			for (const action of ["assistant", "web-search", "web-search"] as const)
				await generateText({
					model: getModel({ ...connection, usage: createAiUsage(user.id, action, connection) }),
					prompt: "Fictional query",
					maxRetries: 0,
				});
			await db.insert(tables.aiRequest).values({
				userId: "usage-bob",
				operationId: "foreign-search",
				action: "web-search",
				providerId: connection.id,
				label: connection.label,
				provider: connection.provider,
				model: connection.model,
			});
			const legacy = await client(["read"]).ai.usage({});
			expect(legacy.requests).toBe(3);
			expect(legacy.groups).toEqual([
				expect.objectContaining({ action: "assistant", requests: 3, providerId: connection.id }),
			]);
			const detailed = await client(["read"]).ai.usage({ includeWebSearch: true });
			expect(detailed.requests).toBe(3);
			expect(detailed.groups).toHaveLength(2);
			expect(detailed.groups).toEqual(
				expect.arrayContaining([
					expect.objectContaining({ action: "assistant", requests: 1 }),
					expect.objectContaining({ action: "web-search", requests: 2 }),
				]),
			);
			const exported = await client(["read"]).auth.exportData({});
			expect(exported.career.aiRequests?.filter((row) => row.action === "web-search")).toHaveLength(2);
			expect(JSON.stringify(exported)).not.toContain("foreign-search");
			await authService.deleteAccount({ userId: user.id });
			expect((await pool.query("select * from ai_request where user_id=$1", [user.id])).rows).toEqual([]);
			expect((await pool.query("select * from ai_request where user_id=$1", ["usage-bob"])).rows).toHaveLength(1);
			expect(requests).toHaveLength(3);
		}));

	it("keeps generated answer provenance through save, older-client edits and submitted snapshots", () =>
		run(async () => {
			const connection = await provider();
			const [application] = await db
				.insert(tables.application)
				.values({ userId: user.id, company: "Fictional Harbor", role: "Engineer" })
				.returning();
			if (!application) throw new Error("Missing fixture application");
			mode = "answer";
			const generated = await client().career.generate({
				applicationId: application.id,
				locale: "en-US",
				task: { task: "answer", question: "What did you build?", answer: "" },
			});
			expect(generated.answer).toMatchObject({ aiOperationIds: [expect.any(String)] });
			const source = generated.answer as NonNullable<typeof generated.answer> & { aiOperationIds: string[] };
			const before = await client().career.workspace({ applicationId: application.id });
			const answer = {
				id: "answer-1",
				question: "What did you build?",
				answer: source.text,
				factIds: source.factIds,
				aiOperationIds: source.aiOperationIds,
			};
			await db.insert(tables.aiRequest).values([
				{
					userId: "usage-bob",
					operationId: "foreign-answer-op",
					action: "answer",
					providerId: connection.id,
					label: connection.label,
					provider: connection.provider,
					model: connection.model,
				},
				{
					userId: user.id,
					operationId: "wrong-action-op",
					action: "improve",
					providerId: connection.id,
					label: connection.label,
					provider: connection.provider,
					model: connection.model,
				},
			]);
			for (const bad of ["foreign-answer-op", "wrong-action-op", "fabricated-op"]) {
				await expect(
					client().career.saveWorkspace({
						applicationId: application.id,
						answers: [{ ...answer, aiOperationIds: [bad] }],
						expected: { answers: before.answers },
					}),
				).rejects.toMatchObject({ code: "BAD_REQUEST" });
				expect((await client().career.workspace({ applicationId: application.id })).answers).toEqual(before.answers);
			}
			const saved = await client().career.saveWorkspace({
				applicationId: application.id,
				answers: [answer],
				expected: { answers: before.answers },
			});
			await client().career.saveWorkspace({
				applicationId: application.id,
				checklist: [0, 2],
				expected: { checklist: saved.checklist },
			});
			const review = {
				applicationId: application.id,
				question: answer.question,
				answer: answer.answer,
				scope: "reusable" as const,
				source: "ai-assisted" as const,
				factIds: [],
				storyIds: [],
				expectedEvidence: [],
				reviewed: true as const,
				noEmployerWording: true,
				aiOperationIds: source.aiOperationIds,
			};
			const library = await client().career.answers.save(review);
			const { aiOperationIds: _ids, ...oldReview } = review;
			const updated = await client().career.answers.save({
				...oldReview,
				id: library.id,
				expectedRevision: library.revision,
				answer: answer.answer + " Reviewed in library.",
			});
			expect(updated.aiOperationIds).toEqual(source.aiOperationIds);
			const [other] = await db
				.insert(tables.application)
				.values({ userId: user.id, company: "Fictional Cedar", role: "Builder" })
				.returning();
			if (!other) throw new Error("Missing second application");
			const reused = await client().career.answers.reuse({
				id: library.id,
				expectedRevision: updated.revision,
				applicationId: other.id,
				answer: updated.answer,
				reviewed: true,
			});
			expect(reused.aiOperationIds).toEqual(source.aiOperationIds);

			const legacy = saved.answers.map(({ id, question, answer, factIds }) => ({ id, question, answer, factIds }));
			const edited = await client().career.saveWorkspace({
				applicationId: application.id,
				answers: legacy.map((row) => ({ ...row, answer: row.answer + " Reviewed." })),
				expected: { answers: legacy },
			});
			expect(edited.answers[0]).toMatchObject({ aiOperationIds: source.aiOperationIds });
			const old = edited.answers.map(({ id, question, answer, factIds }) => ({ id, question, answer, factIds }));
			await client().career.submitApplication({ applicationId: application.id, answers: old, expectedAnswers: old });
			const snapshots = await client().career.savedItems({ applicationId: application.id, kind: "answers" });
			expect(snapshots[0]?.aiUsage).toEqual({
				requests: 1,
				models: [
					{ providerId: connection.id, label: connection.label, provider: connection.provider, model: "main-model" },
				],
			});
			expect(snapshots[0]?.data).toMatchObject({
				kind: "answers",
				answers: [{ aiOperationIds: source.aiOperationIds }],
			});
			const submitted = await client().career.workspace({ applicationId: application.id });
			expect(submitted.submissionReview).toMatchObject({
				checklist: [0, 2],
				answers: true,
				answerVersionId: snapshots[0]?.id,
			});
			const afterLegacyEdit = await client().career.saveWorkspace({
				applicationId: application.id,
				answers: old.map((row) => ({ ...row, answer: row.answer + " Later draft." })),
				expected: { answers: old },
			});
			expect(afterLegacyEdit.answers[0]?.aiOperationIds).toEqual(source.aiOperationIds);
			expect(afterLegacyEdit.submissionReview).toEqual(submitted.submissionReview);
			await expect(
				client().career.saveWorkspace({
					applicationId: application.id,
					checklist: [1],
					expected: { checklist: submitted.checklist },
				}),
			).rejects.toMatchObject({ code: "CONFLICT" });
			expect((await client().career.workspace({ applicationId: application.id })).submissionReview).toEqual(
				submitted.submissionReview,
			);
			expect(requests).toHaveLength(1);
		}));

	it.each(["finish", "stop"] as const)(
		"accepts a real streamed proposal before %s with the same recorded sources in live metadata and storage",
		(ending) =>
			run(async () => {
				const connection = await provider();
				const api = client();
				const data = structuredClone(sampleResumeData);
				data.summary.content = "<p>Original fictional summary.</p>";
				const id = await api.resume.import({ data });
				const loaded = await loadDocument(user.id, { kind: "resume", id });
				const passage = loaded.passages.find((entry) => entry.target.sectionId === "summary");
				if (!passage) throw new Error("Missing fictional summary passage");
				agentChanges = [
					{
						kind: "text",
						sectionId: "summary",
						passageId: passage.id,
						text: "Led fictional delivery work.",
						why: "Clearer wording",
					},
				];
				const thread = await api.agent.threads.start({ resumeId: id });
				mode = "agent";
				const held = new Promise<void>((resolve) => {
					arrived = () => {
						if (requests.length === 3) resolve();
					};
				});
				const stream = await api.agent.messages.send({
					threadId: thread.id,
					message: {
						id: randomUUID(),
						role: "user",
						parts: [{ type: "text", text: "Rewrite the summary for clarity without adding facts." }],
					},
					context: { document: true, posting: false, memory: false },
				});
				const chunks: Record<string, unknown>[] = [];
				const finished = (async () => {
					for await (const frame of stream)
						for (const line of frame.split("\n"))
							if (line.startsWith("data: ") && line !== "data: [DONE]") chunks.push(JSON.parse(line.slice(6)));
				})();
				try {
					await held;
					const sources = aiOperationIds(chunks.find((chunk) => chunk.type === "start")?.messageMetadata);
					expect(sources).toEqual([expect.any(String)]);
					const stored = await api.agent.threads.get({ id: thread.id });
					const message = stored.messages.find((entry) => entry.role === "assistant");
					expect(aiOperationIds(message?.metadata)).toEqual(sources);
					const output = message?.parts.find((part) => part.type === "tool-propose_edits") as
						| { output?: ProposeEditsOutput }
						| undefined;
					const edit = output?.output?.edits[0];
					if (!edit) throw new Error("Missing real streamed proposal");
					const current = await api.resume.getById({ id });
					const accepted = await api.resume.update({
						id,
						expectedUpdatedAt: current.updatedAt,
						data: { ...current.data, summary: { ...current.data.summary, content: edit.after } },
						proposalApplications: { [edit.id]: edit.after },
						proposalSafety: "v1",
					});
					expect(accepted.aiOperationIds).toEqual(sources);
					expect(accepted.aiUsage).toMatchObject({
						requests: 3,
						models: [expect.objectContaining({ providerId: connection.id, model: "capable-model" })],
					});
					if (ending === "stop") await api.agent.messages.stop({ threadId: thread.id });
				} finally {
					release();
					await finished;
				}
				const sources = aiOperationIds(chunks.find((chunk) => chunk.type === "start")?.messageMetadata);
				if (ending === "finish")
					expect(aiOperationIds(chunks.find((chunk) => chunk.type === "finish")?.messageMetadata)).toEqual(sources);
				const stored = await api.agent.threads.get({ id: thread.id });
				const message = stored.messages.find((entry) => entry.role === "assistant");
				expect(aiOperationIds(message?.metadata)).toEqual(sources);
				expect(
					(
						message?.parts.find((part) => part.type === "tool-propose_edits") as
							| { output?: ProposeEditsOutput }
							| undefined
					)?.output?.edits[0]?.status,
				).toBe("accepted");
				expect((await api.resume.getById({ id })).aiOperationIds).toEqual(sources);
				expect(requests).toHaveLength(3);
			}),
	);

	it("uses the canonical letter prompt for MCP/REST cover-letter drafts", () =>
		run(async () => {
			await provider();
			const api = client();
			const data = structuredClone(sampleResumeData);
			data.metadata.page.locale = "en-GB";
			data.metadata.notes = "PRIVATE_FICTIONAL_NOTES_NOT_FOR_DRAFT";
			const sourceId = await api.resume.import({ data });
			const sourceBefore = await api.resume.getById({ id: sourceId });
			const [application] = await db
				.insert(tables.application)
				.values({
					userId: user.id,
					company: "Fictional Cedar",
					role: "Engineer",
					status: "saved",
					resumeId: sourceId,
					jobDescription: "Build fictional reliable services.",
					postingSource: {
						method: "paste",
						format: "text",
						truncated: false,
						completeness: "unknown",
						language: "de-DE",
					},
				})
				.returning();
			if (!application) throw new Error("Missing fictional application");
			mode = "letter";
			const result = await api.applicationAi.draftMessage({ id: application.id, kind: "cover-letter" });
			expect(result.text).toBe("done");
			expect(requests).toHaveLength(1);
			const system = requestMessages[0]?.find((message) => (message as { role?: string }).role === "system") as
				| { content: string }
				| undefined;
			expect(system?.content).toBe(letterDraftSystemPrompt);
			expect(JSON.stringify(requestMessages[0])).toContain("Write in de-DE.");
			expect(JSON.stringify(requestMessages[0])).not.toContain(data.metadata.notes);
			expect(result).toMatchObject({
				reviewRequired: true,
				coverLetterId: expect.any(String),
				aiOperationIds: [expect.any(String)],
				aiUsage: { requests: 1 },
			});
			const letter = await api.letters.getById({ id: result.coverLetterId ?? "missing" });
			expect(letter.content).toBe("");
			expect(letter.aiOperationIds).toEqual([]);
			expect(letter.style.metadata.page.locale).toBe("de-DE");
			await expect(
				client(["read"]).applicationAi.draftMessage({ id: application.id, kind: "cover-letter" }),
			).rejects.toMatchObject({ code: "FORBIDDEN" });
			await expect(
				client(undefined, new Headers({ "x-ai-destination": "none" })).applicationAi.draftMessage({
					id: application.id,
					kind: "cover-letter",
				}),
			).rejects.toMatchObject({ code: "CONFLICT" });
			expect(requests).toHaveLength(1);
			const accepted = await api.letters.update({
				id: letter.id,
				expectedRevision: letter.revision,
				content: coverLetterTextToHtml(result.text),
				aiOperationIds: result.aiOperationIds,
			});
			expect(accepted.content).toBe("<p>done</p>");
			expect(accepted.aiUsage).toEqual(result.aiUsage);
			expect(requests).toHaveLength(1);
			expect((await api.resume.getById({ id: sourceId })).data).toEqual(sourceBefore.data);
		}));

	it("does not create a letter when a canonical application draft fails or the application belongs to another account", () =>
		run(async () => {
			await provider();
			const [owned, foreign] = await db
				.insert(tables.application)
				.values([
					{
						userId: user.id,
						company: "Fictional Cedar",
						role: "Engineer",
						status: "saved" as const,
						jobDescription: "Build fictional reliable services.",
					},
					{
						userId: "usage-bob",
						company: "Other fictional company",
						role: "Engineer",
						status: "saved" as const,
						jobDescription: "PRIVATE_OTHER_APPLICATION",
					},
				])
				.returning();
			if (!owned || !foreign) throw new Error("Missing fictional applications");
			await expect(client().applicationAi.draftMessage({ id: foreign.id, kind: "cover-letter" })).rejects.toMatchObject(
				{ code: "NOT_FOUND" },
			);
			expect(requests).toHaveLength(0);
			mode = "failure";
			await expect(client().applicationAi.draftMessage({ id: owned.id, kind: "cover-letter" })).rejects.toMatchObject({
				code: "BAD_GATEWAY",
			});
			expect(requests).toHaveLength(1);
			expect((await pool.query("select id from cover_letter where user_id=$1", [user.id])).rows).toEqual([]);
		}));

	it("leaves no new letter after an application draft is cancelled in transport", () =>
		run(async () => {
			await provider();
			const [application] = await db
				.insert(tables.application)
				.values({
					userId: user.id,
					company: "Fictional Cedar",
					role: "Engineer",
					status: "saved",
					jobDescription: "Build fictional reliable services.",
				})
				.returning();
			if (!application) throw new Error("Missing fictional application");
			mode = "hold";
			const arrivedAtProvider = new Promise<void>((resolve) => {
				arrived = resolve;
			});
			const controller = new AbortController();
			const pending = client().applicationAi.draftMessage(
				{ id: application.id, kind: "cover-letter" },
				{ signal: controller.signal },
			);
			try {
				await arrivedAtProvider;
				controller.abort();
				await expect(pending).rejects.toThrow();
				expect(requests).toHaveLength(1);
				expect((await client().ai.usage({})).requests).toBe(1);
				expect((await pool.query("select id from cover_letter where user_id=$1", [user.id])).rows).toEqual([]);
			} finally {
				release();
			}
		}));

	it("preserves the legacy follow-up text contract without creating a letter or logging a sent reply", () =>
		run(async () => {
			await provider();
			const [application] = await db
				.insert(tables.application)
				.values({
					userId: user.id,
					company: "Fictional Cedar",
					role: "Engineer",
					status: "saved",
					jobDescription: "Build fictional reliable services.",
				})
				.returning();
			if (!application) throw new Error("Missing fictional application");
			const result = await client().applicationAi.draftMessage({ id: application.id, kind: "follow-up" });
			expect(result).toEqual({ text: "done" });
			expect(requests).toHaveLength(1);
			expect((await pool.query("select id from cover_letter where user_id=$1", [user.id])).rows).toEqual([]);
			expect(
				(await pool.query("select activity from application where id=$1", [application.id])).rows[0]?.activity,
			).toEqual(application.activity);
		}));

	it.each(["resume", "letter"] as const)(
		"%s accepted assistant sources preserve prior lineage, partial decisions and older clients",
		(kind) =>
			run(async () => {
				const connection = await provider();
				const priorUsage = createAiUsage(user.id, "improve", connection);
				await generateText({ model: getModel({ ...connection, usage: priorUsage }), prompt: "Fictional prior source" });
				const foreignConnection = await provider("usage-bob");
				const foreignUsage = createAiUsage("usage-bob", "assistant", foreignConnection);
				await generateText({
					model: getModel({ ...foreignConnection, usage: foreignUsage }),
					prompt: "Fictional other account",
				});
				const usage = createAiUsage(user.id, "assistant", connection);
				await generateText({ model: getModel({ ...connection, usage }), prompt: "Fictional source fixture" });
				const api = client();
				const data = structuredClone(sampleResumeData);
				const first = "<p>Original fictional summary.</p>";
				const second = "<p>Second fictional paragraph.</p>";
				const after = "<p>Led fictional delivery work.</p>";
				const afterSecond = "<p>Built fictional reporting tools.</p>";
				data.summary.content = first + second;
				const id =
					kind === "resume"
						? await api.resume.import({ data, aiOperationIds: [priorUsage.operationId] })
						: (await api.letters.create({ name: "Fictional proposal letter", content: first + second })).id;
				if (kind === "letter") {
					const letter = await api.letters.getById({ id });
					await api.letters.update({
						id,
						content: letter.content,
						aiOperationIds: [priorUsage.operationId],
						expectedRevision: letter.revision,
					});
				}
				const [thread] = await db
					.insert(tables.agentThread)
					.values({
						userId: user.id,
						...(kind === "resume" ? { workingResumeId: id, sourceResumeId: id } : { coverLetterId: id }),
						title: "Fictional proposal source",
					})
					.returning();
				if (!thread) throw new Error("Missing fixture thread");
				await upsertAssistantUiMessage({
					userId: user.id,
					threadId: thread.id,
					status: "completed",
					message: {
						id: "fictional-assistant",
						role: "assistant",
						metadata: {
							aiOperationIds: [usage.operationId, foreignUsage.operationId, priorUsage.operationId, "fabricated-op"],
						},
						parts: [
							{
								type: "tool-propose_edits",
								toolCallId: "fictional-edit-call",
								state: "output-available",
								input: {},
								output: {
									tailoredFor: null,
									edits: [
										{
											id: "fictional-edit",
											status: "pending",
											target: { sectionId: kind === "resume" ? "summary" : "letter", field: "content" },
											location: "Summary",
											before: first,
											after,
											why: "Fictional rewrite",
										},
										{
											id: "second-edit",
											status: "pending",
											target: { sectionId: kind === "resume" ? "summary" : "letter", field: "content" },
											location: "Summary",
											before: second,
											after: afterSecond,
											why: "Fictional second rewrite",
										},
									],
								},
							},
						],
					},
				});
				const save = async (content: string, applications: Record<string, string | boolean>) => {
					if (kind === "resume") {
						const current = await api.resume.getById({ id });
						return api.resume.update({
							id,
							data: { ...current.data, summary: { ...current.data.summary, content } },
							expectedUpdatedAt: current.updatedAt,
							proposalApplications: applications,
							proposalSafety: "v1",
						});
					}
					const current = await api.letters.getById({ id });
					return api.letters.update({
						id,
						content,
						expectedRevision: current.revision,
						proposalApplications: applications,
						proposalSafety: "v1",
					});
				};
				const accepted = await save(after + second, { "fictional-edit": after });
				expect(accepted.aiOperationIds).toEqual([priorUsage.operationId, usage.operationId]);
				expect(accepted.aiUsage).toMatchObject({
					requests: 2,
					models: [expect.objectContaining({ providerId: connection.id, model: connection.model })],
				});
				await save(after + afterSecond, { "second-edit": afterSecond });
				const partial = await save(first + afterSecond, { "fictional-edit": false });
				expect(partial.aiOperationIds).toEqual([priorUsage.operationId, usage.operationId]);
				const undone = await save(first + second, { "second-edit": false });
				expect(undone.aiOperationIds).toEqual([priorUsage.operationId]);
				const redone = await save(after + second, { "fictional-edit": after });
				expect(redone.aiOperationIds).toEqual([priorUsage.operationId, usage.operationId]);
				await api.ai.usage();
				expect(requests).toHaveLength(3);
			}),
	);

	it("returns opt-in Improve sources from actual transport records while preserving the default result contract", () =>
		run(async () => {
			const connection = await provider();
			const api = client();
			mode = "improve";
			const input = { action: "verb" as const, line: "Helped with fictional reliable delivery." };
			const legacy = await api.ai.improve(input);
			expect(legacy).toEqual({
				text: "Led fictional reliable delivery.",
				why: "Uses a direct verb.",
				addsFacts: false,
			});
			const result = await api.ai.improve({ ...input, includeProvenance: true });
			expect(result.aiOperationIds).toEqual([expect.any(String)]);
			expect(result.aiUsage).toEqual({
				requests: 1,
				models: [
					{ providerId: connection.id, label: connection.label, provider: connection.provider, model: "fast-model" },
				],
			});
			expect((await pool.query("select * from resume")).rows).toEqual([]);
			const id = await api.resume.import({ data: sampleResumeData });
			const current = await api.resume.getById({ id });
			const data = { ...current.data, summary: { ...current.data.summary, content: `<p>${result.text}</p>` } };
			const accepted = await api.resume.update({
				id,
				data,
				aiOperationIds: result.aiOperationIds,
				expectedUpdatedAt: current.updatedAt,
			});
			expect(accepted.aiUsage).toEqual(result.aiUsage);
			expect(accepted.data.summary.content).toBe(`<p>${result.text}</p>`);
			expect(requests).toHaveLength(2);
		}));

	it("pairs reviewed resume imports with real request sources through old edits, copies, history, export and deletion", () =>
		run(async () => {
			const connection = await provider();
			const api = client();
			mode = "resume";
			const file = { name: "fictional.pdf", data: Buffer.from("%PDF-fictional").toString("base64") };
			const legacy = await api.ai.parsePdf({ file });
			expect(legacy).not.toHaveProperty("aiOperationIds");
			const bytes = zipSync({
				"word/document.xml": strToU8(
					'<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body><w:p><w:r><w:t>Fictional resume</w:t></w:r></w:p></w:body></w:document>',
				),
			});
			const { aiOperationIds, ...data } = await api.ai.parseDocx({
				file: { name: "fictional.docx", data: Buffer.from(bytes).toString("base64") },
				mediaType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
				includeProvenance: true,
			});
			expect(aiOperationIds).toEqual([expect.any(String)]);
			expect((await pool.query("select * from resume")).rows).toEqual([]);
			const id = await api.resume.import({ data, aiOperationIds });
			const imported = await api.resume.getById({ id });
			const expected = {
				requests: 1,
				models: [
					{ providerId: connection.id, label: connection.label, provider: connection.provider, model: "fast-model" },
				],
			};
			expect(imported.aiOperationIds).toEqual(aiOperationIds);
			expect(imported.aiUsage).toEqual(expected);
			expect(imported.data).not.toHaveProperty("aiOperationIds");
			const first = (await api.resume.listVersions({ resumeId: id }))[0];
			if (!first) throw new Error("Missing import version");
			expect((await api.resume.getVersion({ resumeId: id, versionId: first.id })).aiUsage).toEqual(expected);
			const reviewed = { ...data, summary: { ...data.summary, content: "<p>Reviewed import</p>" } };
			const saved = await api.resume.update({
				id,
				data: reviewed,
				expectedUpdatedAt: imported.updatedAt,
				sessionId: "reviewed",
			});
			expect(saved.aiUsage).toEqual(expected);
			await expect(client(["read"]).resume.import({ data, aiOperationIds })).rejects.toMatchObject({
				code: "FORBIDDEN",
			});
			for (const [operationId, userId, action] of [
				["foreign-resume", "usage-bob", "import-docx"],
				["wrong-resume", user.id, "provider-test"],
			] as const) {
				await db.insert(tables.aiRequest).values({
					operationId,
					userId,
					action,
					providerId: connection.id,
					label: connection.label,
					provider: connection.provider,
					model: "unrelated-model",
				});
			}
			for (const bad of ["foreign-resume", "wrong-resume", "fabricated-source"]) {
				await expect(api.resume.import({ data, aiOperationIds: [bad] })).rejects.toMatchObject({ code: "BAD_REQUEST" });
				await expect(
					api.resume.update({ id, data, aiOperationIds: [bad], expectedUpdatedAt: saved.updatedAt }),
				).rejects.toMatchObject({ code: "BAD_REQUEST" });
			}
			await expect(api.resume.update({ id, aiOperationIds: [] })).rejects.toMatchObject({ code: "BAD_REQUEST" });
			expect((await api.resume.getById({ id })).data.summary.content).toBe("<p>Reviewed import</p>");
			const duplicateId = await api.resume.duplicate({ id });
			const copy = await api.documents.copyForJob({ resumeId: id, name: "Fictional job copy" });
			for (const copyId of [duplicateId, copy])
				expect((await api.resume.getById({ id: copyId })).aiUsage).toEqual(expected);
			await api.resume.createVersion({ resumeId: id, name: "Reviewed" });
			const [application] = await db
				.insert(tables.application)
				.values({ userId: user.id, company: "Fictional recipient", role: "Engineer", resumeId: id })
				.returning();
			if (!application) throw new Error("Missing submission application");
			await api.career.submitApplication({
				applicationId: application.id,
				answers: [],
				expectedAnswers: [],
				expectedDocuments: { resumeId: id, coverLetterId: null },
			});
			const sent = (await api.resume.listVersions({ resumeId: id })).find((version) => version.kind === "sent");
			if (!sent) throw new Error("Missing sent version");
			expect((await api.resume.getVersion({ resumeId: id, versionId: sent.id })).aiUsage).toEqual(expected);
			await api.resume.update({ id, isPublic: true });
			const published = await api.resume.getById({ id });
			const publicResult = await api.resume.getBySlug({ username: user.username, slug: published.slug });
			expect(publicResult).not.toHaveProperty("aiOperationIds");
			expect(publicResult).not.toHaveProperty("aiUsage");
			await aiProvidersService.update({ userId: user.id, id: connection.id, label: "Renamed", model: "replacement" });
			await aiProvidersService.delete({ userId: user.id, id: connection.id });
			expect((await api.resume.getById({ id })).aiUsage).toEqual(expected);
			const restored = await api.resume.restoreVersion({ resumeId: id, versionId: first.id, proposalSafety: "v1" });
			expect(restored.aiUsage).toEqual(expected);
			expect(restored.data.summary.content).toBe(data.summary.content);
			const exported = await client(["read"]).auth.exportData({});
			expect(exported.resumes.find((row) => row.id === id)?.aiOperationIds).toEqual(aiOperationIds);
			expect(exported.documentVersions?.resumes.find((row) => row.id === first.id)?.aiOperationIds).toEqual(
				aiOperationIds,
			);
			const archive = unzipSync(buildAccountZip(exported));
			const resumeFile = Object.keys(archive).find(
				(name) => name.startsWith("resumes/") && name.endsWith(`${id}.json`),
			);
			if (!resumeFile || !archive[resumeFile]) throw new Error("Missing resume account archive");
			expect(JSON.parse(strFromU8(archive[resumeFile])).aiOperationIds).toEqual(aiOperationIds);
			await pool.query("update resume_version set ai_operation_ids='{}' where id=$1", [first.id]);
			const legacyRestored = await api.resume.restoreVersion({
				resumeId: id,
				versionId: first.id,
				proposalSafety: "v1",
			});
			expect(legacyRestored.aiOperationIds).toEqual([]);
			expect(legacyRestored.aiUsage).toBeNull();
			const beforeRestore = (await api.resume.listVersions({ resumeId: id })).find(
				(version) => version.kind === "before-restore",
			);
			if (!beforeRestore) throw new Error("Missing before-restore version");
			expect((await api.resume.getVersion({ resumeId: id, versionId: beforeRestore.id })).aiUsage).toEqual(expected);
			const localId = await api.resume.import({ data });
			expect((await api.resume.getById({ id: localId })).aiUsage).toBeNull();
			await authService.deleteAccount({ userId: user.id });
			for (const table of ["resume", "resume_version"])
				expect((await pool.query(`select * from ${table}`)).rows).toEqual([]);
			expect((await pool.query("select * from ai_request where user_id=$1", [user.id])).rows).toEqual([]);
			expect(requests).toHaveLength(2);
		}));

	it("keeps letter draft sources through owned saves, reuse, history, export and deletion without new dispatches", () =>
		run(async () => {
			const connection = await provider();
			const [resume] = await db
				.insert(tables.resume)
				.values({ userId: user.id, name: "Fictional resume", slug: "letter", data: sampleResumeData })
				.returning();
			if (!resume) throw new Error("Missing fixture resume");
			const api = client();
			const letter = await api.letters.create({ name: "Fictional letter", resumeId: resume.id });
			const created = (await api.letters.listVersions({ id: letter.id }))[0];
			if (!created) throw new Error("Missing created version");
			mode = "stream";
			const stream = await api.letters.draft({ id: letter.id, includeProvenance: true });
			const parts = await Array.fromAsync(stream);
			const source = parts.find((part) => typeof part !== "string");
			if (!source || typeof source === "string") throw new Error("Missing draft provenance");
			const text = parts.filter((part) => typeof part === "string").join("");
			expect(text).toBe("x".repeat(50));
			expect(requests).toHaveLength(1);
			const kept = await api.letters.update({
				id: letter.id,
				expectedRevision: letter.revision,
				content: `<p>${text}</p>`,
				aiOperationIds: [source.aiOperationId, source.aiOperationId],
			});
			const expected = {
				requests: 1,
				models: [
					{ providerId: connection.id, label: connection.label, provider: connection.provider, model: "capable-model" },
				],
			};
			expect(kept.aiOperationIds).toEqual([source.aiOperationId]);
			expect(kept.aiUsage).toEqual(expected);
			// An old app edits without the new field: source history is preserved.
			const edited = await api.letters.update({
				id: letter.id,
				expectedRevision: kept.revision,
				content: "<p>Edited draft</p>",
			});
			expect(edited.aiUsage).toEqual(expected);
			for (const [operationId, userId, action] of [
				["foreign-letter", "usage-bob", "draft-letter"],
				["wrong-letter", user.id, "provider-test"],
			] as const) {
				await db.insert(tables.aiRequest).values({
					operationId,
					userId,
					action,
					providerId: connection.id,
					label: connection.label,
					provider: connection.provider,
					model: "foreign-model",
				});
				await expect(
					api.letters.update({
						id: letter.id,
						expectedRevision: edited.revision,
						content: "<p>Refused</p>",
						aiOperationIds: [operationId],
					}),
				).rejects.toMatchObject({ code: "BAD_REQUEST" });
			}
			expect((await api.letters.getById({ id: letter.id })).content).toBe("<p>Edited draft</p>");
			await expect(
				client(["read"]).letters.update({ id: letter.id, expectedRevision: edited.revision, aiOperationIds: [] }),
			).rejects.toMatchObject({ code: "FORBIDDEN" });
			const named = await api.letters.createVersion({ id: letter.id, name: "Kept draft" });
			expect((await client(["read"]).letters.getVersion({ id: letter.id, versionId: named.id })).aiUsage).toEqual(
				expected,
			);
			const reused = await api.letters.create({
				name: "New employer",
				sourceLetterId: letter.id,
				recipientCompany: "Fictional New Co",
			});
			expect(reused).toMatchObject({
				content: edited.content,
				recipientCompany: "Fictional New Co",
				aiOperationIds: [source.aiOperationId],
				aiUsage: expected,
			});
			expect((await api.letters.duplicate({ id: letter.id })).aiUsage).toEqual(expected);
			const portable = await api.letters.export({ id: letter.id });
			expect(portable).not.toHaveProperty("aiOperationIds");
			expect(portable).not.toHaveProperty("aiUsage");
			const imported = await api.letters.import({ document: portable });
			expect(imported.aiOperationIds).toEqual([]);
			const recovered = await api.letters.import({ document: portable, aiOperationIds: [source.aiOperationId] });
			expect(recovered.aiUsage).toEqual(expected);
			await expect(
				api.letters.import({ document: portable, aiOperationIds: ["foreign-letter"] }),
			).rejects.toMatchObject({ code: "BAD_REQUEST" });
			await aiProvidersService.delete({ userId: user.id, id: connection.id });
			expect((await client(["read"]).letters.getById({ id: letter.id })).aiUsage).toEqual(expected);
			await pool.query("update cover_letter_version set data=data-'aiOperationIds' where id=$1", [created.id]);
			const restored = await api.letters.restoreVersion({ id: letter.id, versionId: created.id, proposalSafety: "v1" });
			expect(restored.aiOperationIds).toEqual([]);
			expect(restored.aiUsage).toBeNull();
			const history = await api.letters.listVersions({ id: letter.id });
			const before = history.find((version) => version.kind === "before-restore");
			if (!before) throw new Error("Missing before-restore version");
			expect((await api.letters.getVersion({ id: letter.id, versionId: before.id })).aiUsage).toEqual(expected);
			const exportData = await client(["read"]).auth.exportData({});
			expect(JSON.stringify(exportData.coverLetters)).toContain(source.aiOperationId);
			expect(
				exportData.documentVersions?.letters.find((version) => version.id === before.id)?.data.aiOperationIds,
			).toEqual([source.aiOperationId]);
			expect(exportData.career.aiRequests?.some((row) => row.operationId === source.aiOperationId)).toBe(true);
			await authService.deleteAccount({ userId: user.id });
			expect((await pool.query("select * from cover_letter")).rows).toEqual([]);
			expect((await pool.query("select * from cover_letter_version")).rows).toEqual([]);
			expect((await pool.query("select * from ai_request where user_id=$1", [user.id])).rows).toEqual([]);
			expect(requests).toHaveLength(1);
		}));

	it("retains saved-result provenance after connection edits/removal, exports it to old archive clients and deletes account usage", () =>
		run(async () => {
			const connection = await provider();
			const [application] = await db
				.insert(tables.application)
				.values({ userId: user.id, company: "Fictional Harbor", role: "Engineer", status: "applied" })
				.returning();
			if (!application) throw new Error("Missing fixture application");
			mode = "reply";
			const generated = await client().career.generate({
				applicationId: application.id,
				locale: "en-US",
				task: { task: "reply", message: "When are you available?" },
			});
			expect(generated.item?.aiOperationId).toEqual(expect.any(String));
			const saved = await client().career.savedItems({ applicationId: application.id });
			expect(saved[0]?.aiUsage).toEqual({
				requests: 1,
				models: [
					{ providerId: connection.id, label: connection.label, provider: connection.provider, model: "main-model" },
				],
			});
			const [resume] = await db
				.insert(tables.resume)
				.values({
					userId: user.id,
					name: "Fictional writing resume",
					slug: "writing",
					data: sampleResumeData,
				})
				.returning();
			if (!resume) throw new Error("Missing writing fixture resume");
			mode = "writing";
			await client().ai.atsReview({
				resumeId: resume.id,
				extractedText: "Fictional original",
				findings: [],
				passages: [],
			});
			const writing = await client(["read"]).ai.writingReview({ resumeId: resume.id });
			expect(writing?.review.summary).toBe("Fictional saved wording review");
			expect(writing?.aiOperationIds).toEqual([expect.any(String)]);
			expect(writing?.aiUsage).toEqual(saved[0]?.aiUsage);
			await aiProvidersService.update({ userId: user.id, id: connection.id, label: "Renamed", model: "replacement" });
			await aiProvidersService.delete({ userId: user.id, id: connection.id });
			expect((await client().career.savedItems({ applicationId: application.id }))[0]?.aiUsage).toEqual(
				saved[0]?.aiUsage,
			);
			expect((await client(["read"]).ai.writingReview({ resumeId: resume.id }))?.aiUsage).toEqual(writing?.aiUsage);
			expect((await client(["read"]).ai.writingReview({ resumeId: resume.id }))?.aiOperationIds).toEqual(
				writing?.aiOperationIds,
			);
			const report = await client(["read"]).ai.usage({ userId: "usage-bob" } as {});
			expect(report.requests).toBe(2);
			expect(report.groups[0]).toMatchObject({ action: "reply", label: "Fictional connection", model: "main-model" });
			const exported = await client(["read"]).auth.exportData({});
			expect(exported.career.aiRequests).toHaveLength(2);
			expect(exported.career.writingReviews).toHaveLength(1);
			const archive = unzipSync(buildAccountZip(exported));
			const careerFile = archive["career.json"];
			if (!careerFile) throw new Error("Missing career export");
			const career = JSON.parse(strFromU8(careerFile)) as { aiRequests: unknown[]; writingReviews: unknown[] };
			expect(career.aiRequests).toHaveLength(2);
			expect(career.writingReviews).toHaveLength(1);
			expect(JSON.stringify(career.aiRequests)).not.toContain("synthetic-key-207");
			await authService.deleteAccount({ userId: user.id });
			expect((await pool.query("select * from ai_request")).rows).toEqual([]);
			expect((await pool.query("select * from resume_writing_review")).rows).toEqual([]);
			expect(requests).toHaveLength(2);
		}));
});