pi-harness-runtime 0.10.43 → 1.1.1

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

@@ -0,0 +1,813 @@
+/**
+ * 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",
+		);
+	});
+});