immune-brain 5.3.0 → 5.5.1

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

@@ -1,5 +1,6 @@
 import { stagePlanningArtifactTransition, type VerdictAuthority } from "../assurance/verdict_authority";
 export { ensureReviewRevision as ensureClaudeReviewRevision } from "../assurance/verdict_authority";
+import { parseDeliveryConsolidation, type DeliveryConsolidation } from "../unattended/parent_delivery_consolidation";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { join } from "node:path";
@@ -14,11 +15,23 @@ import {
 import {
 	writeNativeReviewEvidence,
 } from "../assurance/review_evidence";
-import { projectAssurance, type AssuranceProjection, type AssuranceProjectionResult } from "../kernel/assurance_projection";
+import {
+	projectAssurance,
+	type AssuranceProjection,
+	type AssuranceProjectionResult,
+	type ReworkChoice,
+	type ReworkExitsReadiness,
+} from "../kernel/assurance_projection";
 import { type TaskFinding, type TaskRecord } from "../kernel/types";
 import { findingsDigestV2 } from "../kernel/reducer";
 import { readTaskRecordRaw, recoverKernelStoreFollowUps } from "../kernel/storage";
-import { canonicalIntentHash, parseTaskIntentV1, readTaskIntent } from "../kernel/intent";
+import {
+	assertScopeAdditionsAreFiles,
+	canonicalIntentHash,
+	parseProjectTaskIntent,
+	readTaskIntent,
+	withNextScope,
+} from "../kernel/intent";
 import { capabilityActionFor, createCanaryApplication } from "../kernel/canary_application";
 import {
 	createMutationAuthorityRegistry,
@@ -30,9 +43,9 @@ import {
 	createEnrollmentAuthorityRegistry,
 	type EnrollmentCapabilityBinding,
 } from "../kernel/enrollment_authority";
-import { enrollTask } from "../kernel/enrollment";
+import { enrollmentScopeDisclosure, enrollTask } from "../kernel/enrollment";
 import { reconcileKernelAuthority, repairKernelAuthority } from "../kernel/storage";
-import { inspectEnrollmentGitBase, enrollmentGitBaseNotice, initializeEnrollmentGitBase } from "../assurance/enrollment_git_base";
+import { commitEnrollmentPreconditions, commitUnbornEnrollmentPreconditions, inspectEnrollmentGitBase, enrollmentGitBaseNotice, initializeEnrollmentGitBase, preconditionCommitNote } from "../assurance/enrollment_git_base";
 import { preparePiCanary, revalidatePiCanary } from "../kernel/pi_canary_prepare";
 import { runDeterministicQa } from "../assurance/qa";
 import { taskDeliveryIdentity } from "../workspace_scope";
@@ -43,16 +56,16 @@ import {
 	captureStagedIntent,
 	restoreStagedIntent as restoreStagedIntentShared,
 } from "../staged_intent";
-import { projectTerminalTrackerState, TRACKER_PROJECTION_FAILURE } from "../assurance/coordinator";
-import { runGithubTrackerOperation } from "../github_issue_tracker";
+import { projectTaskStatus, projectTerminalTrackerState, TRACKER_PROJECTION_FAILURE } from "../assurance/coordinator";
+import { runGithubTrackerOperation, assertIsolatedTaskPrerequisites } from "../github_issue_tracker";
 import { readTaskTombstone } from "../kernel/backend_claim";
 import {
 	authorizeBatch,
-	projectBatchPreflight,
+	prepareBatchPreflight,
 	findResumableBatchSlugForTask,
 } from "../unattended/batch_preflight";
 import {
-	startBatch,
+	startBatch, completedParentReport,
 	type BatchRunnerKernelPort,
 	type BatchRunReport,
 	type BatchTrackerPort,
@@ -71,6 +84,7 @@ import {
 import type {
 	InitiativeObservationReader,
 } from "../unattended/types";
+import { integrateSettledCriticalSlices, advanceNativeParent } from "../unattended/batch_git";
 import { observeInitiative } from "../unattended/batch_plan";
 import {
 	confirmationRef,
@@ -82,6 +96,7 @@ import {
 	type NativeDecision,
 	type PrivilegedOperation,
 } from "./interaction";
+import { selectedClaudeParent } from "./run_continuation";
 import { ClaudeReviewHost, FileHookEventLog, type ClaudeHookEvent } from "./review_host";
 import { probeHost, type PermissionMode } from "./capability";
 
@@ -96,6 +111,14 @@ export function diffHashOf(root: string, record: TaskRecord): string {
 	return diffSnapshotOf(root, record).diff_hash;
 }
 
+/**
+ * A revision is prepared, checked and bound against the scope it asks for, so
+ * the delivery identity of that operation reads the next scope (ADR 0021, D6).
+ */
+function nextScopeDiffProvider(nextScope: readonly string[]): typeof diffSnapshotOf {
+	return (root, record) => diffSnapshotOf(root, withNextScope(record, nextScope));
+}
+
 /**
  * Read the TaskIntent through the TaskRecord's `intent_ref.path`.
  *
@@ -107,8 +130,8 @@ export function diffHashOf(root: string, record: TaskRecord): string {
 function readTaskIntentForRecord(root: string, taskId: string) {
 	// Converge committed follow-ups first, then follow the record.
 	recoverKernelStoreFollowUps(root, taskId);
-	const currentPath = readTaskRecordRaw(root, taskId).record?.intent_ref?.path;
-	return readTaskIntent(root, taskId, currentPath);
+	const record = readTaskRecordRaw(root, taskId).record;
+	return readTaskIntent(root, taskId, record?.intent_ref.path, record?.intent_snapshot);
 }
 
 import {
@@ -174,6 +197,7 @@ async function mintCapability(
 		next_intent?: unknown;
 		next_intent_ref?: unknown;
 		reason?: string;
+		rounds?: number;
 		finding_id?: string;
 		resolution?: string;
 		now: string;
@@ -186,6 +210,7 @@ async function mintCapability(
 		at: input.now,
 		actor_id: input.actor_id,
 		...(input.reason !== undefined ? { reason: input.reason } : {}),
+		...(input.rounds !== undefined ? { rounds: input.rounds } : {}),
 		...(input.findings !== undefined ? { findings: input.findings } : {}),
 		...(input.approval !== undefined ? { approval: input.approval } : {}),
 		...(input.next_intent !== undefined ? { next_intent: input.next_intent } : {}),
@@ -242,6 +267,7 @@ export interface ClaudeRuntimeOptions {
  * authorization flow passes them through untouched.
  */
 type ClaudeBatchStartResult =
+	| NonNullable<Awaited<ReturnType<typeof advanceNativeParent>>>
 	| { state: "started"; batch_id: string; report: BatchRunReport }
 	| { state: "retired"; batch_id: string; report: BatchRunReport | BatchLaneRunReport }
 	| { state: "rejected"; reason: string; recovery_action: string }
@@ -344,7 +370,8 @@ export class ClaudeRuntime {
 		intentContentHash?: string;
 		bindingDigest?: string;
 		gitBaseNotice?: string;
-	} = {}): Promise<{ confirmation_ref: string }> {
+		reworkExits?: ReworkExitsReadiness;
+	} = {}): Promise<{ confirmation_ref: string; reworkChoice?: ReworkChoice }> {
 		throwIfCancelled(meta.signal);
 		const probe = probeHost(this.env, process.platform, this.hostVersion);
 		if (!probe.ok) throw new NativeAuthorityError("unsupported_host", probe.reason);
@@ -359,6 +386,7 @@ export class ClaudeRuntime {
 		throwIfCancelled(meta.signal);
 		const gate = evaluateNativeGate({ operation, interactive, decision: result.decision });
 		if (!gate.ok) throw gate.error;
+		const { reworkExits: _exits, ...refBinding } = binding;
 		return {
 			confirmation_ref: confirmationRef({
 				connectionId: meta.sessionId,
@@ -366,34 +394,55 @@ export class ClaudeRuntime {
 				requestId: result.requestId,
 				operation,
 				taskId: meta.taskId,
-				...binding,
+				...refBinding,
 			}),
+			...(result.reworkChoice ? { reworkChoice: result.reworkChoice } : {}),
 		};
 	}
 
-	async status(taskId: string) {
-		return projectAssurance(this.cwd, taskId, diffSnapshotOf);
+	/** The status Tool: readable with unstaged in-scope paths, which come back as a warning. */
+	async status(taskId: string, nextScope?: readonly string[]) {
+		return nextScope ? this.project(taskId, nextScope) : projectTaskStatus(this.cwd, taskId);
+	}
+
+	/** The refusing projection every mutation and authorization is bound to. */
+	private async project(taskId: string, nextScope?: readonly string[]) {
+		return projectAssurance(this.cwd, taskId, nextScope ? nextScopeDiffProvider(nextScope) : diffSnapshotOf);
 	}
 
 	async enroll(taskId: string, meta: ToolMeta) {
 		const now = new Date().toISOString();
-		let preparation = await preparePiCanary(this.cwd, { task_id: taskId, now });
-		const intent = await readTaskIntentForRecord(this.cwd, taskId);
-		const gitBase = inspectEnrollmentGitBase(this.cwd);
-		const gate = await this.gate("enroll", { ...meta, taskId }, {
-			risk: intent.intent.risk,
-			intentRevision: preparation.intent?.revision,
-			intentContentHash: preparation.intent?.content_hash,
-			bindingDigest: preparation.digest,
-			gitBaseNotice: enrollmentGitBaseNotice(gitBase),
-		});
-		const { unchanged } = await revalidatePiCanary(this.cwd, { task_id: taskId, now }, preparation);
-		if (!unchanged) throw new NativeAuthorityError("workspace_changed", "workspace changed after native confirmation");
-		if (!preparation.intent) throw new Error("enrollment requires a readable TaskIntent");
-		throwIfCancelled(meta.signal);
-		preparation = initializeEnrollmentGitBase(this.cwd, { task_id: taskId, now }, preparation, gitBase, meta.signal);
-		const gitBaseNote = gitBase.state === "unborn" ? `; empty initial commit ${preparation.git_base_head} remains` : "";
+		// Commit the task's own dirty preconditions first, so the confirmation
+		// below binds the HEAD that results. An owned workspace commits nothing.
+		let gitBaseNote = preconditionCommitNote(commitEnrollmentPreconditions(this.cwd, taskId, meta.signal));
 		try {
+			await assertIsolatedTaskPrerequisites(this.cwd, taskId);
+			let preparation = await preparePiCanary(this.cwd, { task_id: taskId, now });
+			const intent = await readTaskIntentForRecord(this.cwd, taskId);
+			const gitBase = inspectEnrollmentGitBase(this.cwd);
+			// In-scope changes that already exist are shown in the gate and only the
+			// ones shown are claimed as task work on confirmation.
+			const disclosure = enrollmentScopeDisclosure(this.cwd, taskId);
+			const gate = await this.gate("enroll", { ...meta, taskId }, {
+				risk: intent.intent.risk,
+				intentRevision: preparation.intent?.revision,
+				intentContentHash: preparation.intent?.content_hash,
+				bindingDigest: preparation.digest,
+				gitBaseNotice: [enrollmentGitBaseNotice(gitBase), disclosure.notice].filter(Boolean).join("\n") || undefined,
+			});
+			const { unchanged } = await revalidatePiCanary(this.cwd, { task_id: taskId, now }, preparation);
+			if (!unchanged) throw new NativeAuthorityError("workspace_changed", "workspace changed after native confirmation");
+			if (!preparation.intent) throw new Error("enrollment requires a readable TaskIntent");
+			throwIfCancelled(meta.signal);
+			preparation = initializeEnrollmentGitBase(this.cwd, { task_id: taskId, now }, preparation, gitBase, meta.signal);
+			if (gitBase.state === "unborn") {
+				gitBaseNote += `; empty initial commit ${preparation.git_base_head} remains`;
+				// The scope could not be compared with an unborn HEAD; commit it
+				// now that a base exists and bind the HEAD that results.
+				const late = commitUnbornEnrollmentPreconditions(this.cwd, { task_id: taskId, now }, preparation, meta.signal);
+				gitBaseNote += preconditionCommitNote(late.result);
+				preparation = late.preparation;
+			}
 			if (!preparation.intent) throw new Error("Enrollment requires a readable TaskIntent");
 			const nonce = enrollmentNonce();
 			const binding: EnrollmentCapabilityBinding = {
@@ -406,10 +455,15 @@ export class ClaudeRuntime {
 				confirmation_ref: gate.confirmation_ref,
 				nonce,
 			};
-			return await enrollTask(this.cwd, this.enrollmentRegistry, { binding, now });
+			return await enrollTask(this.cwd, this.enrollmentRegistry, { binding, now, disclosed_scope_paths: disclosure.paths });
 		} catch (error) {
-			if (gitBaseNote) throw new Error(`${error instanceof Error ? error.message : String(error)}${gitBaseNote}`);
-			throw error;
+			if (!gitBaseNote) throw error;
+			// A native-gate error keeps its type and code; only the text grows.
+			if (error instanceof NativeAuthorityError) {
+				error.message += gitBaseNote;
+				throw error;
+			}
+			throw new Error(`${error instanceof Error ? error.message : String(error)}${gitBaseNote}`);
 		}
 	}
 
@@ -453,13 +507,14 @@ export class ClaudeRuntime {
 		}
 		if (!slug) return result;
 		try {
+			if (!selectedClaudeParent(meta.toolCallId, this.cwd, slug)) return result;
 			// 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;
+			return { ...(result as object), batch, ...(batch.state === "started" && batch.report?.tracker ? { tracker: batch.report.tracker } : {}) } as T;
 		} catch (error) {
 			return {
 				...(result as object),
@@ -489,6 +544,8 @@ export class ClaudeRuntime {
 		if (result === null || typeof result !== "object") return result;
 		if (!settledKernelResult(result)) return result;
 		try {
+			// An observation after the commit, not an authority binding: it reads
+			// through the same status the Tool returns.
 			const projection = await this.status(taskId);
 			const tracker = await projectTerminalTrackerState({
 				root: this.cwd,
@@ -558,9 +615,16 @@ export class ClaudeRuntime {
 			return repairKernelAuthority(this.cwd, taskId, authority.revision);
 		}
 		if (!isPrivilegedOperation(operation) && operation !== "request_authorization") throw new Error(`unsupported privileged operation ${operation}`);
-		let op: PrivilegedOperation | "request_authorization" | "resolve_user_decision" | "authorize_rework" = operation;
+		let op: PrivilegedOperation | "request_authorization" | "resolve_user_decision" | "authorize_rework" | "accept_residual_risk" = operation;
 		let decisionOp: { finding_id: string; resolution: string } | undefined;
-		const projection = await this.status(taskId);
+		// Set only at a replan boundary: the exits the literal user chooses between.
+		let reworkExits: ReworkExitsReadiness | undefined;
+		let reworkChoice: ReworkChoice | undefined;
+		const nextIntent = extra.next_intent ? parseProjectTaskIntent(this.cwd, extra.next_intent) : undefined;
+		// The whole operation is judged against the scope it asks for (D6).
+		const nextScope = nextIntent?.scope_hint;
+		const diffProvider = nextScope ? nextScopeDiffProvider(nextScope) : diffSnapshotOf;
+		const projection = await this.project(taskId, nextScope);
 		if (projection.error || !projection.claim) throw new Error(projection.error ?? "no active backend claim");
 		// Kernel projection is the sole source of authorization readiness, and the
 		// derivation is the shared export both Hosts use, so it cannot drift:
@@ -579,12 +643,12 @@ export class ClaudeRuntime {
 				decisionOp = { finding_id: open[0].id, resolution: `resume after literal-user decision: ${open[0].summary}` };
 			} else {
 				op = "authorize_rework";
+				reworkExits = projection.projection.authorization.exits;
 			}
 		}
 		const priorIntent = await readTaskIntentForRecord(this.cwd, taskId);
 		const now = new Date().toISOString();
 		const actorId = LITERAL_USER_ACTOR_ID;
-		const nextIntent = extra.next_intent ? await parseTaskIntentV1(extra.next_intent) : undefined;
 		if (op === "approve_breaking_intent_revision" && !nextIntent) throw new Error("approve_breaking_intent_revision requires next_intent");
 		const nextIntentHash = nextIntent ? canonicalIntentHash(nextIntent) : undefined;
 		const nextIntentRef = nextIntent
@@ -599,7 +663,7 @@ export class ClaudeRuntime {
 			restoreStagedIntentShared(this.cwd, stagedSnapshot);
 		};
 		let preparedDiffHash = projection.projection.diff_hash;
-		let gate: { confirmation_ref: string };
+		let gate: { confirmation_ref: string; reworkChoice?: ReworkChoice };
 		try {
 			if (sidecar && nextIntent) {
 				writeFileSync(sidecar, `${JSON.stringify(nextIntent, null, 2)}\n`);
@@ -608,9 +672,9 @@ export class ClaudeRuntime {
 				if (!preparedRecord.record) {
 					throw new NativeAuthorityError("workspace_changed", "TaskRecord changed before the breaking revision digest");
 				}
-				preparedDiffHash = diffHashOf(this.cwd, preparedRecord.record);
+				preparedDiffHash = diffProvider(this.cwd, preparedRecord.record).diff_hash;
 			}
-			const preparedProjection = await this.status(taskId);
+			const preparedProjection = await this.project(taskId, nextScope);
 			try {
 				assertProjectionBinding(projection, preparedProjection, Boolean(nextIntent));
 				if (preparedProjection.projection.diff_hash !== preparedDiffHash) {
@@ -624,7 +688,9 @@ export class ClaudeRuntime {
 				intentRevision: nextIntent?.revision ?? projection.projection.intent_revision,
 				intentContentHash: nextIntentHash ?? projection.projection.intent_content_hash,
 				bindingDigest: `${preparedDiffHash}:${nextIntentHash ?? ""}`,
+				...(reworkExits ? { reworkExits } : {}),
 			});
+			reworkChoice = gate.reworkChoice;
 		} catch (error) {
 			if (stagedSnapshot) {
 				const current = await readTaskRecordRaw(this.cwd, taskId);
@@ -634,11 +700,24 @@ export class ClaudeRuntime {
 			}
 			throw error;
 		}
+		if (reworkExits) {
+			if (!reworkChoice) throw new NativeAuthorityError("interaction_not_opened", "native interaction returned no exit");
+			// A replan is not a mutation of this operation: the user chose to revise
+			// the Intent, which has its own gate. Nothing is written.
+			if (reworkChoice.exit === "replan") {
+				return {
+					state: "replan_selected",
+					task_id: taskId,
+					next: "revise the Intent, then call approve_breaking_intent_revision",
+				};
+			}
+			if (reworkChoice.exit === "accept_residual_risk") op = "accept_residual_risk";
+		}
 		const { registry, app } = this.authority();
 		const confirmation = gate.confirmation_ref;
 		let committed: ReturnType<typeof app.execute>;
 		try {
-			const capabilityProjection = await this.status(taskId);
+			const capabilityProjection = await this.project(taskId, nextScope);
 			try {
 				assertProjectionBinding(projection, capabilityProjection, Boolean(nextIntent));
 			} catch (error) {
@@ -664,6 +743,8 @@ export class ClaudeRuntime {
 				...(op === "approve_breaking_intent_revision" ? { next_intent: nextIntent, next_intent_ref: nextIntentRef } : {}),
 				...(op === "resolve_user_decision" && decisionOp ? decisionOp : {}),
 				...(op === "stop" ? { reason: stopReason(extra.reason) } : {}),
+				...(op === "authorize_rework" && reworkChoice?.exit === "grant_rounds" ? { rounds: reworkChoice.rounds } : {}),
+				...(op === "accept_residual_risk" && reworkChoice?.exit === "accept_residual_risk" ? { reason: reworkChoice.reason } : {}),
 			});
 			throwIfCancelled(meta.signal);
 			const result = app.execute({
@@ -676,15 +757,18 @@ export class ClaudeRuntime {
 					...(op === "approve_breaking_intent_revision" ? { next_intent: nextIntent, next_intent_ref: nextIntentRef } : {}),
 					...(op === "resolve_user_decision" && decisionOp ? decisionOp : {}),
 					...(op === "stop" ? { reason: stopReason(extra.reason) } : {}),
+					...(op === "authorize_rework" && reworkChoice?.exit === "grant_rounds" ? { rounds: reworkChoice.rounds } : {}),
+					...(op === "accept_residual_risk" && reworkChoice?.exit === "accept_residual_risk" ? { reason: reworkChoice.reason } : {}),
 				} as never,
 				prior_intent_token: priorIntent.token,
-				diffProvider: diffSnapshotOf,
+				diffProvider,
 				now,
 			});
 			committed = result;
 			if (
 				op === "stop" ||
 				op === "authorize_rework" ||
+				op === "accept_residual_risk" ||
 				op === "approve_breaking_intent_revision"
 			) stagePlanningArtifactTransition(this.cwd, result.record);
 		} catch (error) {
@@ -706,9 +790,13 @@ export class ClaudeRuntime {
 	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"
-			? { ...input.operation, next_intent: await parseTaskIntentV1(input.operation.next_intent) }
+			? { ...input.operation, next_intent: parseProjectTaskIntent(ctx.cwd, input.operation.next_intent) }
 			: input.operation;
 		const priorIntent = await readTaskIntentForRecord(ctx.cwd, input.taskId);
+		const nextScope = operation.op === "revise_intent"
+			? (operation.next_intent as { scope_hint: string[] }).scope_hint
+			: undefined;
+		if (nextScope) assertScopeAdditionsAreFiles(ctx.cwd, priorIntent.intent.scope_hint, nextScope);
 		const sidecar = join(ctx.cwd, priorIntent.intent_ref.path);
 		const priorBytes = operation.op === "revise_intent" ? readFileSync(sidecar) : null;
 		// A content-changing revision writes the sidecar before the kernel's drift
@@ -728,7 +816,7 @@ export class ClaudeRuntime {
 				task_id: input.taskId,
 				operation: operation as never,
 				prior_intent_token: priorIntent.token,
-				diffProvider: diffSnapshotOf,
+				diffProvider: nextScope ? nextScopeDiffProvider(nextScope) : diffSnapshotOf,
 				now: new Date().toISOString(),
 			});
 			if (operation.op === "freeze_artifacts" || operation.op === "stop") stagePlanningArtifactTransition(ctx.cwd, result.record);
@@ -746,10 +834,27 @@ export class ClaudeRuntime {
 	async startUnattendedBatch(
 		initiativeSlug: string,
 		meta: ToolMeta,
-		options: { reuseOnly?: boolean; max_parallel?: number; lane_offers?: LaneOffer[]; final_verification?: string[]; lane_instruction?: LaneInstructionRequest; lane_revision?: LaneRevisionRequest } = {},
+		options: { reuseOnly?: boolean; max_parallel?: number; lane_offers?: LaneOffer[]; final_verification?: string[]; delivery_consolidation?: DeliveryConsolidation; lane_instruction?: LaneInstructionRequest; lane_revision?: LaneRevisionRequest } = {},
+	): Promise<ClaudeBatchStartResult> {
+		let commit: string | undefined;
+		try {
+			const result = await this.startPreparedBatch(initiativeSlug, meta, options, (value) => { commit = value; });
+			if (commit && "reason" in result) result.reason += `; batch precondition commit ${commit} remains`;
+			return result;
+		} catch (error) {
+			if (commit && error instanceof Error) error.message += `; batch precondition commit ${commit} remains`;
+			throw error;
+		}
+	}
+
+	private async startPreparedBatch(
+		initiativeSlug: string, meta: ToolMeta,
+		options: { reuseOnly?: boolean; max_parallel?: number; lane_offers?: LaneOffer[]; final_verification?: string[]; delivery_consolidation?: DeliveryConsolidation; lane_instruction?: LaneInstructionRequest; lane_revision?: LaneRevisionRequest },
+		onCommit: (commit: string | undefined) => void,
 	): Promise<ClaudeBatchStartResult> {
 		throwIfCancelled(meta.signal);
 		const reuseOnly = options.reuseOnly === true;
+		const consolidation = parseDeliveryConsolidation(options.delivery_consolidation);
 		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.
@@ -760,17 +865,58 @@ export class ClaudeRuntime {
 		if (!reuseOnly && !this.requestConfirmation)
 			throw new NativeAuthorityError("interaction_not_opened", batchReason("confirmation_port_unavailable").reason);
 
+		await integrateSettledCriticalSlices(this.cwd, initiativeSlug, this.readInitiative);
+		const completed = await completedParentReport(this.cwd, initiativeSlug, this.readInitiative, this.batchTracker);
+		if (completed) return { state: "started", batch_id: completed.batch_id, report: completed };
+		const native = await advanceNativeParent(this.cwd, initiativeSlug, options.final_verification, this.readInitiative, this.batchTracker ?? createBatchTrackerPort(this.cwd, initiativeSlug),
+			async (effects) => {
+				// A continuation never opens a gate; unconfirmed commands wait for a fresh explicit entry.
+				if (reuseOnly) return batchReason("confirmation_port_unavailable");
+				try {
+					const confirmation = await this.requestConfirmation!({
+						operation: "start_unattended_batch",
+						initiativeSlug,
+						toolCallId: meta.toolCallId,
+						planDigest: effects.plan_digest,
+						batchDetails: {
+							initiative_slug: effects.initiative_slug,
+							batch_branch: "",
+							children: effects.children,
+							excluded: [],
+							final_verification: effects.final_commands,
+							parent_final_verification: { integrate_task_ids: effects.integrate_task_ids,
+							...(effects.delivery_consolidation ? { delivery_consolidation: effects.delivery_consolidation } : {}) },
+						},
+						signal: meta.signal,
+					});
+					if (meta.signal?.aborted) return batchReason("cancelled_before_execution");
+					if (confirmation.decision === "accept") return null;
+					if (confirmation.decision === "cancel") return batchReason("confirmation_cancelled");
+					if (confirmation.decision === "decline") return batchReason("confirmation_declined");
+					return batchReason("confirmation_no_decision");
+				} catch (err) {
+					if (meta.signal?.aborted) return batchReason("cancelled_before_execution");
+					if (err instanceof NativeAuthorityError) {
+						if (err.reasonCode === "unsupported_host") throw err;
+						return { state: err.reasonCode === "user_cancelled" ? "cancelled" : "rejected", reason: err.message, recovery_action: err.recoveryAction };
+					}
+					return batchReason("confirmation_failed", err instanceof Error ? err.message : String(err));
+				}
+			}, consolidation);
+		if (native) return native;
 		// 1. Host-independent batch preflight: claim ownership, branch
 		// availability, working-tree cleanliness against the authorized scope,
 		// recovery children, plan digest, and base HEAD are one shared projection,
 		// so neither Host re-implements a batch decision.
 		let now = new Date().toISOString();
-		const preflight = await projectBatchPreflight({
+		const preflight = await prepareBatchPreflight({
 			root: this.cwd,
 			initiative_slug: initiativeSlug,
 			now,
 			readInitiative: this.readInitiative ?? observeInitiative,
+			signal: meta.signal, reuseOnly,
 		});
+		onCommit(preflight.precondition_commit);
 		if (!preflight.ok) {
 			return {
 				state: preflight.state,
@@ -835,6 +981,7 @@ export class ClaudeRuntime {
 								reason: child.reason,
 							})),
 							budget: facts.budget,
+							...(options.final_verification ? { final_verification: options.final_verification } : {}),
 							...(options.max_parallel !== undefined
 								? {
 										lane_mode: {
@@ -932,6 +1079,7 @@ export class ClaudeRuntime {
 		};
 		const kernelPort = createBatchKernelPort({
 			root: this.cwd,
+			parent: await (this.readInitiative ?? observeInitiative)(this.cwd, initiativeSlug),
 			enrollmentRegistry: this.enrollmentRegistry,
 			registry: this.batchRegistry,
 			capability,
@@ -940,7 +1088,7 @@ export class ClaudeRuntime {
 			resume: { isResuming, existingBatch, batchBranch },
 			overrides: this.batchKernel,
 		});
-		const report = await startBatch({
+		let report = await startBatch({
 			root: this.cwd,
 			batch_id: batchId,
 			initiative_slug: initiativeSlug,
@@ -954,11 +1102,11 @@ export class ClaudeRuntime {
 			now,
 			kernel: kernelPort,
 			git: this.batchGit,
+			...(options.final_verification ? { final_verification: options.final_verification } : {}),
 			...(options.max_parallel !== undefined
 				? {
 						max_parallel: options.max_parallel,
 						tracker: this.batchTracker ?? createBatchTrackerPort(this.cwd, initiativeSlug),
-						...(options.final_verification ? { final_verification: options.final_verification } : {}),
 						...(options.lane_instruction ? { lane_instruction: options.lane_instruction } : {}),
 						...(options.lane_revision ? { lane_revision: options.lane_revision } : {}),
 						...(authorization.revision_delegation !== undefined ? { revision_delegation: authorization.revision_delegation } : {}),
@@ -970,6 +1118,8 @@ export class ClaudeRuntime {
 		// review-3 & review-batch-preflight-recovery-is-diagnostic: map rejected batch state to rejected result with same-Host recovery action
 		if (report.batch_state === "rejected") return batchReason("batch_run_rejected", report.reason ?? "");
 
+		if (report.batch_state === "completed" && report.final_verification?.passed)
+			report = await completedParentReport(this.cwd, initiativeSlug, this.readInitiative, this.batchTracker) ?? report;
 		return {
 			state: "started",
 			batch_id: batchId,
@@ -1013,6 +1163,7 @@ export class ClaudeRuntime {
 								state: child.state,
 								commit: child.commit,
 								lane_branch: child.lane_branch,
+								kernel_lifecycle: child.kernel_lifecycle,
 							})),
 						},
 						signal: meta.signal,

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

@@ -8,13 +8,13 @@
 // planning or execution; PreToolUse denies `enroll`, `start_unattended_batch`
 // and the `imm-run` Skill without a live run entry, and otherwise leaves an
 // admission the tool handler consumes by tool-use id. A model Skill call for
-// `imm-planner` or `imm-brainstorm` is never denied; with no active claim it
-// revokes the run entry.
+// `imm-planner` or `imm-brainstorm` is never denied and changes no entry state.
 import { lstatSync, rmSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { laneWriteRefusal } from "../unattended/lane_workspace";
 import { activeTaskNotice } from "../assurance/active_task_notice";
+import { releasesRunBinding } from "../assurance/run_continuation";
 import { readAliasFile } from "../assurance/alias_file";
 import {
 	admitPhaseOperation,
@@ -31,7 +31,6 @@ import {
 	type PhaseEntryState,
 	type PhaseOperation,
 } from "../assurance/phase_entry";
-import { readActiveClaimTaskId } from "../unattended/batch_preflight";
 import { appendPrivate, cacheDir, ensurePrivateDir, ownedByUs, readPrivate, sessionHash } from "./review_host";
 
 const FILE_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
@@ -95,7 +94,7 @@ function cwdOf(payload: Record<string, unknown>): string {
 }
 
 /** Project aliases first, then the user's, as Claude Code resolves commands. */
-function claudeAliasReader(cwd: string, home: string): AliasReader {
+export function claudeAliasReader(cwd: string, home: string): AliasReader {
 	return (name) => {
 		for (const dir of [join(cwd, ".claude", "commands"), join(home, ".claude", "commands")]) {
 			const body = readAliasFile(join(dir, `${name}.md`));
@@ -150,7 +149,8 @@ export function recordPhaseEntryPrompt(payload: Record<string, unknown>, locatio
 	const sessionId = sessionIdOf(payload);
 	if (!sessionId) return false;
 	const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
-	const entry = recognizePhaseEntry(prompt, claudeAliasReader(cwdOf(payload), locations.home ?? homedir()));
+	const recognized = recognizePhaseEntry(prompt, claudeAliasReader(cwdOf(payload), locations.home ?? homedir()));
+	const entry = releasesRunBinding(prompt, recognized === "plan" ? "planner" : null) ? "plan" : recognized;
 	return appendPhaseEntry(sessionId, entry, locations.root ?? tmpdir(), locations);
 }
 
@@ -168,22 +168,15 @@ function gatedOperation(payload: Record<string, unknown>): PhaseOperation | null
 /**
  * PreToolUse for a gated tool: deny without a live run entry; for the two MCP
  * tools, otherwise write the admission the handler consumes. A Planner or
- * Brainstorm Skill call is never denied; with no active claim it records a plan
- * entry first, which revokes the run entry. Any other tool answers null and
- * runs as configured.
+ * Brainstorm Skill call is never denied and leaves the entry store untouched.
+ * Any other tool answers null and runs as configured.
  */
 export function phaseEntryGateHookOutput(payload: Record<string, unknown>, locations: PhaseEntryLocations = {}): string | null {
 	if (payload.hook_event_name !== "PreToolUse") return null;
 	const operation = gatedOperation(payload);
 	if (!operation) return null;
+	if (operation.kind === "skill" && operation.skill !== "imm-run") return null;
 	const root = locations.root ?? tmpdir();
-	if (operation.kind === "skill" && operation.skill !== "imm-run") {
-		let activeClaim = false;
-		try { activeClaim = readActiveClaimTaskId(cwdOf(payload)) !== null; } catch { /* unreadable authority is no claim */ }
-		const sessionId = sessionIdOf(payload);
-		if (!activeClaim && sessionId) appendPhaseEntry(sessionId, "plan", root, locations);
-		return null;
-	}
 	let state: PhaseEntryState | null = null;
 	try { state = readPhaseEntryState(sessionIdOf(payload), root, locations.read); } catch { /* an unreadable store refuses */ }
 	const admission = admitPhaseOperation(operation, state);