@@ -29,7 +29,7 @@ const providerProfiles = {
 		requiredEnvironment: "DEEPSEEK_API_KEY",
 	},
 };
-const suiteVersions = new Set(["v1", "v2", "v3", "v4"]);
+const suiteVersions = new Set(["v1", "v2", "v3", "v4", "v5"]);
 
 function getProviderProfile(profileId) {
 	const profile = providerProfiles[profileId];
@@ -64,11 +64,11 @@ function parseArguments(argv) {
 	}
 	if (outputRoot === undefined || model === undefined)
 		throw new Error(
-		"Usage: npm run benchmark:harness-native-suite -- --output-root <new-directory> --model <model> [--provider-profile <profile>] [--suite-version <v1|v2|v3|v4>] [--dry-run]",
+		"Usage: npm run benchmark:harness-native-suite -- --output-root <new-directory> --model <model> [--provider-profile <profile>] [--suite-version <v1|v2|v3|v4|v5>] [--dry-run]",
 		);
 	if (!modelPattern.test(model)) throw new Error("model must be a valid 1-128 character model identifier.");
 	getProviderProfile(providerProfile);
-	if (!suiteVersions.has(suiteVersion)) throw new Error("suite-version must be one of: v1, v2, v3, v4.");
+	if (!suiteVersions.has(suiteVersion)) throw new Error("suite-version must be one of: v1, v2, v3, v4, v5.");
 	return { outputRoot, model, providerProfile, suiteVersion, dryRun };
 }
 
@@ -140,10 +140,11 @@ async function main() {
 	const options = parseArguments(process.argv.slice(2));
 	const providerProfile = getProviderProfile(options.providerProfile ?? "openai-responses");
 	const fixtureSources =
-		options.suiteVersion === "v4"
+		options.suiteVersion === "v4" || options.suiteVersion === "v5"
 			? [
 				join(fixtureRoot, "harness-native-benchmark-suite-v3"),
 				join(fixtureRoot, "harness-native-benchmark-suite-v4-extension"),
+				...(options.suiteVersion === "v5" ? [join(fixtureRoot, "harness-native-benchmark-suite-v5-extension")] : []),
 			]
 			: [join(fixtureRoot, `harness-native-benchmark-suite-${options.suiteVersion}`)];
 	if (!options.dryRun && !process.env[providerProfile.requiredEnvironment]?.trim())
 
@@ -33,6 +33,7 @@ const registeredTools: HarnessNativeToolName[] = [
 	"git-diff",
 	"apply-patch",
 	"apply-patch-batch",
+	"apply-edit-batch",
 	"create-file",
 ];
 
@@ -172,6 +173,11 @@ interface ConstrainedPatch {
 	replacementText: string;
 }
 
+interface ConstrainedNewFile {
+	path: string;
+	content: string;
+}
+
 function exactOccurrenceCount(content: string, expectedText: string): number {
 	return content.split(expectedText).length - 1;
 }
@@ -199,12 +205,13 @@ function replaceExactText(
 	return content.replace(normalizedExpected, normalizeLineEndings(replacementText, lineEnding));
 }
 
-async function preparePatchBatch(
+async function preparePatches(
 	root: string,
 	value: unknown,
+	options: { minimum: number; maximum: number; failureMessage: string },
 ): Promise<Array<{ path: string; content: string; replacement: string }>> {
-	if (!Array.isArray(value) || value.length < 2 || value.length > 8)
-		throw new Error("Patch batch must contain 2-8 patches.");
+	if (!Array.isArray(value) || value.length < options.minimum || value.length > options.maximum)
+		throw new Error(options.failureMessage);
 	const patches: ConstrainedPatch[] = [];
 	for (const item of value) {
 		if (item === null || typeof item !== "object") throw new Error("Patch batch entry is invalid.");
@@ -244,6 +251,45 @@ async function preparePatchBatch(
 	return prepared;
 }
 
+async function preparePatchBatch(root: string, value: unknown) {
+	return await preparePatches(root, value, {
+		minimum: 2,
+		maximum: 8,
+		failureMessage: "Patch batch must contain 2-8 patches.",
+	});
+}
+
+async function prepareNewFiles(root: string, value: unknown): Promise<ConstrainedNewFile[]> {
+	if (!Array.isArray(value) || value.length > 8) throw new Error("New-file batch is invalid.");
+	const files: ConstrainedNewFile[] = [];
+	for (const item of value) {
+		if (item === null || typeof item !== "object") throw new Error("New-file batch entry is invalid.");
+		const file = item as Partial<ConstrainedNewFile>;
+		if (typeof file.content !== "string" || file.content.length > 32_768 || file.content.includes("\0"))
+			throw new Error("New-file batch entry content is invalid.");
+		files.push({ path: await safeNewFile(root, file.path), content: file.content });
+	}
+	if (new Set(files.map((file) => file.path)).size !== files.length)
+		throw new Error("New-file batch must not target the same file twice.");
+	return files;
+}
+
+async function prepareEditBatch(root: string, value: unknown) {
+	if (value === null || typeof value !== "object") throw new Error("Edit batch is invalid.");
+	const batch = value as { patches?: unknown; creates?: unknown };
+	const patches = await preparePatches(root, batch.patches, {
+		minimum: 0,
+		maximum: 8,
+		failureMessage: "Edit batch patches are invalid.",
+	});
+	const creates = await prepareNewFiles(root, batch.creates);
+	const editCount = patches.length + creates.length;
+	if (editCount < 2 || editCount > 8) throw new Error("Edit batch must contain 2-8 edits.");
+	if (new Set([...patches.map((patch) => patch.path), ...creates.map((file) => file.path)]).size !== editCount)
+		throw new Error("Edit batch must not mix a patch and creation for the same file.");
+	return { patches, creates };
+}
+
 function summary(value: string, limit: number): string {
 	return value.length <= limit ? value : `${value.slice(0, limit)}\n[truncated]`;
 }
@@ -398,6 +444,16 @@ async function executeTool(
 				evidence: `Applied ${patches.length} constrained text replacements after batch preflight.`,
 			};
 		}
+		if (name === "apply-edit-batch") {
+			const batch = await prepareEditBatch(root, request.arguments);
+			for (const patch of batch.patches) await writeFile(patch.path, patch.replacement, "utf8");
+			for (const file of batch.creates) await writeFile(file.path, file.content, { encoding: "utf8", flag: "wx" });
+			return {
+				status: "ok" as const,
+				observation: `Edit batch applied to ${batch.patches.length} existing and ${batch.creates.length} new files.`,
+				evidence: `Applied ${batch.patches.length} constrained replacements and created ${batch.creates.length} files after batch preflight.`,
+			};
+		}
 		if (name === "create-file") {
 			const content = request.arguments.content;
 			if (typeof content !== "string" || content.length > 32_768 || content.includes("\0"))
 
@@ -133,6 +133,39 @@ const toolParameters: Record<HarnessNativeToolName, Record<string, unknown>> = {
 		required: ["patches"],
 		additionalProperties: false,
 	},
+	"apply-edit-batch": {
+		type: "object",
+		properties: {
+			patches: {
+				type: "array",
+				minItems: 0,
+				maxItems: 8,
+				items: {
+					type: "object",
+					properties: {
+						path: { type: "string" },
+						expectedText: { type: "string" },
+						replacementText: { type: "string" },
+					},
+					required: ["path", "expectedText", "replacementText"],
+					additionalProperties: false,
+				},
+			},
+			creates: {
+				type: "array",
+				minItems: 0,
+				maxItems: 8,
+				items: {
+					type: "object",
+					properties: { path: { type: "string" }, content: { type: "string" } },
+					required: ["path", "content"],
+					additionalProperties: false,
+				},
+			},
+		},
+		required: ["patches", "creates"],
+		additionalProperties: false,
+	},
 	"create-file": {
 		type: "object",
 		properties: { path: { type: "string" }, content: { type: "string" } },
@@ -195,7 +228,9 @@ function selectedTools(tools: readonly HarnessNativeToolName[]) {
 			description:
 				name === "run-public-verification"
 					? "Run one TaskSpec-declared public verification command by its zero-based index. It cannot run arbitrary commands."
-					: `Request the Harness-owned ${name} tool.`,
+					: name === "apply-edit-batch"
+						? "Apply a preflighted batch of existing-file text replacements and new-file creations. Every target must stay within the managed workspace."
+						: `Request the Harness-owned ${name} tool.`,
 			parameters: toolParameters[name],
 		})),
 		{
 
@@ -231,6 +231,7 @@ export type HarnessNativeToolName =
 	| "git-diff"
 	| "apply-patch"
 	| "apply-patch-batch"
+	| "apply-edit-batch"
 	| "create-file"
 	| "run-public-verification";
 export type HarnessNativeTerminationReason =
 
@@ -207,6 +207,36 @@ describe("Harness-native Benchmark Suite v1", () => {
 		}
 	});
 
+	it("materializes the v5 controlled edit and self-verification corpus without changing v4", async () => {
+		const root = await mkdtemp(join(tmpdir(), "agentpatchcheck-native-benchmark-suite-"));
+		const outputRoot = join(root, "suite");
+		try {
+			const { stdout } = await execFile(
+				process.execPath,
+				[suiteScript, "--output-root", outputRoot, "--model", "test-model", "--suite-version", "v5", "--dry-run"],
+				{ cwd: projectRoot, windowsHide: true },
+			);
+			const output = JSON.parse(stdout) as NativeSuiteDryRunOutput;
+			expect(output).toMatchObject({
+				suite: { id: "harness-native-public-repair", fixtureVersion: "v5" },
+				baseCommit: "1f487c7346407098397230807a9f4c971a826781",
+			});
+			expect(output.taskSpecPaths).toHaveLength(13);
+			const taskPath = output.taskSpecPaths.find((path) => path.endsWith("edit-batch-public-verification.json"));
+			const policy = await validateTaskPolicy(await loadTaskSpec(taskPath ?? ""));
+			expect(policy).toMatchObject({
+				verificationProfile: { name: "edit-batch-public" },
+				hiddenOracle: { scriptPath: expect.stringContaining("oracle-edit-batch-public-verification.mjs") },
+				nativeAgent: { maxIterations: 8, maxToolCalls: 10 },
+			});
+			expect(
+				await readFile(join(outputRoot, "tasks", "prompts", "edit-batch-public-verification.txt"), "utf8"),
+			).toContain("apply-edit-batch");
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
 	it("fails before materializing a suite when model selection is omitted", async () => {
 		const root = await mkdtemp(join(tmpdir(), "agentpatchcheck-native-benchmark-suite-"));
 		const outputRoot = join(root, "suite");
 
@@ -373,6 +373,138 @@ describe("Harness-native Agent Runtime", () => {
 		}
 	});
 
+	it("preflights and applies a combined existing-file and new-file edit batch", async () => {
+		const worktree = await mkdtemp(join(tmpdir(), "agentpatchcheck-native-runtime-"));
+		try {
+			await mkdir(join(worktree, "docs"), { recursive: true });
+			await writeFile(join(worktree, "README.md"), "before\n", "utf8");
+			const provider: HarnessNativeModelProvider = {
+				id: "test-provider",
+				decide: async ({ observations }) =>
+					observations.length === 0
+						? {
+								decision: {
+									kind: "tool",
+									tool: "apply-edit-batch",
+									arguments: {
+										patches: [
+											{
+												path: "README.md",
+												expectedText: "before",
+												replacementText: "after",
+											},
+										],
+										creates: [{ path: "docs/usage.md", content: "usage\n" }],
+									},
+								},
+							}
+						: { decision: { kind: "finish" } },
+			};
+
+			const result = await runHarnessNativeRuntime({
+				policy: testNativePolicy({ maxIterations: 2, maxToolCalls: 1 }),
+				prompt: "Update README and add usage documentation.",
+				model: "test-model",
+				worktreePath: worktree,
+				provider,
+				timeoutMs: 1_000,
+			});
+
+			expect(result).toMatchObject({ status: "succeeded", toolCalls: 1 });
+			expect(result.trajectory[0]).toMatchObject({ tool: "apply-edit-batch", toolStatus: "ok" });
+			expect(await readFile(join(worktree, "README.md"), "utf8")).toBe("after\n");
+			expect(await readFile(join(worktree, "docs", "usage.md"), "utf8")).toBe("usage\n");
+		} finally {
+			await rm(worktree, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects a combined edit batch before changing any target when creation preflight fails", async () => {
+		const worktree = await mkdtemp(join(tmpdir(), "agentpatchcheck-native-runtime-"));
+		try {
+			await writeFile(join(worktree, "README.md"), "before\n", "utf8");
+			await writeFile(join(worktree, "existing.md"), "original\n", "utf8");
+			const provider: HarnessNativeModelProvider = {
+				id: "test-provider",
+				decide: async ({ observations }) =>
+					observations.length === 0
+						? {
+								decision: {
+									kind: "tool",
+									tool: "apply-edit-batch",
+									arguments: {
+										patches: [
+											{
+												path: "README.md",
+												expectedText: "before",
+												replacementText: "after",
+											},
+										],
+										creates: [{ path: "existing.md", content: "overwrite\n" }],
+									},
+								},
+							}
+						: { decision: { kind: "finish" } },
+			};
+
+			const result = await runHarnessNativeRuntime({
+				policy: testNativePolicy({ maxIterations: 2, maxToolCalls: 1 }),
+				prompt: "Try an invalid batch.",
+				model: "test-model",
+				worktreePath: worktree,
+				provider,
+				timeoutMs: 1_000,
+			});
+
+			expect(result.trajectory[0]).toMatchObject({ tool: "apply-edit-batch", toolStatus: "rejected" });
+			expect(await readFile(join(worktree, "README.md"), "utf8")).toBe("before\n");
+			expect(await readFile(join(worktree, "existing.md"), "utf8")).toBe("original\n");
+		} finally {
+			await rm(worktree, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects more than eight combined edits before changing any target", async () => {
+		const worktree = await mkdtemp(join(tmpdir(), "agentpatchcheck-native-runtime-"));
+		try {
+			await writeFile(join(worktree, "README.md"), "before\n", "utf8");
+			const provider: HarnessNativeModelProvider = {
+				id: "test-provider",
+				decide: async ({ observations }) =>
+					observations.length === 0
+						? {
+								decision: {
+									kind: "tool",
+									tool: "apply-edit-batch",
+									arguments: {
+										patches: [{ path: "README.md", expectedText: "before", replacementText: "after" }],
+										creates: Array.from({ length: 8 }, (_, index) => ({
+											path: `new-${index}.txt`,
+											content: "new\n",
+										})),
+									},
+								},
+							}
+						: { decision: { kind: "finish" } },
+			};
+
+			const result = await runHarnessNativeRuntime({
+				policy: testNativePolicy({ maxIterations: 2, maxToolCalls: 1 }),
+				prompt: "Try an oversized batch.",
+				model: "test-model",
+				worktreePath: worktree,
+				provider,
+				timeoutMs: 1_000,
+			});
+
+			expect(result.trajectory[0]).toMatchObject({ tool: "apply-edit-batch", toolStatus: "rejected" });
+			expect(await readFile(join(worktree, "README.md"), "utf8")).toBe("before\n");
+			await expect(readFile(join(worktree, "new-0.txt"), "utf8")).rejects.toMatchObject({ code: "ENOENT" });
+		} finally {
+			await rm(worktree, { recursive: true, force: true });
+		}
+	});
+
 	it("applies a multi-line LF request to a CRLF file while preserving CRLF output", async () => {
 		const worktree = await mkdtemp(join(tmpdir(), "agentpatchcheck-native-runtime-"));
 		try {
 
@@ -0,0 +1,20 @@
+{
+  "version": 1,
+  "name": "harness-native-public-repair-v5",
+  "suite": { "id": "harness-native-public-repair", "fixtureVersion": "v5" },
+  "tasks": [
+    { "id": "public-repair", "taskSpec": "tasks/public-repair.json" },
+    { "id": "create-new-file", "taskSpec": "tasks/create-new-file.json" },
+    { "id": "multi-file-local-repair", "taskSpec": "tasks/multi-file-local-repair.json" },
+    { "id": "recursive-cross-directory-repair", "taskSpec": "tasks/recursive-cross-directory-repair.json" },
+    { "id": "recursive-feedback-repair", "taskSpec": "tasks/recursive-feedback-repair.json" },
+    { "id": "configuration-semantic-repair", "taskSpec": "tasks/configuration-semantic-repair.json" },
+    { "id": "recursive-feedback-invariant-repair", "taskSpec": "tasks/recursive-feedback-invariant-repair.json" },
+    { "id": "nested-configuration-invariant-repair", "taskSpec": "tasks/nested-configuration-invariant-repair.json" },
+    { "id": "source-normalization-repair", "taskSpec": "tasks/source-normalization-repair.json" },
+    { "id": "cross-file-contract-repair", "taskSpec": "tasks/cross-file-contract-repair.json" },
+    { "id": "feature-flag-invariant-repair", "taskSpec": "tasks/feature-flag-invariant-repair.json" },
+    { "id": "validation-boundary-repair", "taskSpec": "tasks/validation-boundary-repair.json" },
+    { "id": "edit-batch-public-verification", "taskSpec": "tasks/edit-batch-public-verification.json" }
+  ]
+}
@@ -0,0 +1,7 @@
+{
+  "version": 1,
+  "baseCommit": "1f487c7346407098397230807a9f4c971a826781",
+  "suite": { "id": "harness-native-public-repair", "fixtureVersion": "v5" },
+  "taskCount": 13,
+  "budgets": { "timeoutMs": 120000, "maxIterations": 8, "maxToolCalls": 10, "maxObservationBytes": 4096 }
+}