immune-brain 4.5.0 → 5.0.0

package/plugins/immune-brain/runtime/claude/kernel_ports.ts

@@ -1,30 +1,23 @@
-import { randomUUID } from "node:crypto";
+import { stagePlanningArtifactTransition, type VerdictAuthority } from "../assurance/verdict_authority";
+export { ensureReviewRevision as ensureClaudeReviewRevision } from "../assurance/verdict_authority";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { join } from "node:path";
 import {
 	AssuranceCoordinator,
-	reviewAdvisoryRecords,
-	reviewReworkFindings,
 	type AssuranceCoordinatorPorts,
 	type AssuranceSubmitReviewResult,
-	type AssuranceVerdict,
 	type HostContext,
-	type SnapshotDescriptor,
 } from "../assurance/coordinator";
 import {
-	type VerificationDescriptor,
 } from "../assurance/verification";
 import {
-	captureReviewManifest,
 	writeNativeReviewEvidence,
-	type ReviewRevision,
 } from "../assurance/review_evidence";
-import { parseVerificationDescriptor } from "../verification_descriptor";
 import { projectAssurance, type AssuranceProjection, type AssuranceProjectionResult } from "../kernel/assurance_projection";
-import { type TaskApprovalV2, type TaskFinding, type TaskRecord } from "../kernel/types";
+import { type TaskFinding, type TaskRecord } from "../kernel/types";
 import { findingsDigestV2 } from "../kernel/reducer";
-import { readTaskRecord, readTaskRecordRaw, recoverKernelStoreFollowUps } from "../kernel/storage";
+import { readTaskRecordRaw, recoverKernelStoreFollowUps } from "../kernel/storage";
 import { canonicalIntentHash, parseTaskIntentV1, readTaskIntent } from "../kernel/intent";
 import { capabilityActionFor, createCanaryApplication } from "../kernel/canary_application";
 import {
@@ -37,14 +30,13 @@ import {
 	createEnrollmentAuthorityRegistry,
 	type EnrollmentCapabilityBinding,
 } from "../kernel/enrollment_authority";
-import { enrollCanaryTask, runEnrollmentRehearsal } from "../kernel/enrollment";
+import { enrollTask } from "../kernel/enrollment";
 import { reconcileKernelAuthority, repairKernelAuthority } from "../kernel/storage";
 import { inspectEnrollmentGitBase, enrollmentGitBaseNotice, initializeEnrollmentGitBase } from "../assurance/enrollment_git_base";
 import { preparePiCanary, revalidatePiCanary } from "../kernel/pi_canary_prepare";
 import { runDeterministicQa } from "../assurance/qa";
-import { taskDiffIdentity, taskRevisionIdentity } from "../workspace_scope";
+import { taskDeliveryIdentity } from "../workspace_scope";
 import { batchReason } from "../unattended/batch_reasons";
-import { startConfirmationDeadline } from "../unattended/confirmation_deadline";
 import { deriveAuthorizationOperation } from "../authorization_operation";
 import { LITERAL_USER_ACTOR_ID, canonicalActorId } from "../kernel/actor_identity";
 import {
@@ -57,20 +49,16 @@ import { readTaskTombstone } from "../kernel/backend_claim";
 import {
 	authorizeBatch,
 	projectBatchPreflight,
-	readActiveClaimTaskId,
-	isOwnBatchClaim,
+	findResumableBatchSlugForTask,
 } from "../unattended/batch_preflight";
 import {
 	startBatch,
-	batchQaFailureFacts,
 	type BatchRunnerKernelPort,
 	type BatchRunReport,
 } from "../unattended/batch_runner";
+import { createBatchKernelPort } from "../unattended/batch_kernel_port";
 import {
 	createBatchAuthorityRegistry,
-	deriveChildEnrollment,
-	type BatchAuthorityRegistry,
-	type BatchAuthorizationBinding,
 } from "../kernel/batch_authority";
 import {
 	type BatchRunnerGitPort,
@@ -96,11 +84,7 @@ export function diffSnapshotOf(root: string, record: TaskRecord): {
 	diff_hash: string;
 	changed_paths: readonly string[];
 } {
-	if (record.contract === "assurance_kernel/task_record/v4") {
-		if (!record.git_base_head) throw new Error("TaskRecord v4 is missing git_base_head");
-		return taskRevisionIdentity(root, record.intent_snapshot.scope_hint, record.git_base_head, record.task_id);
-	}
-	return taskDiffIdentity(root, record.intent_snapshot.scope_hint, record.task_id);
+	return taskDeliveryIdentity(root, record);
 }
 
 export function diffHashOf(root: string, record: TaskRecord): string {
@@ -144,6 +128,21 @@ function verdictFingerprint(raw: Record<string, unknown>): string {
 	});
 }
 
+const RELEASED_REVIEW_RECOVERY =
+	"Call advance_assurance to obtain a new Review reservation, then dispatch one fresh reviewer with the returned envelope unchanged";
+const RETAINED_REVIEW_RECOVERY =
+	"Wait for the dispatched reviewer to finish, then call submit_review again with its verdict; do not dispatch or continue another reviewer";
+const MISMATCH_REVIEW_RECOVERY =
+	"Resubmit the reviewer's verdict exactly as the reviewer returned it";
+
+function withReviewRecovery(
+	result: AssuranceSubmitReviewResult,
+	recovery_action: string,
+): AssuranceSubmitReviewResult {
+	if (result.state !== "blocked" || result.code === "verdict_invalid") return result;
+	return { ...result, recovery_action };
+}
+
 export async function submitClaudeReview(
 	host: ClaudeReviewHost,
 	coordinator: AssuranceCoordinator,
@@ -154,19 +153,19 @@ export async function submitClaudeReview(
 	if (verdictInput === undefined) throw new Error("verdict is required");
 	const observed = host.inspectReviewForTask(taskId);
 	if (!observed.ok) {
-		if (observed.release) return coordinator.abandonReview(taskId, observed.reason);
-		return { state: "blocked", reason: observed.reason };
+		if (observed.release) return withReviewRecovery(coordinator.abandonReview(taskId, observed.reason), RELEASED_REVIEW_RECOVERY);
+		return { state: "blocked", reason: observed.reason, recovery_action: RETAINED_REVIEW_RECOVERY };
 	}
 	const parentValid = coordinator.isReviewVerdictValid(taskId, verdictInput);
 	if (!parentValid) return coordinator.submitReview(taskId, ctx, verdictInput);
 	const receiptValid = coordinator.isReviewVerdictValid(taskId, observed.receipt.result);
 	if (!receiptValid) {
-		return coordinator.abandonReview(taskId, "reviewer receipt is not a valid verdict");
+		return withReviewRecovery(coordinator.abandonReview(taskId, "reviewer receipt is not a valid verdict"), RELEASED_REVIEW_RECOVERY);
 	}
 	const parentJson = extractVerdictJson(verdictInput)!;
 	const receiptJson = extractVerdictJson(observed.receipt.result)!;
 	if (verdictFingerprint(parentJson) !== verdictFingerprint(receiptJson)) {
-		return { state: "blocked", reason: "parent verdict does not match reviewer receipt" };
+		return { state: "blocked", reason: "parent verdict does not match reviewer receipt", recovery_action: MISMATCH_REVIEW_RECOVERY };
 	}
 	return coordinator.submitReview(taskId, ctx, verdictInput);
 }
@@ -200,150 +199,6 @@ function assertProjectionBinding(before: AssuranceProjectionResult, after: Assur
 	}
 }
 
-function qaOutcomes(record: { attestations: Array<{ kind: string; acceptance_results: Array<{ acceptance_id: string; status: "passed" | "failed" | "blocked"; summary: string }> }> }) {
-	return Object.fromEntries(
-		record.attestations.filter((item) => item.kind === "qa").flatMap((item) => item.acceptance_results)
-			.map((result) => [result.acceptance_id, { status: result.status, summary: result.summary }]),
-	);
-}
-
-/**
- * Publish the task-scoped synthetic revision for a v4 record and return the
- * exact identity the Review snapshot binds.
- *
- * `submitReview` re-derives this identity and compares all four fields —
- * `manifest_digest` included — against the reservation. Returning the bare
- * commit identity therefore compared a real digest against `undefined` and
- * failed every v4 submission with "Review revision changed before submission",
- * so the manifest is recomputed here rather than only the commit. The outcomes
- * come from the same `qaOutcomes` the Review snapshot is built from, which
- * makes the two digests equal by construction instead of by coincidence.
- *
- * v3 records keep the legacy full-source bundle and return null.
- */
-export async function ensureClaudeReviewRevision(
-	root: string,
-	taskId: string,
-	projection: AssuranceProjectionResult,
-): Promise<ReviewRevision | null> {
-	const current = await readTaskRecord(root, taskId);
-	const record = current.record;
-	if (!record) throw new Error(`task ${taskId} has no TaskRecord`);
-	if (current.revision !== projection.projection.record_revision)
-		throw new Error("TaskRecord changed before Review revision preparation");
-	if (record.contract !== "assurance_kernel/task_record/v4") return null;
-	if (!record.git_base_head)
-		throw new Error("Review revision requires a TaskRecord v4 git_base_head");
-	const manifest = captureReviewManifest(root, {
-		taskId,
-		baseHead: record.git_base_head,
-		scopeHint: record.intent_snapshot.scope_hint,
-		expectedDiffHash: projection.projection.diff_hash,
-		intentRevision: projection.projection.intent_revision,
-		intentContentHash: projection.projection.intent_content_hash,
-		recordRevision: projection.projection.record_revision,
-		workspaceRevision: projection.projection.workspace_revision,
-		lifecycle: projection.projection.lifecycle,
-		artifactState: projection.projection.artifact_state,
-		risk: record.intent_snapshot.risk,
-		outcomes: qaOutcomes(record),
-	});
-	return {
-		contract: "assurance_kernel/review_revision/v1",
-		base_head: manifest.base_head,
-		review_tree: manifest.review_tree,
-		review_commit: manifest.review_commit,
-		review_ref: manifest.review_ref,
-		diff_hash: manifest.diff_hash,
-		manifest_digest: manifest.manifest_digest,
-	};
-}
-
-async function buildAssuranceSnapshot(
-	root: string,
-	taskId: string,
-	role: "qa" | "review",
-	projection: AssuranceProjectionResult,
-) {
-	const read = await readTaskRecord(root, taskId);
-	const record = read.record;
-	if (!record || read.revision !== projection.projection.record_revision) throw new Error("TaskRecord changed before assurance snapshot capture");
-	const intent = record.intent_snapshot;
-	const descriptors = new Map<string, VerificationDescriptor>();
-	for (const item of role === "qa" ? intent.acceptance : []) {
-		const descriptor = parseVerificationDescriptor(item.verification);
-		descriptors.set(item.id, descriptor);
-	}
-	const reviewBundle = null;
-	const reviewManifest = role === "review"
-		? captureReviewManifest(root, {
-			taskId,
-			baseHead: record.git_base_head,
-			scopeHint: intent.scope_hint,
-			expectedDiffHash: projection.projection.diff_hash,
-			intentRevision: projection.projection.intent_revision,
-			intentContentHash: projection.projection.intent_content_hash,
-			recordRevision: projection.projection.record_revision,
-			workspaceRevision: projection.projection.workspace_revision,
-			lifecycle: projection.projection.lifecycle,
-			artifactState: projection.projection.artifact_state,
-			risk: intent.risk,
-			outcomes: qaOutcomes(record),
-		})
-		: null;
-	const dirtyFiles = reviewManifest ? Object.keys(reviewManifest.changed_paths) : [];
-	const snapshot: SnapshotDescriptor = {
-		contract: "assurance_kernel/assurance_snapshot/v2",
-		task_id: taskId,
-		run_id: projection.projection.run_id,
-		role,
-		record_revision: projection.projection.record_revision,
-		workspace_revision: projection.projection.workspace_revision,
-		intent_revision: projection.projection.intent_revision,
-		intent_content_hash: projection.projection.intent_content_hash,
-		diff_hash: projection.projection.diff_hash,
-		lifecycle: projection.projection.lifecycle,
-		artifact_state: projection.projection.artifact_state,
-		risk: intent.risk,
-		fresh_acceptance_ids: projection.projection.fresh_acceptance_ids,
-		missing_acceptance_ids: projection.projection.missing_acceptance_ids,
-		stale_attestation_ids: projection.projection.stale_attestation_ids,
-		acceptance: intent.acceptance,
-		dirty_files: dirtyFiles,
-		review_bundle_digest: reviewManifest?.manifest_digest ?? null,
-		root,
-		...(reviewManifest
-			? {
-				review_revision: {
-					contract: "assurance_kernel/review_revision_identity/v1",
-					base_head: reviewManifest.base_head,
-					review_commit: reviewManifest.review_commit,
-					review_tree: reviewManifest.review_tree,
-					manifest_digest: reviewManifest.manifest_digest,
-				},
-			}
-			: {}),
-	};
-	return { snapshot, descriptors, reviewBundle, reviewManifest };
-}
-
-function stagePlanningArtifactTransition(root: string, record: { intent_ref: { path: string }; intent_snapshot: { scope_hint: string[] } }): void {
-	const intentActive = record.intent_ref.path.replace("docs/plans/archive/", "docs/plans/");
-	const intentArchive = intentActive.replace("docs/plans/", "docs/plans/archive/");
-	const specActive = record.intent_snapshot.scope_hint.find((path) =>
-		/^docs\/specs\/(?!archive\/)[^/]+\.spec\.md$/.test(path)
-		&& record.intent_snapshot.scope_hint.includes(path.replace("docs/specs/", "docs/specs/archive/")),
-	);
-	const candidates = [
-		intentActive,
-		intentArchive,
-		...(specActive ? [specActive, specActive.replace("docs/specs/", "docs/specs/archive/")] : []),
-	];
-	const paths = candidates.filter((path) => existsSync(join(root, path)) || execFileSync("git", ["ls-files", "--cached", "--", path], { cwd: root, encoding: "utf8" }).trim().length > 0);
-	if (paths.length === 0) return;
-	execFileSync("git", ["add", "--", ...paths], { cwd: root, stdio: ["ignore", "pipe", "pipe"] });
-}
-
 async function mintCapability(
 	registry: MutationAuthorityRegistry,
 	input: {
@@ -391,7 +246,6 @@ async function mintCapability(
 		diff_hash: input.diff_hash,
 		actor_id: input.actor_id,
 		confirmation_ref: input.confirmation_ref,
-		expires_at: new Date(Date.now() + 10 * 60 * 1000).toISOString(),
 		findings_digest: input.action_kind === "request_rework"
 			? findingsDigestV2(input.findings as TaskFinding[])
 			: null,
@@ -414,6 +268,8 @@ export interface ClaudeRuntimeOptions {
 	 * actually wires was never constructed once.
 	 */
 	ports?: Partial<AssuranceCoordinatorPorts>;
+	/** Optional authority test seam, separate from host ports. */
+	authorityOverrides?: Partial<VerdictAuthority>;
 	interactive?: boolean;
 	permissionMode?: PermissionMode;
 	requestConfirmation?: NativeConfirmationPort;
@@ -470,7 +326,8 @@ export class ClaudeRuntime {
 			...this.createKernelPorts(),
 			...options.ports,
 			host: this.host,
-		});
+			confirmationReference: ({ actorId }) => `claude:${actorId}`,
+		}, options.authorityOverrides);
 	}
 
 	observe(event: ClaudeHookEvent): void {
@@ -503,14 +360,12 @@ export class ClaudeRuntime {
 	private createKernelPorts(): AssuranceCoordinatorPorts {
 		return {
 			host: this.host,
+			confirmationReference: ({ actorId }) => `claude:${actorId}`,
 			projectTask: (root, taskId) => projectAssurance(root, taskId, diffSnapshotOf),
-			readTaskRecord: async (root, taskId) => readTaskRecord(root, taskId),
+			readTaskRecord: async (root, taskId) => readTaskRecordRaw(root, taskId),
 			readTaskIntent: async (root, taskId) => readTaskIntentForRecord(root, taskId),
-			buildAssurance: (root, taskId, role, projection) => buildAssuranceSnapshot(root, taskId, role, projection),
-			ensureReviewRevision: (root, taskId, projection) => ensureClaudeReviewRevision(root, taskId, projection),
 			runQa: (snapshot, descriptors, options) => runDeterministicQa(snapshot, descriptors, options),
 			writeReviewEvidence: (input) => writeNativeReviewEvidence(input.evidence),
-			applyVerdict: (ctx, input) => this.applyVerdict(ctx, input),
 			applyOrdinaryOperation: (ctx, input) => this.executeOrdinary(ctx, input),
 		};
 	}
@@ -587,44 +442,74 @@ export class ClaudeRuntime {
 				preparation_digest: preparation.digest,
 				actor_id: LITERAL_USER_ACTOR_ID,
 				confirmation_ref: gate.confirmation_ref,
-				expires_at: new Date(Date.now() + 10 * 60 * 1000).toISOString(),
 				nonce,
 			};
-			const capability = this.enrollmentRegistry.issue(binding);
-			const input = {
-				task_id: taskId,
-				intent_path: binding.intent_path,
-				intent_revision: binding.intent_revision,
-				preparation_digest: binding.preparation_digest,
-				capability,
-				capability_binding: binding,
-				now,
-			};
-			const rehearsal = runEnrollmentRehearsal(this.cwd, input, capability, this.enrollmentRegistry);
-			if (!rehearsal.rehearsed || rehearsal.evidence.outcome !== "ready") {
-				throw new Error(`Kernel enrollment rehearsal failed: ${rehearsal.evidence.blockers.join("; ")}`);
-			}
-			return enrollCanaryTask(this.cwd, input, this.enrollmentRegistry);
+			return await enrollTask(this.cwd, this.enrollmentRegistry, { binding, now });
 		} catch (error) {
 			if (gitBaseNote) throw new Error(`${error instanceof Error ? error.message : String(error)}${gitBaseNote}`);
 			throw error;
 		}
 	}
 
-	async advance(taskId: string, signal?: AbortSignal) {
-		return this.withTerminalTracker(
+	async advance(taskId: string, signal?: AbortSignal, meta?: ToolMeta) {
+		return this.closeOutBatchChild(
 			taskId,
-			await this.coordinator.advance(taskId, { cwd: this.cwd }, signal),
+			await this.withTerminalTracker(taskId, await this.coordinator.advance(taskId, { cwd: this.cwd }, signal)),
+			meta,
 		);
 	}
 
-	async submitReview(taskId: string, verdictInput: unknown) {
-		return this.withTerminalTracker(
+	async submitReview(taskId: string, verdictInput: unknown, meta?: ToolMeta) {
+		return this.closeOutBatchChild(
 			taskId,
-			await submitClaudeReview(this.host, this.coordinator, { cwd: this.cwd }, taskId, verdictInput),
+			await this.withTerminalTracker(
+				taskId,
+				await submitClaudeReview(this.host, this.coordinator, { cwd: this.cwd }, taskId, verdictInput),
+			),
+			meta,
 		);
 	}
 
+	/**
+	 * Gate-free closeout: a batch child that reached Kernel `done` in the
+	 * foreground re-enters the batch in the same call, reusing its authorization.
+	 * Only `done` continues; a stopped child, a parked child and a live Review
+	 * obligation end where they do today. The continuation is transport: the
+	 * Kernel result is returned unchanged, and any failure is reported beside it
+	 * with one retry action, never thrown into a path that could read as "the
+	 * mutation did not happen".
+	 */
+	private async closeOutBatchChild<T>(taskId: string, result: T, meta?: ToolMeta): Promise<T> {
+		if (!meta || result === null || typeof result !== "object") return result;
+		const lifecycle = (result as { record?: { lifecycle?: unknown } }).record?.lifecycle;
+		if ((result as { state?: unknown }).state !== "completed" && lifecycle !== "done") return result;
+		let slug: string | null;
+		try {
+			slug = findResumableBatchSlugForTask(this.cwd, taskId);
+		} catch {
+			return result;
+		}
+		if (!slug) return result;
+		try {
+			// The batch commit takes exactly the scope envelope plus this task's own
+			// audit evidence, and its preflight refuses unstaged changes: stage only
+			// that evidence, the step an Executor otherwise does by hand.
+			if (existsSync(join(this.cwd, ".imm", "audit", taskId)))
+				execFileSync("git", ["-C", this.cwd, "add", "--", `.imm/audit/${taskId}`], { stdio: "ignore" });
+			const batch = await this.startUnattendedBatch(slug, meta, { reuseOnly: true });
+			return { ...(result as object), batch } as T;
+		} catch (error) {
+			return {
+				...(result as object),
+				batch: {
+					state: "rejected",
+					reason: `batch continuation failed: ${error instanceof Error ? error.message : String(error)}`,
+					recovery_action: "call start_unattended_batch with the same Initiative to continue the batch",
+				},
+			} as T;
+		}
+	}
+
 	/**
 	 * Post-settlement GitHub tracker projection: the same shared step the Pi Host
 	 * runs, so an opted-in terminal projection no longer depends on which Host
@@ -723,7 +608,7 @@ export class ClaudeRuntime {
 			const derived = deriveAuthorizationOperation({ readiness: projection.projection.authorization });
 			if ("blocked" in derived) throw new Error(derived.blocked);
 			if (derived.operation === "resolve-user-decision") {
-				const record = await readTaskRecord(this.cwd, taskId);
+				const record = await readTaskRecordRaw(this.cwd, taskId);
 				const open = (record.record?.findings ?? []).filter(
 					(finding) => finding.kind === "unresolved_user_decision" && finding.status === "open",
 				);
@@ -757,7 +642,7 @@ export class ClaudeRuntime {
 			if (sidecar && nextIntent) {
 				writeFileSync(sidecar, `${JSON.stringify(nextIntent, null, 2)}\n`);
 				execFileSync("git", ["add", "--", priorIntent.intent_ref.path], { cwd: this.cwd, stdio: ["ignore", "pipe", "pipe"] });
-				const preparedRecord = await readTaskRecord(this.cwd, taskId);
+				const preparedRecord = await readTaskRecordRaw(this.cwd, taskId);
 				if (!preparedRecord.record) {
 					throw new NativeAuthorityError("workspace_changed", "TaskRecord changed before the breaking revision digest");
 				}
@@ -780,7 +665,7 @@ export class ClaudeRuntime {
 			});
 		} catch (error) {
 			if (stagedSnapshot) {
-				const current = await readTaskRecord(this.cwd, taskId);
+				const current = await readTaskRecordRaw(this.cwd, taskId);
 				if (current.record?.intent_snapshot.revision === priorIntent.intent.revision) {
 					restoreStagedIntent();
 				}
@@ -842,7 +727,7 @@ export class ClaudeRuntime {
 			) stagePlanningArtifactTransition(this.cwd, result.record);
 		} catch (error) {
 			if (stagedSnapshot) {
-				const current = await readTaskRecord(this.cwd, taskId);
+				const current = await readTaskRecordRaw(this.cwd, taskId);
 				if (current.record?.intent_snapshot.revision === priorIntent.intent.revision) {
 					restoreStagedIntent();
 				}
@@ -856,94 +741,6 @@ export class ClaudeRuntime {
 		return this.withTerminalTracker(taskId, committed);
 	}
 
-	private async applyVerdict(
-		ctx: HostContext,
-		input: {
-			taskId: string;
-			snapshot: SnapshotDescriptor;
-			verdict: AssuranceVerdict;
-			invocation: { /* token */ };
-			actorId: string;
-			hooks?: { beforeCommit?: () => Promise<void>; onCommit?: () => void; afterCommit?: () => Promise<void> };
-		},
-	): Promise<void> {
-		const { registry, app } = await this.authority();
-		const priorIntentToken = (await readTaskIntentForRecord(ctx.cwd, input.taskId)).token;
-		const now = new Date().toISOString();
-		const commitAndApply = async <T>(apply: () => Promise<T>): Promise<T> => {
-			this.coordinator.commitInvocation(input.invocation as never);
-			const settlement = apply();
-			input.hooks?.onCommit?.();
-			const result = await settlement;
-			await input.hooks?.afterCommit?.();
-			return result;
-		};
-		if (input.verdict.decision === "rework") {
-			const findings = reviewReworkFindings(input.verdict);
-			const capability = await mintCapability(registry, {
-				authority_kind: input.snapshot.role,
-				task_id: input.taskId,
-				run_id: input.snapshot.run_id,
-				action_kind: "request_rework",
-				expected_record_hash: input.snapshot.record_revision,
-				intent_revision: input.snapshot.intent_revision,
-				intent_content_hash: input.snapshot.intent_content_hash,
-				diff_hash: input.snapshot.diff_hash,
-				actor_id: input.actorId,
-				findings,
-				now,
-				confirmation_ref: `claude:${input.actorId}`,
-			});
-			await input.hooks?.beforeCommit?.();
-			const result = await commitAndApply(async () => app.execute({
-				root: ctx.cwd,
-				task_id: input.taskId,
-				operation: { op: "request_rework", capability, findings: findings as never[], actor_id: input.actorId },
-				prior_intent_token: priorIntentToken,
-				diffProvider: diffSnapshotOf,
-				now,
-			}));
-			stagePlanningArtifactTransition(ctx.cwd, result.record);
-			return;
-		}
-		const advisories = input.verdict.decision === "pass" ? reviewAdvisoryRecords(input.verdict) : [];
-		const approval: TaskApprovalV2 = {
-			id: `approval-${input.snapshot.role}-${randomUUID().slice(0, 8)}`,
-			kind: input.snapshot.role === "qa" ? "qa" : "review",
-			authority_role: input.snapshot.role === "qa" ? "qa" : "reviewer",
-			task_revision: input.snapshot.intent_revision,
-			intent_content_hash: input.snapshot.intent_content_hash,
-			diff_hash: input.snapshot.diff_hash,
-			actor_id: input.actorId,
-			summary: input.verdict.approval!.summary,
-			...(input.snapshot.role === "review" && input.snapshot.review_revision ? { review_revision: input.snapshot.review_revision } : {}),
-			...(input.snapshot.role === "review" && advisories.length > 0 ? { advisory_findings: advisories } : {}),
-		};
-		const capability = await mintCapability(registry, {
-			authority_kind: input.snapshot.role,
-			task_id: input.taskId,
-			run_id: input.snapshot.run_id,
-			action_kind: "record_approval",
-			expected_record_hash: input.snapshot.record_revision,
-			intent_revision: input.snapshot.intent_revision,
-			intent_content_hash: input.snapshot.intent_content_hash,
-			diff_hash: input.snapshot.diff_hash,
-			actor_id: input.actorId,
-			approval,
-			now,
-			confirmation_ref: `claude:${input.actorId}`,
-		});
-		await input.hooks?.beforeCommit?.();
-		await commitAndApply(async () => app.execute({
-			root: ctx.cwd,
-			task_id: input.taskId,
-			operation: { op: "record_approval", capability, approval, actor_id: input.actorId },
-			prior_intent_token: priorIntentToken,
-			diffProvider: diffSnapshotOf,
-			now,
-		}));
-	}
-
 	private async executeOrdinary(ctx: HostContext, input: { taskId: string; operation: { op: string; actor_id: string; next_intent?: unknown; finding_id?: string; attestation_id?: string } }) {
 		const { app } = await this.authority();
 		const operation = input.operation.op === "revise_intent"
@@ -976,7 +773,7 @@ export class ClaudeRuntime {
 			return result;
 		} catch (error) {
 			if (priorStaged) {
-				const current = await readTaskRecord(ctx.cwd, input.taskId);
+				const current = await readTaskRecordRaw(ctx.cwd, input.taskId);
 				if (current.record?.intent_snapshot.revision === priorIntent.intent.revision)
 					restoreStagedIntentShared(ctx.cwd, priorStaged);
 			}
@@ -987,15 +784,18 @@ export class ClaudeRuntime {
 	async startUnattendedBatch(
 		initiativeSlug: string,
 		meta: ToolMeta,
+		options: { reuseOnly?: boolean } = {},
 	): Promise<ClaudeBatchStartResult> {
 		throwIfCancelled(meta.signal);
+		const reuseOnly = options.reuseOnly === true;
 		const probe = probeHost(this.env, process.platform, this.hostVersion);
 		if (!probe.ok) throw new NativeAuthorityError("unsupported_host", probe.reason);
+		// A reuse-only continuation never opens a gate, so it needs no confirmation port.
 		const interactive = meta.interactive ?? this.interactive;
-		if (!interactive) throw new NativeAuthorityError("unsupported_host", "interactive MCP elicitation is unavailable");
+		if (!reuseOnly && !interactive) throw new NativeAuthorityError("unsupported_host", "interactive MCP elicitation is unavailable");
 		// The text is table-owned; only the form (a thrown native error rather than
 		// a returned envelope) is this Host's.
-		if (!this.requestConfirmation)
+		if (!reuseOnly && !this.requestConfirmation)
 			throw new NativeAuthorityError("interaction_not_opened", batchReason("confirmation_port_unavailable").reason);
 
 		// 1. Host-independent batch preflight: claim ownership, branch
@@ -1022,7 +822,7 @@ export class ClaudeRuntime {
 		const budget = preflight.projection.budget;
 		const planDigest = preflight.projection.plan_digest;
 		const recoveryChildren = preflight.projection.recovery_children;
-		// 5. Literal-user gate plus the shared reuse/expiry decision, the post-gate
+		// 5. Literal-user gate plus the shared reuse decision, the post-gate
 		// claim/drift cascade, and the Batch Authorization binding. The Host supplies
 		// only its gate, its confirmation reference, and its binding nonce.
 		const authorization = await authorizeBatch<ClaudeBatchStartResult>({
@@ -1033,9 +833,19 @@ export class ClaudeRuntime {
 			readInitiative: this.readInitiative ?? observeGithubInitiative,
 			nonce: enrollmentNonce(),
 			gate: async (facts) => {
-				// review-4: the bounded elicitation deadline is shared behavior now, so
-				// both Hosts bound an unanswered confirmation by the same setting.
-				const deadline = startConfirmationDeadline({ env: this.env, signal: meta.signal });
+				// A continuation after a foreground child never opens a gate: when the
+				// authorization cannot be reused, the user re-enters the batch tool.
+				if (reuseOnly)
+					return {
+						kind: "host_rejection",
+						value: {
+							state: "blocked",
+							reason: `batch authorization cannot be reused (${facts.reuse_blockers.join(", ")})`,
+							recovery_action: "call start_unattended_batch with the same Initiative to confirm a fresh authorization",
+						},
+					};
+				// The gate settles only on the literal user's answer or the caller's
+				// cancellation signal.
 				let confirmationResult: { decision: NativeDecision; requestId: string };
 				try {
 					confirmationResult = await this.requestConfirmation!({
@@ -1057,7 +867,6 @@ export class ClaudeRuntime {
 								reason: child.reason,
 							})),
 							budget: facts.budget,
-							expires_at: facts.expires_at,
 							...(facts.reuse_blockers.length > 0
 								? {
 										re_confirmation_required: facts.reuse_blockers,
@@ -1065,10 +874,9 @@ export class ClaudeRuntime {
 									}
 								: {}),
 						},
-						signal: deadline.signal,
+						signal: meta.signal,
 					});
 				} catch (err) {
-					if (deadline.timedOut()) return { kind: "host_rejection", value: batchReason("confirmation_timed_out") };
 					if (meta.signal?.aborted)
 						return { kind: "host_rejection", value: batchReason("cancelled_before_execution") };
 					if (err instanceof NativeAuthorityError) {
@@ -1088,13 +896,8 @@ export class ClaudeRuntime {
 						kind: "host_rejection",
 						value: batchReason("confirmation_failed", err instanceof Error ? err.message : String(err)),
 					};
-				} finally {
-					deadline.clear();
 				}
 
-				// A transport that answers "cancel" on abort is still a timeout, not a user
-				// decision: the Host that owns the transport reports which one it was.
-				if (deadline.timedOut()) return { kind: "host_rejection", value: batchReason("confirmation_timed_out") };
 				if (confirmationResult.decision === "cancel" && meta.signal?.aborted)
 					return { kind: "host_rejection", value: batchReason("confirmation_cancelled") };
 				if (meta.signal?.aborted)
@@ -1122,27 +925,38 @@ export class ClaudeRuntime {
 		});
 		if (authorization.outcome === "host_rejection") return authorization.value;
 		if (authorization.outcome === "rejected") return authorization.rejection;
-		const { binding, batch_id: batchId, expires_at: expiresAt } = authorization;
+		const { binding, batch_id: batchId } = authorization;
 
 		// review-1: verify cancellation signal right before authority issuance and startBatch
 		if (meta.signal?.aborted) return batchReason("cancelled_before_execution");
 
 		now = new Date().toISOString();
-		if (Date.parse(expiresAt) <= Date.parse(now))
-			return batchReason("confirmation_failed", "confirmed batch deadline expired before authorization issuance");
 		const capability = this.batchRegistry.issue(binding, recoveryChildren as any, now);
 
-		const basePort = this.createBatchKernelPort(this.batchRegistry, capability, binding);
-		const kernelPort: BatchRunnerKernelPort = {
-			...basePort,
-			ownsTaskClaim: (taskId) => {
-				if (isResuming && taskId === readActiveClaimTaskId(this.cwd)) {
-					// Re-verify the CURRENT claim identity synchronously.
-					return isOwnBatchClaim(this.cwd, existingBatch!, taskId, batchBranch);
-				}
-				return basePort.ownsTaskClaim(taskId);
-			},
+		// review-batch-partial-port-fabricates-enrollment: the production child
+		// Kernel port is the shared runtime/unattended one; this Host supplies
+		// only its own advanceTask progression seam (D5).
+		const advanceTask: BatchRunnerKernelPort["advanceTask"] = async (root, taskId) => {
+			const result = await this.coordinator.advance(taskId, { cwd: root });
+			const facts = { diagnostics: result.diagnostics, environment_failure: result.environment_failure, recovery: result.recovery };
+			if (result.state === "completed") return { state: "completed", ...facts };
+			if (result.state === "stopped") return { state: "stopped", ...facts };
+			if (result.state === "rework") return { state: "rework", operation: result.operation, summary: result.summary, ...facts };
+			if (result.state === "review_ready") return { state: "review_ready", operation_id: result.operation_id, ...facts };
+			if (result.state === "review_preparation_failed") return { state: result.state, operation: result.operation, operation_id: result.operation_id, reason: result.reason, ...facts };
+			if (result.state === "blocked") return { state: "blocked", reason: result.reason, ...facts };
+			return { state: "failed", reason: (result as { reason?: string }).reason ?? "advance failed", ...facts };
 		};
+		const kernelPort = createBatchKernelPort({
+			root: this.cwd,
+			enrollmentRegistry: this.enrollmentRegistry,
+			registry: this.batchRegistry,
+			capability,
+			binding,
+			advanceTask,
+			resume: { isResuming, existingBatch, batchBranch },
+			overrides: this.batchKernel,
+		});
 		const report = await startBatch({
 			root: this.cwd,
 			batch_id: batchId,
@@ -1153,7 +967,6 @@ export class ClaudeRuntime {
 			plan_digest: planDigest,
 			base_head: binding.base_head,
 			confirmation_time: now,
-			authorization_expires_at: expiresAt,
 			budget,
 			now,
 			kernel: kernelPort,
@@ -1169,80 +982,6 @@ export class ClaudeRuntime {
 			report,
 		};
 	}
-
-	private createBatchKernelPort(
-		registry: BatchAuthorityRegistry,
-		capability: object,
-		binding: BatchAuthorizationBinding,
-	): BatchRunnerKernelPort {
-		// review-batch-partial-port-fabricates-enrollment: construct real production port first, never fabricate stubs
-		const realPort: BatchRunnerKernelPort = {
-			enrollTask: async ({ root, task_id, batch }) => {
-				const now = new Date().toISOString();
-				const derived = deriveChildEnrollment(root, batch.registry, {
-					capability: batch.capability,
-					binding,
-					task_id,
-					expected_head: batch.binding.expected_head,
-					now,
-				});
-				const enrollmentCapability = this.enrollmentRegistry.issue(derived.binding);
-				const input = {
-					task_id,
-					intent_path: derived.binding.intent_path,
-					intent_revision: derived.binding.intent_revision,
-					preparation_digest: derived.binding.preparation_digest,
-					capability: enrollmentCapability,
-					capability_binding: derived.binding,
-					batch: {
-						registry: batch.registry,
-						capability: batch.capability,
-						binding,
-						expected_head: batch.binding.expected_head,
-					},
-					now,
-				};
-				const rehearsal = runEnrollmentRehearsal(root, input, enrollmentCapability, this.enrollmentRegistry);
-				if (!rehearsal.rehearsed || rehearsal.evidence.outcome !== "ready") {
-					throw new Error(`Kernel enrollment rehearsal failed: ${rehearsal.evidence.blockers.join("; ")}`);
-				}
-				// The enrollment itself is the effect; its record is re-read below.
-				enrollCanaryTask(root, input, this.enrollmentRegistry);
-				const recordRaw = readTaskRecordRaw(root, task_id);
-				return { record_revision: recordRaw.revision };
-			},
-			advanceTask: async (root, taskId) => {
-				const result = await this.coordinator.advance(taskId, { cwd: root });
-				const facts = { diagnostics: result.diagnostics, environment_failure: result.environment_failure, recovery: result.recovery };
-				if (result.state === "completed") return { state: "completed", ...facts };
-				if (result.state === "stopped") return { state: "stopped", ...facts };
-				if (result.state === "rework") return { state: "rework", operation: result.operation, summary: result.summary, ...facts };
-				if (result.state === "review_ready") return { state: "review_ready", operation_id: result.operation_id, ...facts };
-				if (result.state === "review_preparation_failed") return { state: result.state, operation: result.operation, operation_id: result.operation_id, reason: result.reason, ...facts };
-				if (result.state === "blocked") return { state: "blocked", reason: result.reason, ...facts };
-				return { state: "failed", reason: (result as { reason?: string }).reason ?? "advance failed", ...facts };
-			},
-			projectTask: async (root, taskId) => {
-				const fresh = await projectAssurance(root, taskId, diffSnapshotOf);
-				if (!fresh.claim || fresh.projection.lifecycle !== "active" || fresh.error !== null) return fresh;
-				const { record, revision } = readTaskRecordRaw(root, taskId);
-				if (!record || revision !== fresh.projection.record_revision) throw new Error(`Kernel recovery projection changed for ${taskId}`);
-				return { ...fresh, ...batchQaFailureFacts(record) };
-			},
-			ownsTaskClaim: (taskId) => {
-				return registry.isChildConsumed(capability, taskId);
-			},
-			validateBatchAuthorization: (input) => {
-				return input.registry.inspect(input.capability, input.binding as never);
-			},
-		};
-
-		if (!this.batchKernel) return realPort;
-		return {
-			...realPort,
-			...this.batchKernel,
-		};
-	}
 }
 
 export interface ToolMeta {