pi-harness-runtime 1.1.440 → 1.1.441

package/packages/prompt-compiler/test/prompt-compiler.test.ts

@@ -1,813 +0,0 @@
-/**
- * Prompt Compiler - Tests
- *
- * Tests cover all acceptance criteria from RFC-0041:
- * 1. Identical inputs produce identical prompt content and hash.
- * 2. Required sections are never removed by compaction.
- * 3. Provider formatting does not alter task semantics.
- * 4. Secrets are redacted before persistence.
- * 5. Invalid output contracts fail compilation.
- * 6. Continuation prompts do not repeat completed work.
- * 7. Unit tests cover all error codes.
- * 8. Tests pass without network access.
- */
-
-import assert from "node:assert";
-import { describe, it } from "node:test";
-
-import type { CompiledRequirement } from "@pi-harness/requirement-compiler";
-import type { CompiledTask } from "@pi-harness/task-compiler";
-import { compactToBudget, estimateTokens } from "../src/budget.js";
-// Import directly from source (TypeScript modules)
-import { compilePrompt, createSyncHasher } from "../src/compiler.js";
-import {
-	deduplicateSections,
-	normalizeForDeduplication,
-} from "../src/deduplicate.js";
-import { normalizeRequest } from "../src/normalize.js";
-import { renderForProvider } from "../src/render.js";
-import { buildSections } from "../src/section-builder.js";
-import { PromptCompileError } from "../src/types.js";
-import { PROVIDER_PROFILES } from "../src/types.js";
-import type { PromptCompileRequest } from "../src/types.js";
-import { validateSections, validateTokenBudget } from "../src/validate.js";
-
-// --- Test fixtures -------------------------------------------------------
-
-function makeRequest(
-	overrides?: Partial<PromptCompileRequest>,
-): PromptCompileRequest {
-	const requirement: CompiledRequirement = {
-		id: "REQ-001",
-		title: "Build login feature",
-		problemStatement: "Implement user login with JWT",
-		goals: [{ id: "g1", description: "Build login" }],
-		constraints: [
-			{ id: "c1", description: "Use HTTPS only", blocking: true },
-			{ id: "c2", description: "Passwords hashed with bcrypt", blocking: true },
-		],
-		acceptanceCriteria: [
-			{ id: "ac1", outcome: ["User can log in with valid credentials"] },
-			{ id: "ac2", outcome: ["Invalid credentials show error"] },
-		],
-		riskTags: [],
-	};
-
-	const task: CompiledTask = {
-		id: "task-001",
-		type: "implementation",
-		title: "Implement login",
-		objective: "Implement user login feature with JWT authentication",
-		dependencies: [],
-		priority: 1,
-		fileOwnership: {
-			taskId: "task-001",
-			mode: "exclusive",
-			include: ["/project/src/auth/**"],
-			exclude: [],
-		},
-		filesInScope: [
-			{ path: "/project/src/auth/login.ts", description: "Login handler" },
-			{ path: "/project/src/auth/jwt.ts", description: "JWT utilities" },
-		],
-		estimatedComplexity: 3 as const,
-		expectedOutputs: [
-			{
-				kind: "file",
-				description: "login.ts implementation",
-				path: "/project/src/auth/login.ts",
-				required: true,
-			},
-			{ kind: "test_result", description: "login tests", required: true },
-		],
-		prohibitedCommands: ["rm -rf /", "yarn build"],
-		permittedCommands: ["tsc", "jest", "node"],
-		requiredCapabilities: ["typescript", "node"],
-		acceptanceCriteria: ["ac1", "ac2"],
-		jobId: "JOB-001",
-	};
-
-	return {
-		task,
-		requirement,
-		context: { entries: [] },
-		provider: "codex",
-		attempt: 1,
-		...overrides,
-	};
-}
-
-function makeDeps(overrides?: {
-	projectRules?: string[];
-	redactor?: (content: string) => string;
-}) {
-	const hasher = createSyncHasher();
-	return {
-		hasher,
-		clock: { now: () => new Date("2026-01-01T00:00:00.000Z") },
-		redactor: {
-			redact: overrides?.redactor ?? ((s: string) => s),
-		},
-		projectRules: overrides?.projectRules ?? [
-			"Use TypeScript strict mode",
-			"Write unit tests for all public functions",
-		],
-	};
-}
-
-// --- Test 1: Deterministic hash --------------------------------------
-
-describe("Deterministic hash", () => {
-	it("identical inputs produce identical prompt content and hash", async () => {
-		const request = makeRequest();
-		const deps = makeDeps();
-
-		const pkg1 = await compilePrompt(request, deps);
-		const pkg2 = await compilePrompt(request, deps);
-
-		assert.strictEqual(pkg1.hash, pkg2.hash, "Hash should be deterministic");
-		assert.strictEqual(pkg1.system, pkg2.system, "System prompt should match");
-		assert.strictEqual(pkg1.user, pkg2.user, "User prompt should match");
-		assert.strictEqual(pkg1.taskId, pkg2.taskId);
-		assert.strictEqual(pkg1.provider, pkg2.provider);
-		assert.strictEqual(pkg1.version, "1");
-	});
-
-	it("different content produces different hash", async () => {
-		const request1 = makeRequest();
-		const request2 = makeRequest({
-			task: {
-				...request1.task,
-				objective: "Different objective",
-			} as CompiledTask,
-		});
-		const deps = makeDeps();
-
-		const pkg1 = await compilePrompt(request1, deps);
-		const pkg2 = await compilePrompt(request2, deps);
-
-		assert.notStrictEqual(
-			pkg1.hash,
-			pkg2.hash,
-			"Different content should produce different hash",
-		);
-	});
-
-	it("hash includes both system and user content", async () => {
-		const request = makeRequest();
-		const deps = makeDeps();
-
-		const pkg = await compilePrompt(request, deps);
-
-		assert.ok(pkg.hash.length > 0, "Hash should not be empty");
-		assert.ok(
-			pkg.hash === deps.hasher.sha256(`${pkg.system}\n${pkg.user}`),
-			"Hash should equal SHA-256 of system+user",
-		);
-	});
-});
-
-// --- Test 2: Required sections never removed -----------------------------
-
-describe("Required sections survive compaction", () => {
-	it("objective section is required and never compacted", async () => {
-		const request = makeRequest({
-			context: {
-				entries: Array.from({ length: 50 }, (_, i) => ({
-					id: `ctx-${i}`,
-					content: `This is supplemental context entry number ${i}. It provides background information that could be safely removed if needed.`,
-					priority: 7, // supplemental priority
-					source: `file-${i}.md`,
-				})),
-			},
-		});
-		const deps = makeDeps();
-
-		const pkg = await compilePrompt(request, deps);
-
-		assert.ok(
-			pkg.user.includes("Implement user login feature"),
-			"Objective should be in user prompt",
-		);
-		assert.ok(
-			pkg.user.includes("User can log in with valid credentials"),
-			"Acceptance criteria should be preserved",
-		);
-		assert.ok(
-			pkg.user.includes("/project/src/auth/login.ts"),
-			"Files in scope should be preserved",
-		);
-	});
-
-	it("project rules section is required", async () => {
-		const request = makeRequest();
-		const deps = makeDeps({
-			projectRules: ["Use TypeScript", "No console.log"],
-		});
-
-		const pkg = await compilePrompt(request, deps);
-
-		assert.ok(
-			pkg.system.includes("TypeScript") || pkg.user.includes("TypeScript"),
-			"Project rules should be in prompt",
-		);
-	});
-
-	it("acceptance criteria are never removed", async () => {
-		const request = makeRequest();
-		const deps = makeDeps();
-
-		const pkg = await compilePrompt(request, deps);
-
-		const acSection = pkg.sections.find(
-			(s) => s.kind === "acceptance_criteria",
-		);
-		assert.ok(acSection, "AC section should exist");
-		assert.strictEqual(
-			acSection?.required,
-			true,
-			"AC section should be required",
-		);
-		assert.ok(
-			pkg.user.includes("User can log in with valid credentials"),
-			"AC text should be in prompt",
-		);
-	});
-});
-
-// --- Test 3: Provider formatting ---------------------------------------
-
-describe("Provider formatting", () => {
-	it("anthropic uses XML formatting", async () => {
-		const request = makeRequest({ provider: "anthropic" });
-		const deps = makeDeps();
-
-		const pkg = await compilePrompt(request, deps);
-		const profile = PROVIDER_PROFILES.anthropic;
-
-		const sections = buildSections(
-			normalizeRequest(request),
-			deps.projectRules,
-		);
-		const rendered = renderForProvider(sections, profile);
-
-		// Anthropic's rules go in system
-		if (profile.supportsSystemPrompt) {
-			assert.ok(
-				rendered.system.length > 0 || rendered.user.length > 0,
-				"Should have some output",
-			);
-		}
-	});
-
-	it("all supported providers produce valid output", async () => {
-		const request = makeRequest();
-		const providers: Array<
-			"codex" | "minimax" | "glm" | "openai" | "anthropic" | "gemini"
-		> = ["codex", "minimax", "glm", "openai", "anthropic", "gemini"];
-
-		for (const provider of providers) {
-			const req = makeRequest({ provider });
-			const deps = makeDeps();
-			const pkg = await compilePrompt(req, deps);
-
-			assert.ok(
-				pkg.system.length > 0 || pkg.user.length > 0,
-				`Provider ${provider} should produce output`,
-			);
-			assert.strictEqual(pkg.provider, provider);
-		}
-	});
-
-	it("different styles produce different formatting but same content", async () => {
-		const request = makeRequest({ provider: "openai" });
-		const deps = makeDeps();
-
-		const pkg1 = await compilePrompt(request, deps);
-		const req2 = makeRequest({ provider: "anthropic" });
-		const pkg2 = await compilePrompt(req2, deps);
-
-		// Both should contain the same key content
-		assert.ok(
-			pkg1.user.includes("Implement user login"),
-			"OpenAI should have objective",
-		);
-		assert.ok(
-			pkg2.user.includes("Implement user login"),
-			"Anthropic should have objective",
-		);
-	});
-});
-
-// --- Test 4: Secret redaction -----------------------------------------
-
-describe("Secret redaction", () => {
-	it("API keys are redacted before persistence", async () => {
-		const request = makeRequest();
-		const deps = makeDeps({
-			redactor: (content: string) =>
-				content
-					.replace(/sk-[a-zA-Z0-9]{20,}/g, "[API_KEY_REDACTED]")
-					.replace(/password\s*=\s*["'][^"']+["']/gi, 'password="[REDACTED]"'),
-		});
-
-		const secretRequest = makeRequest({
-			task: {
-				...request.task,
-				objective: "Use API key sk-1234567890abcdefghij for authentication",
-				permittedCommands: [
-					"curl -H 'Authorization: Bearer sk-abcdefghijklmnop12345' https://api.example.com",
-				],
-			} as CompiledTask,
-		});
-
-		const pkg = await compilePrompt(secretRequest, deps);
-
-		assert.ok(
-			!pkg.user.includes("sk-1234567890abcdefghij"),
-			"API key should be redacted",
-		);
-		assert.ok(
-			!pkg.user.includes("sk-abcdefghijklmnop12345"),
-			"Bearer token should be redacted",
-		);
-	});
-
-	it("identity section preserves task ID", async () => {
-		const request = makeRequest();
-		const deps = makeDeps();
-
-		const pkg = await compilePrompt(request, deps);
-
-		assert.ok(pkg.user.includes("task-001"), "Task ID should be preserved");
-		assert.ok(
-			pkg.user.includes("REQ-001"),
-			"Requirement ID should be preserved",
-		);
-	});
-
-	it("hash is computed over redacted content", async () => {
-		const request = makeRequest();
-		const deps = makeDeps({
-			redactor: (content: string) =>
-				content.replace(/sk-[a-zA-Z0-9]+/g, "[REDACTED]"),
-		});
-
-		const pkg = await compilePrompt(request, deps);
-
-		assert.ok(pkg.hash.length > 0, "Hash should be computed");
-		assert.ok(!pkg.user.includes("sk-"), "No API keys in prompt");
-	});
-});
-
-// --- Test 5: Error codes -----------------------------------------------
-
-describe("Error codes", () => {
-	it("INVALID_TASK when task ID is empty", async () => {
-		const base = makeRequest();
-		const request = makeRequest({
-			task: { ...base.task, id: "" },
-		});
-		const deps = makeDeps();
-
-		await assert.rejects(
-			async () => compilePrompt(request, deps),
-			(err: unknown) => {
-				if (err instanceof PromptCompileError) {
-					assert.strictEqual(err.code, "INVALID_TASK");
-					return true;
-				}
-				return false;
-			},
-		);
-	});
-
-	it("MISSING_OBJECTIVE when objective is empty", async () => {
-		const base = makeRequest();
-		const request = makeRequest({
-			task: { ...base.task, objective: "" },
-		});
-		const deps = makeDeps();
-
-		await assert.rejects(
-			async () => compilePrompt(request, deps),
-			(err: unknown) => {
-				if (err instanceof PromptCompileError) {
-					assert.strictEqual(err.code, "MISSING_OBJECTIVE");
-					return true;
-				}
-				return false;
-			},
-		);
-	});
-
-	it("MISSING_OUTPUT_CONTRACT when no outputs defined", async () => {
-		const base = makeRequest();
-		const request = makeRequest({
-			task: { ...base.task, expectedOutputs: [] },
-		});
-		const deps = makeDeps();
-
-		await assert.rejects(
-			async () => compilePrompt(request, deps),
-			(err: unknown) => {
-				if (err instanceof PromptCompileError) {
-					assert.strictEqual(err.code, "MISSING_OUTPUT_CONTRACT");
-					return true;
-				}
-				return false;
-			},
-		);
-	});
-
-	it("TOKEN_BUDGET_EXCEEDED when estimated tokens exceed budget", async () => {
-		// Test validation directly: compactToBudget removes all compactable content,
-		// so the full compile cannot produce TOKEN_BUDGET_EXCEEDED.
-		// We test validateTokenBudget directly.
-		const profile = PROVIDER_PROFILES.codex;
-		const available = profile.maximumInputTokens - profile.reservedOutputTokens;
-
-		assert.throws(
-			() => validateTokenBudget(available + 1, profile),
-			(err: unknown) => {
-				if (err instanceof PromptCompileError) {
-					assert.strictEqual(err.code, "TOKEN_BUDGET_EXCEEDED");
-					return true;
-				}
-				return false;
-			},
-		);
-	});
-	it("POLICY_CONFLICT for prohibited tools", async () => {
-		const base = makeRequest();
-		const request = makeRequest({
-			task: {
-				...base.task,
-				permittedCommands: ["rm -rf /", "tsc", "jest"],
-			},
-		});
-		const deps = makeDeps();
-
-		await assert.rejects(
-			async () => compilePrompt(request, deps),
-			(err: unknown) => {
-				if (err instanceof PromptCompileError) {
-					assert.strictEqual(err.code, "POLICY_CONFLICT");
-					return true;
-				}
-				return false;
-			},
-		);
-	});
-
-	it("INVALID_TASK for unknown provider", async () => {
-		const request = makeRequest({ provider: "unknown-provider" as "codex" });
-		const deps = makeDeps();
-
-		await assert.rejects(
-			async () => compilePrompt(request, deps),
-			(err: unknown) => {
-				if (err instanceof PromptCompileError) {
-					assert.strictEqual(err.code, "INVALID_TASK");
-					return true;
-				}
-				return false;
-			},
-		);
-	});
-});
-
-// --- Test 6: Continuation without repetition ---------------------------
-
-describe("Continuation without repetition", () => {
-	it("completed items are marked as done, not repeated", async () => {
-		const request = makeRequest({
-			continuation: {
-				previousResponsePath: "/path/to/previous/response.json",
-				completedItems: ["Step 1: Login form", "Step 2: JWT utility"],
-				incompleteItems: ["Step 3: Error handling"],
-				instruction: "continue_without_repeating",
-			},
-		});
-		const deps = makeDeps();
-
-		const pkg = await compilePrompt(request, deps);
-
-		assert.ok(
-			pkg.user.includes("Step 1: Login form") || pkg.user.includes("DONE"),
-			"Completed items should be marked",
-		);
-		assert.ok(
-			pkg.user.includes("Step 3: Error handling"),
-			"Incomplete items should be included",
-		);
-		assert.ok(
-			pkg.user.includes("Continue from where the previous attempt stopped"),
-			"Continuation instruction should be present",
-		);
-	});
-
-	it("continuation section has required=true so it survives compaction", async () => {
-		const request = makeRequest({
-			continuation: {
-				previousResponsePath: "/tmp/response.json",
-				completedItems: ["A", "B"],
-				incompleteItems: ["C"],
-				instruction: "continue_without_repeating",
-			},
-		});
-		const deps = makeDeps();
-
-		const pkg = await compilePrompt(request, deps);
-
-		const contSection = pkg.sections.find(
-			(s) => s.kind === "continuation_instructions",
-		);
-		assert.ok(contSection, "Continuation section should exist");
-		assert.strictEqual(
-			contSection?.required,
-			true,
-			"Continuation should be required",
-		);
-	});
-
-	it("previous response path is referenced", async () => {
-		const request = makeRequest({
-			continuation: {
-				previousResponsePath: "/tmp/attempt-1-response.json",
-				completedItems: [],
-				incompleteItems: ["Remaining work"],
-				instruction: "continue_without_repeating",
-			},
-		});
-		const deps = makeDeps();
-
-		const pkg = await compilePrompt(request, deps);
-
-		assert.ok(
-			pkg.user.includes("attempt-1-response.json") ||
-				pkg.sections.some((s) =>
-					s.sourceRefs.some((ref) => ref.source.includes("attempt-1")),
-				),
-			"Previous response path should be referenced",
-		);
-	});
-});
-
-// --- Test 7: Token budget ----------------------------------------------
-
-describe("Token budget", () => {
-	it("estimateTokens returns 0 for empty string", () => {
-		assert.strictEqual(estimateTokens(""), 0);
-		assert.strictEqual(estimateTokens("   "), 0);
-	});
-
-	it("estimateTokens scales with content length", () => {
-		const short = "hello";
-		const long = "hello world this is a much longer string";
-
-		assert.ok(estimateTokens(long) > estimateTokens(short));
-	});
-
-	it("compactToBudget preserves required sections", () => {
-		const sections = [
-			{
-				id: "objective",
-				kind: "objective" as const,
-				content: "This is the critical objective",
-				required: true,
-				compactable: false,
-				sourceRefs: [],
-			},
-			{
-				id: "context-1",
-				kind: "supplemental" as const,
-				content: "This is supplemental content that can be removed",
-				required: false,
-				compactable: true,
-				sourceRefs: [],
-			},
-		];
-
-		const result = compactToBudget(sections, 100, estimateTokens);
-
-		const objectiveSection = result.sections.find((s) => s.id === "objective");
-		assert.ok(
-			objectiveSection?.content.includes("critical objective"),
-			"Required section should be preserved",
-		);
-	});
-
-	it("validateTokenBudget throws when exceeded", () => {
-		const profile = PROVIDER_PROFILES.codex;
-		const available = profile.maximumInputTokens - profile.reservedOutputTokens;
-
-		assert.throws(
-			() => validateTokenBudget(available + 1, profile),
-			(err: unknown) => {
-				if (err instanceof PromptCompileError) {
-					assert.strictEqual(err.code, "TOKEN_BUDGET_EXCEEDED");
-					return true;
-				}
-				return false;
-			},
-		);
-	});
-
-	it("validateTokenBudget passes when within budget", () => {
-		const profile = PROVIDER_PROFILES.codex;
-		const available = profile.maximumInputTokens - profile.reservedOutputTokens;
-
-		assert.doesNotThrow(() => validateTokenBudget(available, profile));
-		assert.doesNotThrow(() => validateTokenBudget(100, profile));
-	});
-});
-
-// --- Test 8: Deduplication ---------------------------------------------
-
-describe("Deduplication", () => {
-	it("normalizeForDeduplication strips markdown and lowercases", () => {
-		assert.strictEqual(normalizeForDeduplication("# Header"), "header");
-		assert.strictEqual(normalizeForDeduplication("**bold** text"), "bold text");
-		assert.strictEqual(
-			normalizeForDeduplication("[link](http://example.com)"),
-			"link",
-		);
-		assert.strictEqual(
-			normalizeForDeduplication("  spaces  collapse  "),
-			"spaces collapse",
-		);
-	});
-
-	it("duplicate lines are removed from compactable sections", () => {
-		const sections = [
-			{
-				id: "context-1",
-				kind: "relevant_context" as const,
-				content:
-					"Important note\nThis is repeated\nThis is repeated\nAnother line",
-				required: false,
-				compactable: true,
-				sourceRefs: [],
-			},
-		];
-
-		const result = deduplicateSections(sections);
-
-		assert.ok(
-			result[0]?.content.split("\n").filter(Boolean).length < 4,
-			"Duplicates should be removed",
-		);
-	});
-
-	it("required sections are not deduplicated", () => {
-		const sections = [
-			{
-				id: "objective",
-				kind: "objective" as const,
-				content: "Same objective",
-				required: true,
-				compactable: false,
-				sourceRefs: [],
-			},
-			{
-				id: "objective-2",
-				kind: "objective" as const,
-				content: "Same objective",
-				required: true,
-				compactable: false,
-				sourceRefs: [],
-			},
-		];
-
-		const result = deduplicateSections(sections);
-
-		// Both required sections should be preserved
-		assert.strictEqual(
-			result.length,
-			2,
-			"Required sections should not be deduplicated",
-		);
-	});
-});
-
-// --- Test 9: Metadata completeness ------------------------------------
-
-describe("Metadata completeness", () => {
-	it("PromptPackage includes token estimate and source refs", async () => {
-		const request = makeRequest({
-			context: {
-				entries: [
-					{
-						id: "ctx-1",
-						content: "Important context about the codebase",
-						priority: 1,
-						source: "repo/readme.md",
-					},
-				],
-			},
-		});
-		const deps = makeDeps();
-
-		const pkg = await compilePrompt(request, deps);
-
-		assert.ok(
-			pkg.estimatedInputTokens > 0,
-			"Token estimate should be positive",
-		);
-		assert.ok(pkg.sourceRefs.length > 0, "Should have source references");
-		assert.strictEqual(pkg.version, "1");
-		assert.strictEqual(pkg.createdAt, "2026-01-01T00:00:00.000Z");
-		assert.ok(pkg.hash.length > 0, "Hash should be present");
-	});
-
-	it("sections are ordered deterministically", async () => {
-		const request = makeRequest();
-		const deps = makeDeps();
-
-		const pkg = await compilePrompt(request, deps);
-
-		const kinds = pkg.sections.map((s) => s.kind);
-		// identity should come first
-		assert.strictEqual(kinds[0], "identity");
-		// objective should be early
-		assert.ok(
-			kinds.indexOf("objective") < kinds.indexOf("supplemental") ||
-				!kinds.includes("supplemental"),
-		);
-	});
-});
-
-// --- Test 10: PromptCompileError -------------------------------------
-
-describe("PromptCompileError", () => {
-	it("has correct name, code, and message", () => {
-		const error = new PromptCompileError(
-			"TOKEN_BUDGET_EXCEEDED",
-			"Budget exceeded",
-			{ estimated: 1000, available: 500 },
-		);
-
-		assert.strictEqual(error.name, "PromptCompileError");
-		assert.strictEqual(error.code, "TOKEN_BUDGET_EXCEEDED");
-		assert.strictEqual(error.message, "Budget exceeded");
-		assert.deepStrictEqual(error.details, { estimated: 1000, available: 500 });
-	});
-
-	it("is instance of Error", () => {
-		const error = new PromptCompileError("INVALID_TASK", "Bad task");
-		assert.ok(error instanceof Error);
-		assert.ok(error instanceof PromptCompileError);
-	});
-});
-
-// --- Test 11: normalizeRequest ----------------------------------------
-
-describe("normalizeRequest", () => {
-	it("trims strings", () => {
-		const req = makeRequest({
-			task: { ...makeRequest().task, id: "  task-001  " } as CompiledTask,
-		});
-		const normalized = normalizeRequest(req);
-		assert.strictEqual(normalized.taskId, "task-001");
-	});
-
-	it("sorts context entries by priority", () => {
-		const req = makeRequest({
-			context: {
-				entries: [
-					{ id: "a", content: "Low priority", priority: 5, source: "x" },
-					{ id: "b", content: "High priority", priority: 1, source: "y" },
-					{ id: "c", content: "Medium priority", priority: 3, source: "z" },
-				],
-			},
-		});
-		const normalized = normalizeRequest(req);
-
-		assert.strictEqual(normalized.contextEntries[0]?.id, "b");
-		assert.strictEqual(normalized.contextEntries[1]?.id, "c");
-		assert.strictEqual(normalized.contextEntries[2]?.id, "a");
-	});
-
-	it("removes duplicates from arrays", () => {
-		const req = makeRequest();
-		const withDupes = normalizeRequest({
-			...req,
-			context: {
-				entries: [
-					{ id: "a", content: "Content A", priority: 1, source: "x" },
-					{ id: "b", content: "Content A", priority: 1, source: "y" }, // duplicate content
-				],
-			},
-		});
-
-		const uniqueContents = new Set(
-			withDupes.contextEntries.map((e) => e.content),
-		);
-		assert.strictEqual(
-			uniqueContents.size,
-			1,
-			"Duplicate content should be removed",
-		);
-	});
-});