immune-brain 5.3.0 → 5.5.1

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

@@ -318,7 +318,8 @@ export async function verifyCandidateDescriptors(input: {
 	};
 	let verdict;
 	try {
-		verdict = await runDeterministicQa(snapshot, descriptors, { signal: input.signal });
+		// The candidate is a merge-tree commit that is never checked out.
+		verdict = await runDeterministicQa(snapshot, descriptors, { signal: input.signal, delivery: "materialized" });
 	} catch (error) {
 		if (error instanceof VerificationAbortedError) throw error;
 		throw new BatchIntegrationError(

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

@@ -3,6 +3,8 @@
 // Kernel-facing member; a Host supplies only advanceTask, its own progression
 // seam. Git operations are not Kernel-port members: the runner drives them
 // through BatchRunnerGitPort alone.
+import { observeParentCompletion } from "./batch_git";
+import type { InitiativeObservation } from "./types";
 import { projectAssurance } from "../kernel/assurance_projection";
 import { deriveChildEnrollment, type BatchAuthorizationBinding, type BatchAuthorityRegistry } from "../kernel/batch_authority";
 import { enrollTask } from "../kernel/enrollment";
@@ -16,6 +18,7 @@ import { batchQaFailureFacts, type BatchChildAdvanceResult, type BatchRunnerKern
 export interface BatchKernelPortInput {
 	/** Worktree root the batch runs in. */
 	root: string;
+	parent?: InitiativeObservation;
 	/** Enrollment authority registry shared with the single Enrollment entry (D3). */
 	enrollmentRegistry: EnrollmentAuthorityRegistry;
 	/** The batch's registry, derived capability and validated binding. */
@@ -53,6 +56,16 @@ export function createBatchKernelPort(input: BatchKernelPortInput): BatchRunnerK
 	const deriveEnrollment = input.deps?.deriveChildEnrollment ?? deriveChildEnrollment;
 	const enrollKernelTask = input.deps?.enrollTask ?? enrollTask;
 	const base: BatchRunnerKernelPort = {
+		canStartTask: async taskId => {
+			if (!input.parent) return true;
+			const task = input.parent.tasks.find(child => child.task_id === taskId);
+			if (!task) throw new Error("authorized child absent from confirmed Parent topology");
+			const authorizedIds = new Set(input.registry.children(input.capability).map(child => child.task_id));
+			const external = task.blocked_by.filter(id => !authorizedIds.has(id));
+			if (!external.length) return true;
+			const observation = await observeParentCompletion(input.root, input.parent.initiative_id, external);
+			return observation.missing_task_ids.length === 0;
+		},
 		enrollTask: async ({ root, task_id, batch }) => {
 			const now = new Date().toISOString();
 			const derived = deriveEnrollment(root, batch.registry, {

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

@@ -12,6 +12,7 @@ import { isAbsolute, join } from "node:path";
 import { computeBatchPlanDigest } from "../kernel/batch_authority";
 import { readTaskRecordRaw } from "../kernel/storage";
 import { readTaskIntent } from "../kernel/intent";
+import { applyScopeRiskFloor, readRiskFloor } from "../kernel/risk_floor";
 import { readTaskTombstone } from "../kernel/backend_claim";
 import {
 	readRuntimeContracts,
@@ -228,14 +229,19 @@ export function laneRuntimeContractRefusal(root: string, executorRuntime?: strin
 	return `${RUNTIME_CONTRACT_MISMATCH}: coordinator runtime ${runningRuntimeSource()} and Lane runtime ${lane.path} disagree (${differences.join("; ")}); load the same runtime on both sides before starting the batch`;
 }
 
-/**
- * A Lane whose Kernel state exists but that this runtime refuses to read is a
- * contract mismatch, not a lost Lane: one side was upgraded under the batch.
- */
-function laneUnreadableReason(error: string): string {
-	return /contract must equal|unknown field|schema version .* incompatible|unknown contract/i.test(error)
-		? `${LANE_CONTRACT_MISMATCH}: ${error}`
-		: "batch_lane_lost";
+function laneUnreadableReason(error: string, taskId: string, runId: string | null | undefined): string {
+	const category = /contract must equal|unknown field|schema version .* incompatible|unknown contract/i.test(error)
+		? LANE_CONTRACT_MISMATCH : "batch_lane_unreadable";
+	// Persist identity and stage, never arbitrary parser/IO exception bytes.
+	return `${category}: ${JSON.stringify({ stage: "project_task", task_id: taskId, run_id: runId ?? null })}`;
+}
+
+async function readLaneProjection(input: StartBatchInput, path: string, taskId: string) {
+	try {
+		return await input.kernel.projectTask(path, taskId);
+	} catch (error) {
+		return { error: error instanceof Error ? error.message : String(error) } as Awaited<ReturnType<StartBatchInput["kernel"]["projectTask"]>>;
+	}
 }
 
 /** The branch the Lane for a child must sit on. */
@@ -393,7 +399,7 @@ function laneGitOf(input: StartBatchInput): BatchLaneGitPort {
 	return (input.git as (BatchRunnerGitPort & { lane?: BatchLaneGitPort }) | undefined)?.lane ?? createDefaultLaneGitPort();
 }
 
-function serialGitOf(input: StartBatchInput): Pick<BatchRunnerGitPort, "preflight" | "commitChild" | "lookupBatchCommit"> {
+function serialGitOf(input: StartBatchInput): Pick<BatchRunnerGitPort, "preflight" | "commitChild" | "lookupBatchCommit" | "retainLaneEvidence"> {
 	return input.git ?? defaultSerialGit();
 }
 
@@ -791,9 +797,11 @@ export async function runLaneBatch(
 				if (!child.lane?.run_id)
 					return laneReport(record, "parked Lane has no recorded run identity; inspect it without re-enrolling", LANE_NEEDS_HUMAN_NEXT_ACTION);
 				const facts = lanes.inspectLane(input.root, child.lane.path);
-				const fresh = await input.kernel.projectTask(child.lane.path, child.task_id);
+				const fresh = await readLaneProjection(input, child.lane.path, child.task_id);
+				if (fresh.error !== null)
+					return laneReport(record, laneUnreadableReason(fresh.error, child.task_id, child.lane.run_id), LANE_NEEDS_HUMAN_NEXT_ACTION);
 				if (!facts.exists || !facts.same_repository || !facts.is_worktree_root || facts.branch !== child.lane.branch ||
-					fresh.error !== null || fresh.projection.run_id !== child.lane.run_id ||
+					fresh.projection.run_id !== child.lane.run_id ||
 					fresh.projection.open_user_decision_count > 0 || fresh.projection.replan_required_ids.length > 0)
 					return laneReport(record, "parked Lane identity or decision is unresolved", LANE_NEEDS_HUMAN_NEXT_ACTION);
 				const state = fresh.projection.lifecycle === "done" && fresh.projection.completion_ready ?
@@ -876,6 +884,8 @@ export async function runLaneBatch(
 			lane_commit: child.lane.lane_commit,
 		});
 		if (!found) continue;
+		await git.retainLaneEvidence?.({ root: input.root, taskId: child.task_id, batchId: record.batch_id,
+			branch: record.branch, lane: { ...child.lane, lane_commit: child.lane.lane_commit, integrated_commit: found } });
 		record.children = record.children.map((c) => (c.task_id === child.task_id ? { ...c, state: "integrated", commit: found } : c));
 		record.commits = [...record.commits, found];
 		persist();
@@ -958,14 +968,17 @@ export async function runLaneBatch(
 				const authorized = readTaskIntent(input.root, request.task_id, planChild?.intent_path ?? undefined).intent;
 				const current = readTaskRecordRaw(child.lane.path, request.task_id).record?.intent_snapshot;
 				if (!current) throw new Error(`the Lane has no TaskRecord for ${request.task_id}`);
-				const outOfBounds = delegatedRevisionRefusal(authorized, current, request.next_intent);
+				// The Lane's own declaration decides the floor of the revision it applies.
+				const floor = readRiskFloor(child.lane.path);
+				const nextIntent = applyScopeRiskFloor(request.next_intent, floor);
+				const outOfBounds = delegatedRevisionRefusal(authorized, current, nextIntent, floor);
 				if (outOfBounds) refuseRevision(outOfBounds);
 				else {
 					const confirmationRef = delegatedConfirmationRef(record.batch_id, grant);
 					const applied = await applyDelegatedIntentRevision({
 						lane_root: child.lane.path,
 						task_id: request.task_id,
-						next_intent: request.next_intent,
+						next_intent: nextIntent,
 						confirmation_ref: confirmationRef,
 						now: input.now,
 					});
@@ -998,8 +1011,9 @@ export async function runLaneBatch(
 				task_id: taskId,
 				batch: { registry: input.registry, capability: input.capability, binding: { batch_id: record.batch_id, expected_head: lane.base_head } },
 			});
-			const fresh = await input.kernel.projectTask(lane.path, taskId);
-			if (fresh.error !== null || !fresh.projection.run_id || fresh.claim?.task_id !== taskId)
+			const fresh = await readLaneProjection(input, lane.path, taskId);
+			if (fresh.error !== null) throw new Error(laneUnreadableReason(fresh.error, taskId, lane.run_id));
+			if (!fresh.projection.run_id || fresh.claim?.task_id !== taskId)
 				throw new Error("enrolled Lane has no observable owned run");
 			record.children = record.children.map((c) => (c.task_id === taskId ? { ...c, state: "enrolled", reason: null, lane: { ...lane, run_id: fresh.projection.run_id } } : c));
 			persist();
@@ -1019,14 +1033,9 @@ export async function runLaneBatch(
 	// Nothing is inferred from terminal text; only Kernel facts move a child.
 	for (const child of [...record.children]) {
 		if ((child.state !== "lane_admitted" && child.state !== "enrolled") || !child.lane) continue;
-		let fresh: Awaited<ReturnType<StartBatchInput["kernel"]["projectTask"]>>;
-		try {
-			fresh = await input.kernel.projectTask(child.lane.path, child.task_id);
-		} catch (error) {
-			fresh = { error: error instanceof Error ? error.message : String(error) } as unknown as typeof fresh;
-		}
+		const fresh = await readLaneProjection(input, child.lane.path, child.task_id);
 		if (fresh.error !== null) {
-			parkChild(child.task_id, laneUnreadableReason(String(fresh.error)));
+			parkChild(child.task_id, laneUnreadableReason(fresh.error, child.task_id, child.lane.run_id));
 			continue;
 		}
 		if (child.lane.run_id && fresh.projection.run_id !== child.lane.run_id) {
@@ -1167,6 +1176,8 @@ export async function runLaneBatch(
 					.filter((c) => c.state === "integrated" && c.task_id !== child.task_id)
 					.map((c) => ({ task_id: c.task_id, intent_path: intentPathOf(c.task_id), commit: c.commit })),
 			});
+			await git.retainLaneEvidence?.({ root: input.root, taskId: child.task_id, batchId: record.batch_id,
+				branch: record.branch, lane: { ...child.lane, lane_commit: child.lane.lane_commit, integrated_commit: commit } });
 			record.children = record.children.map((c) => (c.task_id === child.task_id ? { ...c, state: "integrated", commit, reason: null } : c));
 			record.commits = [...record.commits, commit];
 			persist();
@@ -1199,6 +1210,10 @@ export async function runLaneBatch(
 			refusals.push({ ...offer, reason: "batch_lane_unknown_child" });
 			continue;
 		}
+		if (input.kernel.canStartTask && !await input.kernel.canStartTask(offer.task_id)) {
+			refusals.push({ ...offer, reason: "Parent prerequisite is not integrated" });
+			continue;
+		}
 		const head = expectedBatchHead(record);
 		const facts = lanes.inspectLane(input.root, offer.path);
 		const reason = decideLaneAdmission({
@@ -1227,6 +1242,7 @@ export async function runLaneBatch(
 		// completion report is written. A failure is reported, never rolled back.
 		const final = record.final_verification?.length ? await runFinalVerification(input.root, record.final_verification) : undefined;
 		record.batch_state = "completed";
+		if (final) record.final_verification_result = final;
 		persist();
 		return finalizeLane(
 			input.root,
@@ -1256,8 +1272,11 @@ export async function runLaneBatch(
 			});
 			continue;
 		}
-		const fresh = await input.kernel.projectTask(child.lane.path, child.task_id);
-		if (fresh.error !== null) continue;
+		const fresh = await readLaneProjection(input, child.lane.path, child.task_id);
+		if (fresh.error !== null) {
+			parkChild(child.task_id, laneUnreadableReason(fresh.error, child.task_id, child.lane.run_id));
+			continue;
+		}
 		handoffs.push({
 			role: "executor",
 			task_id: child.task_id,

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

@@ -5,6 +5,7 @@ import { hasLocalInitiative, observeLocalInitiative } from "../local_initiative"
 import { readTaskTombstone } from "../kernel/backend_claim";
 import {
 	observeTaskIntent,
+	observeEnrollmentTaskIntent,
 	TaskIntentObservationError,
 } from "../kernel/intent";
 import { readTaskRecordRaw } from "../kernel/storage";
@@ -155,6 +156,7 @@ export async function projectBatchPlan(
 	initiativeSlug: string,
 	input: ProjectBatchPlanInput,
 	readInitiative: InitiativeObservationReader = observeInitiative,
+	preparing = false,
 ): Promise<BatchPlan> {
 	if (!ID_PATTERN.test(initiativeSlug)) throw new Error("initiative_slug is invalid");
 	if (!input || typeof input !== "object") throw new Error("batch plan input is required");
@@ -180,7 +182,9 @@ export async function projectBatchPlan(
 		}
 		const intentPath = `docs/plans/${task.task_id}.intent.json`;
 		try {
-			const read = observeTaskIntent(root, task.task_id, intentPath);
+			const read = preparing
+				? observeEnrollmentTaskIntent(root, task.task_id)
+				: observeTaskIntent(root, task.task_id, intentPath);
 			if (read.intent.risk === "critical") {
 				children.push({
 					...child,
@@ -224,7 +228,7 @@ export async function projectBatchPlan(
 		if (child.status !== "enrollable") continue;
 		if (directDependencies.get(child.task_id)!.some((id) => {
 			const status = childById.get(id)!.status;
-			return status === "already_owned" || status === "needs_human" || status === "blocked";
+			return status === "already_owned" || (status === "needs_human" && childById.get(id)!.reason !== "critical") || status === "blocked";
 		})) {
 			child.status = "blocked";
 			child.reason = "dependency_unavailable";

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

@@ -19,9 +19,10 @@ import { LITERAL_USER_ACTOR_ID } from "../kernel/actor_identity";
 import { readBackendClaim } from "../kernel/backend_claim";
 import { computeBatchPlanDigest, type BatchAuthorizationBinding } from "../kernel/batch_authority";
 import { readGitHead } from "../kernel/pi_canary_prepare";
-import { readTaskIntent } from "../kernel/intent";
-import { readTaskRecordRaw, readSettledTaskEvidence, readWorkspaceStateRaw, enrollmentEventIdFor, reconcileKernelAuthority } from "../kernel/storage";
+import { readTaskIntent, observeEnrollmentTaskIntent } from "../kernel/intent";
+import { readTaskRecordRaw, readSettledTaskEvidence, readWorkspaceStateRaw, enrollmentEventIdFor, reconcileKernelAuthority, withKernelStoreLock } from "../kernel/storage";
 import type { TaskRecord } from "../kernel/types";
+import { commitWorkflowPaths } from "../assurance/workflow_autocommit";
 import { pathMatchesScope } from "../workspace_scope";
 import { captureBatchReconfirmation, retainReconfirmation, ownUnpersistedBatchHead, type ReconfirmationSnapshot } from "./batch_reconfirmation";
 import { projectBatchPlan } from "./batch_plan";
@@ -419,6 +420,7 @@ type PlanSurfaceOutcome =
  * and the post-confirmation drift check so both read one implementation.
  */
 async function projectPlanSurface(input: {
+	preparing?: boolean;
 	root: string;
 	initiative_slug: string;
 	is_resuming: boolean;
@@ -500,7 +502,7 @@ async function projectPlanSurface(input: {
 	} else {
 		let plan;
 		try {
-			plan = await projectBatchPlan(root, initiativeSlug, { confirmation_time: now }, input.readInitiative);
+			plan = await projectBatchPlan(root, initiativeSlug, { confirmation_time: now }, input.readInitiative, input.preparing);
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
 			if (msg.includes("has no enrollable children"))
@@ -528,7 +530,9 @@ async function projectPlanSurface(input: {
 		for (const c of plan.children.filter((item) => item.status === "enrollable")) {
 			let childRisk = "material";
 			try {
-				childRisk = readTaskIntent(root, c.task_id, c.intent_path ?? undefined).intent.risk;
+				childRisk = (input.preparing
+					? observeEnrollmentTaskIntent(root, c.task_id)
+					: readTaskIntent(root, c.task_id, c.intent_path ?? undefined)).intent.risk;
 			} catch {
 				// fallback
 			}
@@ -555,8 +559,62 @@ async function projectPlanSurface(input: {
 	};
 }
 
-export async function projectBatchPreflight(
-	options: BatchPreflightOptions,
+export async function projectBatchPreflight(options: BatchPreflightOptions): Promise<BatchPreflightOutcome> {
+	return projectPreflight(options, false);
+}
+
+/** Host preparation only: commit fresh-batch preconditions before capturing the binding. */
+export async function prepareBatchPreflight(
+	options: BatchPreflightOptions & { signal?: AbortSignal; reuseOnly?: boolean },
+): Promise<BatchPreflightOutcome & { precondition_commit?: string }> {
+	options.signal?.throwIfAborted();
+	const projected = await projectPreflight(options, !options.reuseOnly);
+	if (!projected.ok || projected.projection.is_resuming || options.reuseOnly) return projected;
+	const { root, initiative_slug: slug } = options;
+	const initialEntries = porcelainEntries(root);
+	if (!initialEntries) return reject("git_status_unreadable");
+	if (initialEntries.length === 0) return projected;
+	let commit: string | undefined;
+	try {
+		const refusal = withKernelStoreLock(root, () => {
+			options.signal?.throwIfAborted();
+			const claim = readActiveClaimTaskId(root);
+			if (claim) return reject("claim_already_active", claim);
+			if (findExistingActiveBatch(root, slug)) return reject("plan_changed");
+			if (readGitHead(root) !== projected.projection.base_head) return reject("head_moved");
+			const scopes: string[] = [];
+			for (const child of projected.projection.recovery_children) {
+				const observed = observeEnrollmentTaskIntent(root, child.task_id);
+				if (observed.content_hash !== child.intent_content_hash) return reject("plan_changed");
+				scopes.push(...observed.intent.scope_hint);
+			}
+			const entries = porcelainEntries(root);
+			if (!entries) return reject("git_status_unreadable");
+			const paths = entries.map(({ path }) => path).filter((path) =>
+				[".imm/audit/", "docs/plans/", "docs/specs/"].some((prefix) => path.startsWith(prefix))
+				|| scopes.some((scope) => pathMatchesScope(path, scope)),
+			);
+			const result = commitWorkflowPaths(root, {
+				paths, subject: `chore(imm): commit batch preconditions for ${slug}`, signal: options.signal,
+			});
+			if (result.committed) commit = result.commit;
+			return null;
+		});
+		if (refusal) return refusal;
+		if (!commit) {
+			const remaining = porcelainEntries(root);
+			if (!remaining) return reject("git_status_unreadable");
+			return remaining.length ? reject("working_tree_dirty", remaining.map(({ path }) => path).join(", ")) : projected;
+		}
+		return { ...await projectBatchPreflight(options), precondition_commit: commit };
+	} catch (error) {
+		return { ...reject("precondition_commit_failed", error instanceof Error ? error.message : String(error)),
+			...(commit ? { precondition_commit: commit } : {}) };
+	}
+}
+
+async function projectPreflight(
+	options: BatchPreflightOptions, allowNewDirt: boolean,
 ): Promise<BatchPreflightOutcome> {
 	const { root, initiative_slug: initiativeSlug, readInitiative } = options;
 	if (!INITIATIVE_SLUG_PATTERN.test(initiativeSlug))
@@ -609,49 +667,52 @@ export async function projectBatchPreflight(
 		else if (plan.kind === "unprovable") unprovableLeak = `${plan.path}: ${plan.detail}`;
 	}
 	if (statusEntries.length > 0) {
-		if (!isResuming)
-			return reject("working_tree_dirty");
-		// Kernel projections accept staged in-flight work inside the active child's
-		// authorized scope, and reject unstaged/untracked bytes or out-of-scope paths.
-		// `settled` belongs here: Kernel settlement happens before the batch commits
-		// the child, and settlement clears the live state record, so a crash in that
-		// window resumes into a settled child whose staged work is legitimate.
-		const inFlightChild = existingBatch!.children.find(
-			(c) => c.state === "enrolled" || c.state === "needs_human" || c.state === "settled",
-		);
-		let authorizedScope: string[] = [];
-		if (inFlightChild) {
-			authorizedScope = authorizedScopeOf(root, inFlightChild.task_id, inFlightChild.state);
-			if (authorizedScope.length === 0)
-				return reject("authorized_scope_underivable");
-		}
-		const dirtyBytes = statusEntries.some(({ code }) => code === "??" || code[1] !== " ");
-		if (dirtyBytes)
-			return reject("working_tree_unstaged", unprovableLeak);
-		let outsideScope = false;
-		for (const { path } of statusEntries) {
-			if (path.startsWith(".imm/") || path.startsWith("docs/plans/") || path.startsWith("docs/specs/")) continue;
-			// Scope entries may be exact files, directories, or globs; delegate the
-			// boundary matching to the Kernel's own helper instead of exact includes.
-			let matched = false;
-			for (const scopePath of authorizedScope) {
-				if (pathMatchesScope(path, scopePath)) {
-					matched = true;
+		if (!isResuming && !allowNewDirt)
+			return reject("working_tree_dirty", statusEntries.map(({ path }) => path).join(", "));
+		if (isResuming) {
+			// Kernel projections accept staged in-flight work inside the active child's
+			// authorized scope, and reject unstaged/untracked bytes or out-of-scope paths.
+			// `settled` belongs here: Kernel settlement happens before the batch commits
+			// the child, and settlement clears the live state record, so a crash in that
+			// window resumes into a settled child whose staged work is legitimate.
+			const inFlightChild = existingBatch!.children.find(
+				(c) => c.state === "enrolled" || c.state === "needs_human" || c.state === "settled",
+			);
+			let authorizedScope: string[] = [];
+			if (inFlightChild) {
+				authorizedScope = authorizedScopeOf(root, inFlightChild.task_id, inFlightChild.state);
+				if (authorizedScope.length === 0)
+					return reject("authorized_scope_underivable");
+			}
+			const dirtyBytes = statusEntries.some(({ code }) => code === "??" || code[1] !== " ");
+			if (dirtyBytes)
+				return reject("working_tree_unstaged", unprovableLeak);
+			let outsideScope = false;
+			for (const { path } of statusEntries) {
+				if (path.startsWith(".imm/") || path.startsWith("docs/plans/") || path.startsWith("docs/specs/")) continue;
+				// Scope entries may be exact files, directories, or globs; delegate the
+				// boundary matching to the Kernel's own helper instead of exact includes.
+				let matched = false;
+				for (const scopePath of authorizedScope) {
+					if (pathMatchesScope(path, scopePath)) {
+						matched = true;
+						break;
+					}
+				}
+				if (!matched) {
+					outsideScope = true;
 					break;
 				}
 			}
-			if (!matched) {
-				outsideScope = true;
-				break;
-			}
+			if (outsideScope)
+				return reject("working_tree_out_of_scope");
 		}
-		if (outsideScope)
-			return reject("working_tree_out_of_scope");
 	}
 
 	// 3. Project or reconstruct the plan (pre-confirmation).
 	const now = options.now ?? new Date().toISOString();
 	const planSurface = await projectPlanSurface({
+		preparing: allowNewDirt && !isResuming,
 		root,
 		initiative_slug: initiativeSlug,
 		is_resuming: isResuming,
@@ -665,7 +726,7 @@ export async function projectBatchPreflight(
 	if (activeRecord && !isLaneBatchRecord(activeRecord) && activeRecord.plan_digest !== planSurface.surface.plan_digest) {
 		try { reconfirmation = await captureBatchReconfirmation(root, activeRecord, planSurface.surface.recovery_children); }
 		catch { return reject("plan_projection_failed", activeRecord.commits.length
-			? `batch plan changed after ${activeRecord.commits.length} recorded child commit(s). The old authorization cannot execute the revised plan. Preserve the batch record, report, commit evidence and audit; inspect each remaining child's Kernel run before an explicit imm-run handoff. Do not re-enroll settled children or manufacture batch trailers. To close the parked record explicitly, dispose it with the retire_stale_batch Tool for this Initiative; a child that is still mid-flight must settle first. This rejection neither terminates the old batch nor authorizes the revised plan.`
+			? `batch plan changed after ${activeRecord.commits.length} recorded child commit(s). The old authorization cannot execute the revised plan. Preserve the batch record, report, commit evidence and audit; inspect each remaining child's Kernel run before an explicit imm-run handoff. Do not re-enroll settled children or manufacture batch trailers. To close the parked record explicitly, dispose it with the retire_stale_batch Tool for this Initiative; a child whose Kernel run is still live must settle first, while one that already ended outside the batch does not block the disposition. This rejection neither terminates the old batch nor authorizes the revised plan.`
 			: "batch plan reconfirmation is not eligible"); }
 	}
 

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

@@ -34,6 +34,7 @@ export type BatchReasonKey =
 	| "repository_became_unreadable"
 	| "head_moved"
 	| "cancelled_before_execution"
+	| "precondition_commit_failed"
 	| "batch_run_rejected"
 	| "stale_batch_absent"
 	| "stale_batch_in_flight";
@@ -83,8 +84,8 @@ export const BATCH_REASONS: Readonly<Record<BatchReasonKey, BatchReasonSpec>> =
 	},
 	working_tree_dirty: {
 		state: "rejected",
-		reason: "branch preflight failed: working tree is dirty",
-		recovery_action: "delete or rename the conflicting branch, or commit working changes in the current Host",
+		reason: (detail: string) => `branch preflight failed: working tree is dirty${detail ? `: ${detail}` : ""}`,
+		recovery_action: "resolve the listed remaining paths outside the batch committable set, then retry in the current Host",
 	},
 	authorized_scope_underivable: {
 		state: "rejected",
@@ -167,6 +168,11 @@ export const BATCH_REASONS: Readonly<Record<BatchReasonKey, BatchReasonSpec>> =
 		reason: "user cancelled before batch execution",
 		recovery_action: "wait for a fresh literal-user request",
 	},
+	precondition_commit_failed: {
+		state: "rejected",
+		reason: (detail: string) => `batch precondition commit failed: ${detail}`,
+		recovery_action: "repair the reported Git precondition failure and retry the batch in the current Host",
+	},
 	batch_run_rejected: {
 		state: "rejected",
 		// The runner owns the specific reason; the fallback is this entry's own text.
@@ -181,7 +187,7 @@ export const BATCH_REASONS: Readonly<Record<BatchReasonKey, BatchReasonSpec>> =
 	stale_batch_in_flight: {
 		state: "blocked",
 		reason: (detail: string) => `a batch child is still mid-flight, so the record cannot be disposed: ${detail}`,
-		recovery_action: "settle or stop the in-flight child through its own task, then dispose the batch in the current Host",
+		recovery_action: "settle or stop the in-flight child through its own task, then dispose the batch in the current Host; a child whose Kernel run already ended no longer blocks the disposition",
 	},
 });
 

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

@@ -1,12 +1,13 @@
 // Read-only eligibility for a first, zero-commit plan reconfirmation.
 import { spawnSync } from "node:child_process";
 import { computeBatchPlanDigest, type BatchPlanChild as DigestChild } from "../kernel/batch_authority";
-import { canonicalIntentHash, parseTaskIntentV1, readTaskIntent } from "../kernel/intent";
+import { canonicalIntentHash, parseProjectTaskIntent, readTaskIntent } from "../kernel/intent";
 import { projectAssurance } from "../kernel/assurance_projection";
 import { readAuditTaskPair, readSecureProjectBytes, readSettledRunEvidence, enrollmentEventIdFor, readWorkspaceStateRaw, type SettledRunEvidence } from "../kernel/storage";
 import { auditRunDirPath, auditRunRecordPath, auditRunTerminalProofPath, batchCommitEvidencePath, batchStatePath } from "../kernel/storage_paths";
 import { taskDeliveryIdentity, taskCommitRevisionIdentity, pathMatchesScope } from "../workspace_scope";
 import { projectTask } from "../kernel/completion";
+import { readRiskFloor } from "../kernel/risk_floor";
 import { isTerminalBatchState, type BatchRunStateRecord } from "./batch_state";
 import type { BatchPlanChild } from "./types";
 
@@ -54,7 +55,7 @@ export function ownUnpersistedBatchHead(root: string, record: BatchRunStateRecor
 		if (!paths.length || paths.some(path => !path.startsWith(`${auditRunDirPath(task, run)}/`) &&
 			!pair.record.intent_snapshot.scope_hint.some(s => pathMatchesScope(path, s)))) return false;
 		const identity = taskCommitRevisionIdentity(root, pair.record.intent_snapshot.scope_hint, pair.record.git_base_head, head);
-		if (!projectTask(pair.record.intent_snapshot, pair.record, identity.diff_hash, pair.record.intent_ref.content_hash, identity.changed_paths).complete) return false;
+		if (!projectTask(pair.record.intent_snapshot, pair.record, identity.diff_hash, pair.record.intent_ref.content_hash, identity.changed_paths, readRiskFloor(root)).complete) return false;
 		return git(root, ["rev-parse", "HEAD"]).trim() === head;
 	} catch { return false; }
 }
@@ -111,12 +112,12 @@ export async function captureBatchReconfirmation(root: string, record: BatchRunS
 		const previous = record.children[index]!;
 		if (!id.test(child.task_id) || child.task_id !== previous.task_id || child.slice_id !== previous.slice_id ||
 			JSON.stringify(child.blocked_by) !== JSON.stringify(previous.blocked_by) || child.intent_path !== `docs/plans/${child.task_id}.intent.json`) refuse();
-		const old = parseTaskIntentV1(JSON.parse(git(root, ["show", `${record.base_head}:${child.intent_path}`])));
+		const old = parseProjectTaskIntent(root, JSON.parse(git(root, ["show", `${record.base_head}:${child.intent_path}`])));
 		if (old.task_id !== child.task_id) refuse();
 		const oldHash = canonicalIntentHash(old);
 		oldChildren.push({ task_id: child.task_id, blocked_by: [...child.blocked_by], intent_path: child.intent_path, intent_revision: old.revision, intent_content_hash: oldHash });
 		const currentBytes = capture(child.intent_path);
-		const current = parseTaskIntentV1(JSON.parse(decode(currentBytes)));
+		const current = parseProjectTaskIntent(root, JSON.parse(decode(currentBytes)));
 		const currentHash = canonicalIntentHash(current);
 		const tracked = readTaskIntent(root, child.task_id, child.intent_path);
 		if (currentHash !== tracked.content_hash || currentHash !== child.intent_content_hash || current.revision !== child.intent_revision) refuse();
@@ -140,12 +141,11 @@ export async function captureBatchReconfirmation(root: string, record: BatchRunS
 		const capturedProof = JSON.parse(decode(capture(proofPath)));
 		if (!matchesLocalProof(settled.proof_json, capturedProof) || !matchesLocalProof(settled.proof_json, pair.proof)) refuse();
 		const identity = taskDeliveryIdentity(root, r);
-		const projection = await projectAssurance(root, child.task_id, (cwd, task) => {
-			if (task.contract !== "assurance_kernel/task_record/v4" || !task.git_base_head) refuse();
-			return taskDeliveryIdentity(cwd, task);
-		});
+		// Settlement status is historical; reconfirmation must also bind the current delivery.
+		if (!projectTask(r.intent_snapshot, r, identity.diff_hash, currentHash, identity.changed_paths, readRiskFloor(root)).complete) refuse();
+		const projection = await projectAssurance(root, child.task_id);
 		if (projection.error || projection.claim || projection.projection.run_id !== run || projection.projection.lifecycle !== "done" ||
-			!projection.projection.completion_ready || projection.projection.intent_content_hash !== currentHash || projection.projection.diff_hash !== identity.diff_hash ||
+			!projection.projection.completion_ready || projection.projection.intent_content_hash !== currentHash ||
 			!projection.projection.fresh_approval_kinds.includes("qa") ||
 			(projection.projection.risk !== "routine" && !projection.projection.fresh_approval_kinds.includes("review"))) refuse();
 		scope = r.intent_snapshot.scope_hint;