immune-brain 4.5.0 → 5.0.0

package/plugins/immune-brain/runtime/unattended/batch_preflight.ts

@@ -20,13 +20,13 @@ import { readBackendClaim } from "../kernel/backend_claim";
 import { computeBatchPlanDigest, type BatchAuthorizationBinding } from "../kernel/batch_authority";
 import { readGitHead } from "../kernel/pi_canary_prepare";
 import { readTaskIntent } from "../kernel/intent";
-import { localRunId, readAuditTaskPair, readTaskRecordRaw, readWorkspaceStateRaw, reconcileKernelAuthority } from "../kernel/storage";
+import { readTaskRecordRaw, readSettledTaskEvidence, readWorkspaceStateRaw, enrollmentEventIdFor, reconcileKernelAuthority } from "../kernel/storage";
+import type { TaskRecord } from "../kernel/types";
 import { pathMatchesScope } from "../workspace_scope";
 import { captureBatchReconfirmation, retainReconfirmation, ownUnpersistedBatchHead, type ReconfirmationSnapshot } from "./batch_reconfirmation";
-import { DEFAULT_DEADLINE_MS, projectBatchPlan } from "./batch_plan";
+import { projectBatchPlan } from "./batch_plan";
 import { batchReason, type BatchReasonKey } from "./batch_reasons";
 import { isTerminalBatchState, readBatchRunState, type BatchRunStateRecord } from "./batch_state";
-import { readRunRowByTask, withKernelRead } from "../kernel/sqlite_store";
 import type {
 	BatchPlanBudget,
 	BatchPlanChild,
@@ -98,6 +98,29 @@ export function readActiveClaimTaskId(root: string): string | null {
 	return workspace.state.current_working || (claim?.lifecycle_status === "active" ? claim.task_id : null);
 }
 
+/**
+ * The initiative whose resumable batch holds `taskId` as an in-flight child, or
+ * null. Read-only; a Host uses it to re-enter the batch after a foreground
+ * child settles, and anything unreadable simply means there is nothing to continue.
+ */
+export function findResumableBatchSlugForTask(root: string, taskId: string): string | null {
+	const batchesDir = join(root, ".imm", "state", "batches");
+	if (!existsSync(batchesDir)) return null;
+	for (const file of readdirSync(batchesDir)) {
+		if (!file.endsWith(".json")) continue;
+		try {
+			const record = JSON.parse(readFileSync(join(batchesDir, file), "utf8")) as BatchRunStateRecord;
+			if (record?.contract !== "assurance_kernel/batch_run_state/v1") continue;
+			if (record.batch_state !== "running" && record.batch_state !== "needs_human") continue;
+			if (record.children.some((child) => child.task_id === taskId && (child.state === "enrolled" || child.state === "settled")))
+				return record.initiative_slug;
+		} catch {
+			continue;
+		}
+	}
+	return null;
+}
+
 /**
  * The batch record for this initiative, or a corruption marker. A terminal
  * record (completed, budget_stopped, failed, rejected) is not active: returning
@@ -182,10 +205,78 @@ export function findSettledBatchRecord(root: string, initiativeSlug: string): Ba
 	return newest;
 }
 
+export type BatchLineage =
+	| { kind: "equal"; head: string }
+	| { kind: "fast_forward"; head: string }
+	| { kind: "broken"; message: string };
+
+/**
+ * Classify live HEAD against the batch's recorded head. `fast_forward` is HEAD
+ * on the same batch branch with the recorded head as an ancestor and every
+ * recorded child commit still reachable: the user's own commit, adopted rather
+ * than refused. Anything else is the fatal `batch_head_lineage_broken`.
+ */
+export function classifyBatchLineage(input: {
+	root: string;
+	branch: string;
+	expectedHead: string;
+	childCommits: readonly string[];
+	/** When set, a fast-forward carrying this batch's own trailer is refused. */
+	batchId?: string;
+}): BatchLineage {
+	const { root, branch, expectedHead, childCommits } = input;
+	const run = (args: string[]) =>
+		spawnSync("git", ["-C", root, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+	const broken = (reason: string): BatchLineage => ({
+		kind: "broken",
+		message: `batch_head_lineage_broken: ${reason}`,
+	});
+	const branchResult = run(["symbolic-ref", "--short", "HEAD"]);
+	const currentBranch = branchResult.stdout.trim();
+	if (branchResult.status !== 0 || currentBranch !== branch)
+		return broken(`current branch ${currentBranch} does not match expected branch ${branch}`);
+	const headResult = run(["rev-parse", "HEAD"]);
+	const head = headResult.stdout.trim();
+	if (headResult.status !== 0 || !head) return broken("current HEAD is unreadable");
+	if (head !== expectedHead && run(["merge-base", "--is-ancestor", expectedHead, head]).status !== 0)
+		return broken(`current HEAD ${head} does not descend from expected batch head ${expectedHead}`);
+	for (const commit of childCommits) {
+		if (run(["merge-base", "--is-ancestor", commit, head]).status !== 0)
+			return broken(`recorded commit ${commit} is no longer reachable from HEAD`);
+	}
+	if (head === expectedHead) return { kind: "equal", head };
+	// Only the runner writes this batch's trailer, and every commit it recorded
+	// is already in childCommits: a fast-forward claiming it is an impersonation
+	// (or an unverified own commit), never the user's own work.
+	if (input.batchId) {
+		const claimed = run([
+			"log",
+			"--fixed-strings",
+			`--grep=Immune-Brain-Batch: ${input.batchId}`,
+			"--format=%H",
+			`${expectedHead}..${head}`,
+		]);
+		const claimant = claimed.stdout.split(/\s+/).find(Boolean);
+		if (claimed.status !== 0 || claimant)
+			return broken(`commit ${claimant ?? head} claims batch ${input.batchId} without recorded evidence`);
+	}
+	return { kind: "fast_forward", head };
+}
+
 /** The HEAD a resumable batch must still sit on: its last child commit, or its base. */
-export function expectedBatchHead(record: { base_head: string; commits?: unknown }): string {
+export function expectedBatchHead(record: {
+	base_head: string;
+	commits?: unknown;
+	adopted_heads?: ReadonlyArray<{ from: string; to: string }>;
+}): string {
 	const commits = Array.isArray(record.commits) ? (record.commits as string[]) : [];
-	return commits.length > 0 ? commits[commits.length - 1]! : record.base_head;
+	let head = commits.length > 0 ? commits[commits.length - 1]! : record.base_head;
+	// An adoption is keyed by the head it moved from, so one recorded before the
+	// last child commit can never resurface as the expected head.
+	for (const adoption of record.adopted_heads ?? []) {
+		if (adoption.from === head) head = adoption.to;
+	}
+	return head;
 }
 
 /**
@@ -226,19 +317,20 @@ export function isOwnBatchClaim(
 	if (!childInBatch || !(childInBatch.state === "enrolled" || childInBatch.state === "needs_human")) {
 		return false;
 	}
-	let rec: Record<string, any> | null = null;
+	let rec: TaskRecord | null = null;
 	try {
-		const run = withKernelRead(root, (db) => readRunRowByTask(db, taskId));
-		rec = run ? (JSON.parse(run.record_json) as Record<string, any>) : null;
+		// Through the store read: the record is identity-validated against its
+		// run instead of being parsed from a raw row.
+		rec = readTaskRecordRaw(root, taskId).record;
 	} catch {
 		return false;
 	}
 	if (!rec) return false;
-	const lineageHeads = [existingBatch.base_head].concat(
-		Array.isArray(existingBatch.commits) ? existingBatch.commits : [],
-	);
+	const lineageHeads = [existingBatch.base_head]
+		.concat(Array.isArray(existingBatch.commits) ? existingBatch.commits : [])
+		.concat((existingBatch.adopted_heads ?? []).map((adoption) => adoption.to));
 	if (!lineageHeads.includes(rec.git_base_head)) return false;
-	if (claim.enrollment_event_id !== `enroll-${taskId}-${claim.created_at}`) return false;
+	if (claim.enrollment_event_id !== enrollmentEventIdFor(taskId, claim.created_at)) return false;
 	const createdAt = Date.parse(claim.created_at);
 	if (!Number.isFinite(createdAt) || createdAt > Date.parse(existingBatch.updated_at)) return false;
 	if (claim.task_id !== taskId || claim.lifecycle_status !== "active") return false;
@@ -264,16 +356,13 @@ function authorizedScopeOf(root: string, taskId: string, state: string): string[
 		// fallback below
 	}
 	if (scope.length === 0 && state === "settled") {
-		// A settled child has no live state record; its authority is the immutable
-		// terminal audit pair. Read-only, so a refusal still writes nothing.
+		// A settled child has no live state record; the Authority Store's settled
+		// Run read is its authority. Read-only, so a refusal still writes nothing.
 		try {
-			const localRun = localRunId(root, taskId);
-			const settled = readAuditTaskPair(root, taskId, localRun ?? undefined);
-			const snapshot = (settled?.record as { intent_snapshot?: { scope_hint?: string[] } } | null | undefined)
-				?.intent_snapshot;
+			const settled = readSettledTaskEvidence(root, taskId);
+			const snapshot = settled?.record.intent_snapshot;
 			scope = snapshot?.scope_hint ?? [];
-			recordedIntentPath = recordedIntentPath ?? (settled?.record as { intent_ref?: { path?: string } } | null | undefined)
-				?.intent_ref?.path;
+			recordedIntentPath = recordedIntentPath ?? settled?.record.intent_ref?.path;
 		} catch {
 			// fallback below
 		}
@@ -347,11 +436,11 @@ async function projectPlanSurface(input: {
 	let budget: BatchPlanBudget;
 
 	if (isResuming && existingBatch) {
-		// Candidate only: renewal uses the same default window as a fresh plan,
-		// while preserving the confirmed count limits and the persisted record.
-		budget = { ...existingBatch.budget };
-		if (Date.parse(budget.deadline_at) <= Date.parse(now))
-			budget.deadline_at = new Date(Date.parse(now) + DEFAULT_DEADLINE_MS).toISOString();
+		// A resume keeps the confirmed count limits of the persisted record.
+		budget = {
+			max_children: existingBatch.budget.max_children,
+			qa_failure_limit: existingBatch.budget.qa_failure_limit,
+		};
 		try {
 			recoveryChildren = existingBatch.children.map((c) => {
 				const intentPath = `docs/plans/${c.task_id}.intent.json`;
@@ -635,7 +724,6 @@ export interface BatchConfirmationFacts {
 	batch_branch: string;
 	plan_digest: string;
 	budget: BatchPlanBudget;
-	expires_at: string;
 	reuse_blockers: string[];
 	children: Array<{ task_id: string; slice_id: string; risk: string; status: BatchPlanChildStatus }>;
 	excluded: Array<{ task_id: string; slice_id: string; reason: string }>;
@@ -656,7 +744,6 @@ export type BatchAuthorizationOutcome<HostRejection> =
 			batch_id: string;
 			reuse_authorization: boolean;
 			reuse_blockers: string[];
-			expires_at: string;
 			binding: BatchAuthorizationBinding;
 	  }
 	| { outcome: "rejected"; rejection: BatchPreflightRejection }
@@ -678,7 +765,7 @@ export interface BatchAuthorizationOptions<HostRejection> {
 
 /**
  * The one authorization flow both Host adapters call after the shared
- * preflight: ADR-0005's reuse/expiry decision, the literal-user gate, the
+ * preflight: ADR-0005's reuse decision, the literal-user gate, the
  * post-gate claim/drift cascade, and the BatchAuthorizationBinding. A Host
  * supplies its gate, its confirmation reference, and its nonce; every decision
  * below stays Host-independent.
@@ -696,10 +783,6 @@ export async function authorizeBatch<HostRejection>(
 	} = projection;
 	const existingBatch = projection.existing_batch;
 
-	// ADR-0005 Decision 1: one Batch Authorization spans the work it authorizes,
-	// so its expiry is the deadline the literal user confirmed rather than a fixed
-	// window that lapses while a child is parked on a foreground Review.
-	const isExistingExpired = isResuming && Date.parse(existingBatch!.authorization_expires_at) <= Date.now();
 	const branchBefore = spawnSync("git", ["-C", root, "branch", "--show-current"], { encoding: "utf8" });
 	if (branchBefore.status !== 0)
 		return { outcome: "rejected", rejection: batchRejection("repository_became_unreadable") };
@@ -709,20 +792,29 @@ export async function authorizeBatch<HostRejection>(
 	// binds falls through to the gate below, which names the reason.
 	const ownsUnpersistedHead = isResuming && existingBatch !== null && existingBatch.plan_digest === planDigest &&
 		expectedBatchHead(existingBatch) !== baseHead && ownUnpersistedBatchHead(root, existingBatch, baseHead);
+	// A fast-forward on the batch branch is the user's own work: the runner adopts
+	// it, so it neither blocks reuse nor counts as moved provenance.
+	const fastForwardsRecordedHead = isResuming && existingBatch !== null && existingBatch.branch === batchBranch &&
+		expectedBatchHead(existingBatch) !== baseHead && !ownsUnpersistedHead &&
+		classifyBatchLineage({
+			root,
+			branch: batchBranch,
+			expectedHead: expectedBatchHead(existingBatch),
+			childCommits: existingBatch.commits,
+			batchId: existingBatch.batch_id,
+		}).kind === "fast_forward";
 	if (isResuming && existingBatch && !existingBatch.commits.length && existingBatch.children[0]?.state === "settled" &&
-		expectedBatchHead(existingBatch) !== baseHead && !ownsUnpersistedHead)
+		expectedBatchHead(existingBatch) !== baseHead && !ownsUnpersistedHead && !fastForwardsRecordedHead)
 		return { outcome: "rejected", rejection: batchRejection("head_moved", "first unpersisted commit provenance is invalid") };
 	const reuseBlockers: string[] = [];
 	if (isResuming && existingBatch) {
-		if (isExistingExpired) reuseBlockers.push("batch_authorization_expired");
-		if (Date.parse(existingBatch.budget.deadline_at) <= Date.now()) reuseBlockers.push("batch_budget_expired");
 		if (existingBatch.batch_state !== "running") reuseBlockers.push("batch_not_running");
 		if (existingBatch.plan_digest !== planDigest) reuseBlockers.push("batch_plan_digest_changed");
 		if (existingBatch.branch !== batchBranch) reuseBlockers.push("batch_branch_changed");
-		if (expectedBatchHead(existingBatch) !== baseHead && !ownsUnpersistedHead) reuseBlockers.push("batch_head_lineage_moved");
+		if (expectedBatchHead(existingBatch) !== baseHead && !ownsUnpersistedHead && !fastForwardsRecordedHead)
+				reuseBlockers.push("batch_head_lineage_moved");
 	}
 	const reuseAuthorization = isResuming && reuseBlockers.length === 0;
-	const expiresAt = reuseAuthorization ? existingBatch!.authorization_expires_at : budget.deadline_at;
 
 	const batchId = isResuming && existingBatch ? existingBatch.batch_id : `batch-${initiativeSlug}-${randomUUID()}`;
 	const facts: BatchConfirmationFacts = {
@@ -730,7 +822,6 @@ export async function authorizeBatch<HostRejection>(
 		batch_branch: batchBranch,
 		plan_digest: planDigest,
 		budget,
-		expires_at: expiresAt,
 		reuse_blockers: reuseBlockers,
 		children: projection.recovery_children.map((child) => ({
 			task_id: child.task_id,
@@ -777,8 +868,8 @@ export async function authorizeBatch<HostRejection>(
 	if (finalClaimTaskId && !finalOwnClaim)
 		return { outcome: "rejected", rejection: batchRejection("claim_appeared_during_confirmation", finalClaimTaskId) };
 
-	// Confirmation cannot adopt a changed record or extend its displayed window
-	// after the user answers. Re-read the clock and branch after the async checks.
+	// Confirmation cannot adopt a changed record after the user answers. Re-read
+	// the record and branch after the async checks.
 	if (isResuming) {
 		const current = findExistingActiveBatch(root, initiativeSlug);
 		if (!current || current.corrupt || JSON.stringify(current.record) !== JSON.stringify(existingBatch))
@@ -787,8 +878,6 @@ export async function authorizeBatch<HostRejection>(
 	const branchAfter = spawnSync("git", ["-C", root, "branch", "--show-current"], { encoding: "utf8" });
 	if (branchAfter.status !== 0 || branchAfter.stdout !== branchBefore.stdout)
 		return { outcome: "rejected", rejection: batchRejection("confirmation_failed", "Git branch moved after native confirmation") };
-	if (Date.parse(expiresAt) <= Date.now())
-		return { outcome: "rejected", rejection: batchRejection("confirmation_failed", "confirmed batch deadline expired before authorization issuance") };
 
 	if (projection.reconfirmation) {
 		try { projection.reconfirmation.assertUnchanged(); }
@@ -803,16 +892,14 @@ export async function authorizeBatch<HostRejection>(
 		budget,
 		actor_id: LITERAL_USER_ACTOR_ID,
 		confirmation_ref: options.confirmationRef({ batch_id: batchId, request_id: requestId }),
-		expires_at: expiresAt,
 		nonce: options.nonce,
 	};
-	if (projection.reconfirmation) retainReconfirmation(binding.nonce, binding.expires_at, projection.reconfirmation);
+	if (projection.reconfirmation) retainReconfirmation(binding.nonce, projection.reconfirmation);
 	return {
 		outcome: "authorized",
 		batch_id: batchId,
 		reuse_authorization: reuseAuthorization,
 		reuse_blockers: reuseBlockers,
-		expires_at: expiresAt,
 		binding,
 	};
 }

package/plugins/immune-brain/runtime/unattended/batch_reasons.ts

@@ -24,7 +24,6 @@ export type BatchReasonKey =
 	| "empty_enrollable_set"
 	| "plan_projection_failed"
 	| "confirmation_port_unavailable"
-	| "confirmation_timed_out"
 	| "confirmation_cancelled"
 	| "confirmation_declined"
 	| "confirmation_no_decision"
@@ -115,11 +114,6 @@ export const BATCH_REASONS: Readonly<Record<BatchReasonKey, BatchReasonSpec>> =
 		reason: "native confirmation port is unavailable",
 		recovery_action: "retry through a fresh native gate in the current Host",
 	},
-	confirmation_timed_out: {
-		state: "rejected",
-		reason: "native confirmation timed out waiting for user interaction",
-		recovery_action: "retry through a fresh native gate in the current Host",
-	},
 	confirmation_cancelled: {
 		state: "cancelled",
 		reason: "native interaction cancelled",

package/plugins/immune-brain/runtime/unattended/batch_reconfirmation.ts

@@ -3,9 +3,9 @@ import { spawnSync } from "node:child_process";
 import { computeBatchPlanDigest, type BatchPlanChild as DigestChild } from "../kernel/batch_authority";
 import { canonicalIntentHash, parseTaskIntentV1, readTaskIntent } from "../kernel/intent";
 import { projectAssurance } from "../kernel/assurance_projection";
-import { localRunId, readAuditTaskPair, readSecureProjectBytes, readWorkspaceStateRaw } from "../kernel/storage";
-import { readRunRowByTask, withKernelRead } from "../kernel/sqlite_store";
-import { taskRevisionIdentity, taskCommitRevisionIdentity, pathMatchesScope } from "../workspace_scope";
+import { readAuditTaskPair, readSecureProjectBytes, readSettledRunEvidence, enrollmentEventIdFor, readWorkspaceStateRaw, type SettledRunEvidence } from "../kernel/storage";
+import { auditRunDirPath, auditRunRecordPath, auditRunTerminalProofPath, batchCommitEvidencePath, batchStatePath } from "../kernel/storage_paths";
+import { taskDeliveryIdentity, taskCommitRevisionIdentity, pathMatchesScope } from "../workspace_scope";
 import { projectTask } from "../kernel/completion";
 import { isTerminalBatchState, type BatchRunStateRecord } from "./batch_state";
 import type { BatchPlanChild } from "./types";
@@ -31,7 +31,7 @@ export function ownUnpersistedBatchHead(root: string, record: BatchRunStateRecor
 			record.children[0]?.state !== "settled" || record.children.some(c => c.commit !== null)) return false;
 		const task = record.children[0].task_id;
 		if (!id.test(task)) return false;
-		const evidence = JSON.parse(decode(readSecureProjectBytes(root, `.imm/state/batches/commits/${record.batch_id}-${task}.json`)));
+		const evidence = JSON.parse(decode(readSecureProjectBytes(root, batchCommitEvidencePath(record.batch_id, task))));
 		if (evidence.contract !== "assurance_kernel/batch_commit_evidence/v1" || evidence.batch_id !== record.batch_id ||
 			evidence.task_id !== task || evidence.commit !== head || evidence.parent_head !== record.base_head) return false;
 		if (git(root, ["symbolic-ref", "--short", "HEAD"]).trim() !== record.branch) return false;
@@ -39,18 +39,19 @@ export function ownUnpersistedBatchHead(root: string, record: BatchRunStateRecor
 		if (parents.length !== 1 || parents[0] !== record.base_head) return false;
 		const metadata = git(root, ["show", "-s", "--format=%an%x00%s%x00%(trailers:key=Immune-Brain-Batch,valueonly)", head]).split("\0");
 		if (metadata[0] !== batchAuthor || !metadata[1]?.startsWith(`imm(${task}):`) || metadata[2]?.trim() !== record.batch_id) return false;
-		const run = localRunId(root, task);
-		if (!run || !id.test(run)) return false;
+		const settled = readSettledRunEvidence(root, task);
+		if (!settled || settled.lifecycle !== "done") return false;
+		const run = settled.run_id;
+		if (!id.test(run)) return false;
 		const pair = readAuditTaskPair(root, task, run);
 		if (!pair || pair.record.contract !== "assurance_kernel/task_record/v4" || pair.record.lifecycle !== "done" || pair.proof.terminal_lifecycle !== "done") return false;
-		const local = withKernelRead(root, db => readRunRowByTask(db, task));
-		if (!local || local.run_id !== run || local.state !== "done" || !matchesLocalProof(local.terminal_proof_json, pair.proof)) return false;
+		if (!matchesLocalProof(settled.proof_json, pair.proof)) return false;
 		for (const file of ["task-record.json", "terminal-proof.json"]) {
-			const path = `.imm/audit/${task}/${run}/${file}`;
+			const path = `${auditRunDirPath(task, run)}/${file}`;
 			if (!readSecureProjectBytes(root, path).equals(Buffer.from(git(root, ["show", `${head}:${path}`])))) return false;
 		}
 		const paths = git(root, ["diff-tree", "--no-commit-id", "--name-only", "--no-renames", "-z", "-r", head]).split("\0").filter(Boolean);
-		if (!paths.length || paths.some(path => !path.startsWith(`.imm/audit/${task}/${run}/`) &&
+		if (!paths.length || paths.some(path => !path.startsWith(`${auditRunDirPath(task, run)}/`) &&
 			!pair.record.intent_snapshot.scope_hint.some(s => pathMatchesScope(path, s)))) return false;
 		const identity = taskCommitRevisionIdentity(root, pair.record.intent_snapshot.scope_hint, pair.record.git_base_head, head);
 		if (!projectTask(pair.record.intent_snapshot, pair.record, identity.diff_hash, pair.record.intent_ref.content_hash, identity.changed_paths).complete) return false;
@@ -67,17 +68,16 @@ export interface ReconfirmationSnapshot {
 }
 
 // Ephemeral captured observations, not authority: the runner independently
-// validates the native capability. Entries expire and are discarded on application.
-const confirmations = new Map<string, { snapshot: ReconfirmationSnapshot; expires: number }>();
-export function retainReconfirmation(nonce: string, expires: string, snapshot: ReconfirmationSnapshot): void {
-	for (const [key, value] of confirmations) if (value.expires <= Date.now()) confirmations.delete(key);
+// validates the native capability. Entries are discarded on application.
+const confirmations = new Map<string, ReconfirmationSnapshot>();
+export function retainReconfirmation(nonce: string, snapshot: ReconfirmationSnapshot): void {
 	if (confirmations.has(nonce)) refuse();
-	confirmations.set(nonce, { snapshot, expires: Date.parse(expires) });
+	confirmations.set(nonce, snapshot);
 }
 export function takeReconfirmation(nonce: string): ReconfirmationSnapshot {
 	const found = confirmations.get(nonce); confirmations.delete(nonce);
-	if (!found || found.expires <= Date.now()) refuse();
-	return found.snapshot;
+	if (!found) refuse();
+	return found;
 }
 
 export async function captureBatchReconfirmation(root: string, record: BatchRunStateRecord, children: BatchPlanChild[]): Promise<ReconfirmationSnapshot> {
@@ -86,7 +86,7 @@ export async function captureBatchReconfirmation(root: string, record: BatchRunS
 	const assertNoCommitEvidence = () => {
 		for (const child of record.children) {
 			if (!id.test(child.task_id)) refuse();
-			const path = `.imm/state/batches/commits/${record.batch_id}-${child.task_id}.json`;
+			const path = batchCommitEvidencePath(record.batch_id, child.task_id);
 			let missing = false;
 			try { readSecureProjectBytes(root, path); }
 			catch (error) {
@@ -97,13 +97,13 @@ export async function captureBatchReconfirmation(root: string, record: BatchRunS
 		}
 	};
 	assertNoCommitEvidence();
-	const statePath = `.imm/state/batches/${record.batch_id}.json`;
+	const statePath = batchStatePath(record.batch_id);
 	const stateBytes = readSecureProjectBytes(root, statePath);
 	if (JSON.stringify(JSON.parse(decode(stateBytes))) !== JSON.stringify(record)) refuse();
 	const files = new Map<string, Buffer>();
 	const capture = (path: string) => { const bytes = readSecureProjectBytes(root, path); files.set(path, bytes); return bytes; };
 	const oldChildren: DigestChild[] = [];
-	const changed: Array<{ task: string; run: string; identity: string; local: string }> = [];
+	const changed: Array<{ task: string; run: string; identity: string; settled: string }> = [];
 	let scope: string[] | null = null;
 	const workspace = readWorkspaceStateRaw(root);
 	if (workspace.state.current_working !== null) refuse();
@@ -122,11 +122,11 @@ export async function captureBatchReconfirmation(root: string, record: BatchRunS
 		if (currentHash !== tracked.content_hash || currentHash !== child.intent_content_hash || current.revision !== child.intent_revision) refuse();
 		if (currentHash === oldHash) continue;
 		if (scope !== null || previous.state === "pending" || previous.state === "skipped_blocked" || current.revision <= old.revision || current.goal !== old.goal || current.owner !== old.owner) refuse();
-		const run = localRunId(root, child.task_id);
-		if (!run || !id.test(run)) refuse();
-		const local = withKernelRead(root, db => readRunRowByTask(db, child.task_id));
-		if (!local || local.run_id !== run || local.state !== "done" || local.enrollment_event_id !== `enroll-${child.task_id}-${local.created_at}` ||
-			Date.parse(local.created_at) > Date.parse(record.updated_at)) refuse();
+		const settled = readSettledRunEvidence(root, child.task_id);
+		if (!settled || settled.lifecycle !== "done") refuse();
+		const run = settled.run_id;
+		if (!id.test(run) || settled.enrollment_event_id !== enrollmentEventIdFor(child.task_id, settled.created_at) ||
+			Date.parse(settled.created_at) > Date.parse(record.updated_at)) refuse();
 		const pair = readAuditTaskPair(root, child.task_id, run);
 		if (!pair || pair.record.contract !== "assurance_kernel/task_record/v4") refuse();
 		const r = pair.record;
@@ -134,22 +134,22 @@ export async function captureBatchReconfirmation(root: string, record: BatchRunS
 			r.git_base_head !== record.base_head || pair.proof.terminal_lifecycle !== "done") refuse();
 		const terminal = r.history.at(-1);
 		if (terminal?.type !== "complete" || terminal.from_state !== "active:frozen" || terminal.to_state !== "done:frozen" || terminal.id !== pair.proof.terminal_event_id) refuse();
-		const recordPath = `.imm/audit/${child.task_id}/${run}/task-record.json`;
-		const proofPath = `.imm/audit/${child.task_id}/${run}/terminal-proof.json`;
-		if (!capture(recordPath).equals(Buffer.from(local.record_json))) refuse();
+		const recordPath = auditRunRecordPath(child.task_id, run);
+		const proofPath = auditRunTerminalProofPath(child.task_id, run);
+		if (!capture(recordPath).equals(Buffer.from(settled.record_json))) refuse();
 		const capturedProof = JSON.parse(decode(capture(proofPath)));
-		if (!matchesLocalProof(local.terminal_proof_json, capturedProof) || !matchesLocalProof(local.terminal_proof_json, pair.proof)) refuse();
-		const identity = taskRevisionIdentity(root, r.intent_snapshot.scope_hint, r.git_base_head, r.task_id);
+		if (!matchesLocalProof(settled.proof_json, capturedProof) || !matchesLocalProof(settled.proof_json, pair.proof)) refuse();
+		const identity = taskDeliveryIdentity(root, r);
 		const projection = await projectAssurance(root, child.task_id, (cwd, task) => {
 			if (task.contract !== "assurance_kernel/task_record/v4" || !task.git_base_head) refuse();
-			return taskRevisionIdentity(cwd, task.intent_snapshot.scope_hint, task.git_base_head, task.task_id);
+			return taskDeliveryIdentity(cwd, task);
 		});
 		if (projection.error || projection.claim || projection.projection.run_id !== run || projection.projection.lifecycle !== "done" ||
 			!projection.projection.completion_ready || projection.projection.intent_content_hash !== currentHash || projection.projection.diff_hash !== identity.diff_hash ||
 			!projection.projection.fresh_approval_kinds.includes("qa") ||
 			(projection.projection.risk !== "routine" && !projection.projection.fresh_approval_kinds.includes("review"))) refuse();
 		scope = r.intent_snapshot.scope_hint;
-		changed.push({ task: child.task_id, run, identity: JSON.stringify(identity), local: JSON.stringify(local) });
+		changed.push({ task: child.task_id, run, identity: JSON.stringify(identity), settled: JSON.stringify(settled) });
 	}
 	if (computeBatchPlanDigest(oldChildren) !== record.plan_digest || changed.length !== 1 || scope === null) refuse();
 	const confirmedScope = scope;
@@ -162,7 +162,7 @@ export async function captureBatchReconfirmation(root: string, record: BatchRunS
 	for (const entry of entries) {
 		const code = entry.slice(0, 2), path = entry.slice(3);
 		if (code[1] !== " " || !["A", "M", "D"].includes(code[0]!) ||
-			(!path.startsWith(`.imm/audit/${owner.task}/${owner.run}/`) &&
+			(!path.startsWith(`${auditRunDirPath(owner.task, owner.run)}/`) &&
 			!confirmedScope.some(s => pathMatchesScope(path, s)))) refuse();
 	}
 	const flagsBytes = git(root, ["ls-files", "-v"]);
@@ -173,11 +173,15 @@ export async function captureBatchReconfirmation(root: string, record: BatchRunS
 	if (head() !== record.base_head || branch() !== record.branch) refuse();
 	const assertDeliveryUnchanged = () => {
 		for (const c of changed) {
+			let settled: SettledRunEvidence | null;
+			try {
+				settled = readSettledRunEvidence(root, c.task);
+			} catch { refuse(); }
+			if (!settled || settled.run_id !== c.run || JSON.stringify(settled) !== c.settled) refuse();
 			const pair = readAuditTaskPair(root, c.task, c.run);
 			if (!pair || pair.record.contract !== "assurance_kernel/task_record/v4" || !pair.record.git_base_head) refuse();
-			const local = withKernelRead(root, db => readRunRowByTask(db, c.task));
-			const diff = taskRevisionIdentity(root, pair.record.intent_snapshot.scope_hint, pair.record.git_base_head, c.task);
-			if (localRunId(root, c.task) !== c.run || JSON.stringify(local) !== c.local || JSON.stringify(diff) !== c.identity) refuse();
+			const diff = taskDeliveryIdentity(root, pair.record);
+			if (JSON.stringify(diff) !== c.identity) refuse();
 		}
 	};
 	const assertUnchanged = () => {