immune-brain 4.6.0 → 5.1.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,12 +30,12 @@ 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 { deriveAuthorizationOperation } from "../authorization_operation";
 import { LITERAL_USER_ACTOR_ID, canonicalActorId } from "../kernel/actor_identity";
@@ -56,21 +49,17 @@ 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 type { LaneOffer } from "../unattended/batch_lanes";
 import {
 	createBatchAuthorityRegistry,
-	deriveChildEnrollment,
-	type BatchAuthorityRegistry,
-	type BatchAuthorizationBinding,
 } from "../kernel/batch_authority";
 import {
 	type BatchRunnerGitPort,
@@ -78,7 +67,7 @@ import {
 import type {
 	InitiativeObservationReader,
 } from "../unattended/types";
-import { observeGithubInitiative } from "../github_issue_tracker";
+import { observeInitiative } from "../unattended/batch_plan";
 import {
 	confirmationRef,
 	enrollmentNonce,
@@ -96,11 +85,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 +129,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 +154,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 +200,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: {
@@ -413,6 +269,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;
@@ -469,7 +327,8 @@ export class ClaudeRuntime {
 			...this.createKernelPorts(),
 			...options.ports,
 			host: this.host,
-		});
+			confirmationReference: ({ actorId }) => `claude:${actorId}`,
+		}, options.authorityOverrides);
 	}
 
 	observe(event: ClaudeHookEvent): void {
@@ -502,14 +361,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),
 		};
 	}
@@ -588,21 +445,7 @@ export class ClaudeRuntime {
 				confirmation_ref: gate.confirmation_ref,
 				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;
@@ -766,7 +609,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",
 				);
@@ -800,7 +643,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");
 				}
@@ -823,7 +666,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();
 				}
@@ -885,7 +728,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();
 				}
@@ -899,94 +742,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"
@@ -1019,7 +774,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);
 			}
@@ -1030,7 +785,7 @@ export class ClaudeRuntime {
 	async startUnattendedBatch(
 		initiativeSlug: string,
 		meta: ToolMeta,
-		options: { reuseOnly?: boolean } = {},
+		options: { reuseOnly?: boolean; max_parallel?: number; lane_offers?: LaneOffer[] } = {},
 	): Promise<ClaudeBatchStartResult> {
 		throwIfCancelled(meta.signal);
 		const reuseOnly = options.reuseOnly === true;
@@ -1053,7 +808,7 @@ export class ClaudeRuntime {
 			root: this.cwd,
 			initiative_slug: initiativeSlug,
 			now,
-			readInitiative: this.readInitiative ?? observeGithubInitiative,
+			readInitiative: this.readInitiative ?? observeInitiative,
 		});
 		if (!preflight.ok) {
 			return {
@@ -1076,7 +831,7 @@ export class ClaudeRuntime {
 			initiative_slug: initiativeSlug,
 			now,
 			projection: preflight.projection,
-			readInitiative: this.readInitiative ?? observeGithubInitiative,
+			readInitiative: this.readInitiative ?? observeInitiative,
 			nonce: enrollmentNonce(),
 			gate: async (facts) => {
 				// A continuation after a foreground child never opens a gate: when the
@@ -1113,6 +868,15 @@ export class ClaudeRuntime {
 								reason: child.reason,
 							})),
 							budget: facts.budget,
+							...(options.max_parallel !== undefined
+								? {
+										lane_mode: {
+											max_parallel: options.max_parallel,
+											parallel_groups: facts.parallel_groups,
+											serialized: facts.scope_conflicts,
+										},
+									}
+								: {}),
 							...(facts.reuse_blockers.length > 0
 								? {
 										re_confirmation_required: facts.reuse_blockers,
@@ -1179,17 +943,30 @@ export class ClaudeRuntime {
 		now = new Date().toISOString();
 		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,
@@ -1204,6 +981,8 @@ export class ClaudeRuntime {
 			now,
 			kernel: kernelPort,
 			git: this.batchGit,
+			...(options.max_parallel !== undefined ? { max_parallel: options.max_parallel } : {}),
+			...(options.lane_offers !== undefined ? { lane_offers: options.lane_offers } : {}),
 		});
 
 		// review-3 & review-batch-preflight-recovery-is-diagnostic: map rejected batch state to rejected result with same-Host recovery action
@@ -1215,80 +994,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 {