immune-brain 4.3.0 → 4.4.1

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

@@ -23,6 +23,7 @@ export const TOOLS = [
 	{ name: "advance_assurance", description: "Advance frozen Assurance through deterministic QA and Review reservation.", privileged: false },
 	{ name: "submit_review", description: "Submit the Parent-mediated Review verdict bound to the correlated receipt.", privileged: false },
 	{ name: "request_authorization", description: "Apply exact literal-user authorization.", privileged: true },
+	{ name: "revise_intent", description: "Apply a compatible TaskIntent revision.", privileged: false },
 	{ name: "approve_breaking_intent_revision", description: "Approve a breaking TaskIntent revision.", privileged: true },
 	{ name: "stop", description: "Stop the active task with literal-user authority.", privileged: true },
 	{ name: "start_unattended_batch", description: "Start an unattended serial batch run for an Initiative after native confirmation.", privileged: true },
@@ -42,7 +43,7 @@ export function listMcpTools() {
 					? { initiative_slug: { type: "string" } }
 					: {
 						task_id: { type: "string" },
-						...(tool.name === "approve_breaking_intent_revision" ? { next_intent: { type: "object" } } : {}),
+						...(tool.name === "approve_breaking_intent_revision" || tool.name === "revise_intent" ? { next_intent: { type: "object" } } : {}),
 						...(tool.name === "stop" ? { reason: { type: "string" } } : {}),
 						...(tool.name === "submit_review" ? { verdict: { type: "object" } } : {}),
 						...(tool.name === "resolve_finding" ? { finding_id: { type: "string" } } : {}),
@@ -57,7 +58,9 @@ export function listMcpTools() {
 						? ["task_id", "finding_id"]
 						: tool.name === "refute_finding"
 							? ["task_id", "finding_id", "attestation_id"]
-							: ["task_id"],
+							: tool.name === "revise_intent"
+								? ["task_id", "next_intent"]
+								: ["task_id"],
 		},
 		annotations: tool.privileged ? privilegedAnnotations() : { readOnlyHint: tool.name === "status" },
 	}));
@@ -162,6 +165,10 @@ export function createMcpRuntime(options: McpRuntimeOptions = {}) {
 				if (!Object.hasOwn(args, "verdict")) throw new Error("verdict is required");
 				return runtime.submitReview(taskId, args.verdict);
 			}
+			if (name === "revise_intent") {
+				if (!Object.hasOwn(args, "next_intent")) throw new Error("next_intent is required");
+				return runtime.reviseIntent(taskId, args.next_intent);
+			}
 			if (name === "resolve_finding") {
 				// Structural only. Which findings may be resolved, and when, stays
 				// the reducer's decision; duplicating it here would create a second

package/plugins/immune-brain/runtime/plugin_version.ts

@@ -1,2 +1,2 @@
 // Generated by scripts/plugin_versioning.ts from the root package.json.
-export const PLUGIN_VERSION = "4.3.0" as const;
+export const PLUGIN_VERSION = "4.4.1" as const;

package/plugins/immune-brain/runtime/prompts/executor.md

@@ -6,6 +6,12 @@ same-boundary follow-up) in the current Parent conversation. New helpers or
 tests inside an approved directory or glob do not require a revision. Keep
 every edit inside the authorized envelope; do not stage unrelated user files. Do not discover or load a Pi Skill.
 
+On a batch `handoff.role=executor`, implement only its named enrolled child;
+the batch stays `running` with that child `enrolled`. Return to the Parent after
+scoped implementation, staging and focused diagnostics. Enrollment itself does
+not start QA; the Parent owns the subsequent Kernel Assurance and foreground
+Review handoff under the same still-valid batch authorization.
+
 Before handoff, run the permitted diagnostic checks and return commands and
 outcomes to the Parent as structured diagnostic evidence. The read-only Loop
 runtime action only constructs the dispatch envelope; it does not store

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

@@ -19,7 +19,7 @@ import type {
 } from "./types";
 
 const ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
-const DEFAULT_DEADLINE_MS = 8 * 60 * 60 * 1_000;
+export const DEFAULT_DEADLINE_MS = 8 * 60 * 60 * 1_000;
 const DEFAULT_QA_FAILURE_LIMIT = 2;
 
 /**

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

@@ -20,11 +20,11 @@ import { readBackendClaim } from "../kernel/backend_claim";
 import { computeBatchPlanDigest, type BatchAuthorizationBinding } from "../kernel/batch_authority";
 import { readGitHead } from "../kernel/pi_canary_prepare";
 import { readTaskIntent } from "../kernel/intent";
-import { localRunId, readAuditTaskPair, readTaskRecordRaw, readWorkspaceStateRaw } from "../kernel/storage";
+import { localRunId, readAuditTaskPair, readTaskRecordRaw, readWorkspaceStateRaw, reconcileKernelAuthority } from "../kernel/storage";
 import { pathMatchesScope } from "../workspace_scope";
-import { projectBatchPlan } from "./batch_plan";
+import { DEFAULT_DEADLINE_MS, projectBatchPlan } from "./batch_plan";
 import { batchReason, type BatchReasonKey } from "./batch_reasons";
-import { isTerminalBatchState, type BatchRunStateRecord } from "./batch_state";
+import { isTerminalBatchState, readBatchRunState, type BatchRunStateRecord } from "./batch_state";
 import { readRunRowByTask, withKernelRead } from "../kernel/sqlite_store";
 import type {
 	BatchPlanBudget,
@@ -139,7 +139,13 @@ export function findExistingActiveBatch(root: string, initiativeSlug: string): B
 			return { corrupt: true, path: file };
 		}
 		if (isTerminalBatchState(candidate.batch_state)) continue;
-		return { corrupt: false, record: candidate };
+		try {
+			const record = readBatchRunState(root, file.slice(0, -5));
+			if (record) return { corrupt: false, record };
+		} catch {
+			// Reuse the state owner's full validation before offering a renewal.
+		}
+		return { corrupt: true, path: file };
 	}
 	return null;
 }
@@ -338,7 +344,11 @@ async function projectPlanSurface(input: {
 	let budget: BatchPlanBudget;
 
 	if (isResuming && existingBatch) {
-		budget = existingBatch.budget;
+		// Candidate only: renewal uses the same default window as a fresh plan,
+		// while preserving the confirmed count limits and the persisted record.
+		budget = { ...existingBatch.budget };
+		if (Date.parse(budget.deadline_at) <= Date.parse(now))
+			budget.deadline_at = new Date(Date.parse(now) + DEFAULT_DEADLINE_MS).toISOString();
 		try {
 			recoveryChildren = existingBatch.children.map((c) => {
 				const intentPath = `docs/plans/${c.task_id}.intent.json`;
@@ -465,6 +475,11 @@ export async function projectBatchPreflight(
 
 	// 1. Active workspace claim (pre-confirmation).
 	const activeTaskId = readActiveClaimTaskId(root);
+	if (activeTaskId) {
+		const authority = reconcileKernelAuthority(root, activeTaskId);
+		if (authority.state === "authority_conflict")
+			return reject("kernel_authority_conflict", authority.diagnostic ?? "unverifiable workspace authority");
+	}
 	const ownClaim =
 		isResuming && activeTaskId !== null && isOwnBatchClaim(root, activeRecord!, activeTaskId, batchBranch);
 	if (activeTaskId && !ownClaim)
@@ -678,9 +693,9 @@ export async function authorizeBatch<HostRejection>(
 	// so its expiry is the deadline the literal user confirmed rather than a fixed
 	// window that lapses while a child is parked on a foreground Review.
 	const isExistingExpired = isResuming && Date.parse(existingBatch!.authorization_expires_at) <= Date.now();
-	const expiresAt = isResuming && !isExistingExpired && existingBatch!.batch_state === "running"
-		? existingBatch!.authorization_expires_at
-		: budget.deadline_at;
+	const branchBefore = spawnSync("git", ["-C", root, "branch", "--show-current"], { encoding: "utf8" });
+	if (branchBefore.status !== 0)
+		return { outcome: "rejected", rejection: batchRejection("repository_became_unreadable") };
 
 	// ADR-0005 Decision 1: a resume of an intact, still-binding authorization
 	// reuses it instead of opening a second native gate. Anything that no longer
@@ -688,12 +703,14 @@ export async function authorizeBatch<HostRejection>(
 	const reuseBlockers: string[] = [];
 	if (isResuming && existingBatch) {
 		if (isExistingExpired) reuseBlockers.push("batch_authorization_expired");
+		if (Date.parse(existingBatch.budget.deadline_at) <= Date.now()) reuseBlockers.push("batch_budget_expired");
 		if (existingBatch.batch_state !== "running") reuseBlockers.push("batch_not_running");
 		if (existingBatch.plan_digest !== planDigest) reuseBlockers.push("batch_plan_digest_changed");
 		if (existingBatch.branch !== batchBranch) reuseBlockers.push("batch_branch_changed");
 		if (expectedBatchHead(existingBatch) !== baseHead) reuseBlockers.push("batch_head_lineage_moved");
 	}
 	const reuseAuthorization = isResuming && reuseBlockers.length === 0;
+	const expiresAt = reuseAuthorization ? existingBatch!.authorization_expires_at : budget.deadline_at;
 
 	const batchId = isResuming && existingBatch ? existingBatch.batch_id : `batch-${initiativeSlug}-${randomUUID()}`;
 	const facts: BatchConfirmationFacts = {
@@ -748,6 +765,19 @@ export async function authorizeBatch<HostRejection>(
 	if (finalClaimTaskId && !finalOwnClaim)
 		return { outcome: "rejected", rejection: batchRejection("claim_appeared_during_confirmation", finalClaimTaskId) };
 
+	// Confirmation cannot adopt a changed record or extend its displayed window
+	// after the user answers. Re-read the clock and branch after the async checks.
+	if (isResuming) {
+		const current = findExistingActiveBatch(root, initiativeSlug);
+		if (!current || current.corrupt || JSON.stringify(current.record) !== JSON.stringify(existingBatch))
+			return { outcome: "rejected", rejection: batchRejection("plan_changed") };
+	}
+	const branchAfter = spawnSync("git", ["-C", root, "branch", "--show-current"], { encoding: "utf8" });
+	if (branchAfter.status !== 0 || branchAfter.stdout !== branchBefore.stdout)
+		return { outcome: "rejected", rejection: batchRejection("confirmation_failed", "Git branch moved after native confirmation") };
+	if (Date.parse(expiresAt) <= Date.now())
+		return { outcome: "rejected", rejection: batchRejection("confirmation_failed", "confirmed batch deadline expired before authorization issuance") };
+
 	const binding: BatchAuthorizationBinding = {
 		batch_id: batchId,
 		initiative_slug: initiativeSlug,

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

@@ -13,6 +13,7 @@ export type BatchReasonKey =
 	| "invalid_slug"
 	| "batch_state_unreadable"
 	| "claim_already_active"
+	| "kernel_authority_conflict"
 	| "git_head_unreadable"
 	| "branch_already_exists"
 	| "git_status_unreadable"
@@ -59,6 +60,11 @@ export const BATCH_REASONS: Readonly<Record<BatchReasonKey, BatchReasonSpec>> =
 		reason: (detail: string) => `an active workspace claim already exists for task: ${detail}`,
 		recovery_action: "resolve or stop the active task before starting a batch in the current Host",
 	},
+	kernel_authority_conflict: {
+		state: "rejected",
+		reason: (detail: string) => `Kernel authority conflict: ${detail}`,
+		recovery_action: "resolve the Kernel storage conflict before resuming in the current Host",
+	},
 	git_head_unreadable: {
 		state: "rejected",
 		reason: (detail: string) => detail,

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

@@ -12,6 +12,16 @@ import {
 	computeBatchPlanDigest,
 } from "../kernel/batch_authority";
 import type { AssuranceProjectionResult } from "../kernel/assurance_projection";
+import type { TaskRecord } from "../kernel/types";
+import { deriveAssuranceRecovery, type AssuranceRecovery, type TaskRecordRead } from "../assurance/coordinator";
+import type { QaCheckDiagnostic } from "../assurance/qa";
+
+/** Failed atomic QA attempts observed through Kernel history, including Parent-driven QA. */
+export function batchQaFailureFacts(record: Pick<TaskRecord, "history"> & { findings: NonNullable<TaskRecordRead["record"]>["findings"] }) {
+	const failed = record.history.filter((event) => event.type === "request_rework" && event.authority?.authority_kind === "qa");
+	return { qa_failure_count: failed.length, last_qa_failure_at: failed.at(-1)?.at ?? null,
+		recovery_findings: record.findings.filter(f => f.status === "open").map(f => ({ id: f.id, kind: f.kind, status: f.status, acceptance_id: f.acceptance_id })) };
+}
 import type { BatchPlanChild } from "./types";
 import {
 	type BatchRunnerGitPort,
@@ -75,7 +85,7 @@ export interface BatchRunnerKernelPort {
 	 * persistence. Uses the real AssuranceProjectionResult contract; batch
 	 * ownership of the claim is verified separately through the authoritative
 	 * batch registry, because the Kernel claim carries no batch id. */
-	projectTask(root: string, taskId: string): Promise<AssuranceProjectionResult>;
+	projectTask(root: string, taskId: string): Promise<AssuranceProjectionResult & { qa_failure_count?: number; last_qa_failure_at?: string | null; recovery_findings?: NonNullable<TaskRecordRead["record"]>["findings"] }>;
 	/** Authoritative batch ownership check: true when the task's Kernel claim
 	 * is held under this batch's derived capability (consumed child slot). */
 	ownsTaskClaim(taskId: string): boolean;
@@ -92,13 +102,14 @@ export interface BatchRunnerKernelPort {
 	}): ValidatedBatchAuthorization;
 }
 
-export type BatchChildAdvanceResult =
+export type BatchChildAdvanceResult = { diagnostics?: QaCheckDiagnostic[]; environment_failure?: boolean; recovery?: AssuranceRecovery } & (
 	| { state: "completed" }
 	| { state: "stopped" }
 	| { state: "failed"; reason: string }
 	| { state: "rework"; operation: "qa" | "review"; summary: string }
 	| { state: "blocked"; reason: string }
-	| { state: "review_ready"; operation_id: string };
+	| { state: "review_ready"; operation_id: string }
+	| { state: "review_preparation_failed"; operation: "review"; operation_id: string; reason: string });
 
 export interface StartBatchInput {
 	root: string;
@@ -166,13 +177,13 @@ function isAuthorizationExpiryError(error: unknown): boolean {
 	return error instanceof BatchAuthorizationExpiryError;
 }
 
-function requireFreshProjection(
-	result: AssuranceProjectionResult,
+function requireFreshProjection<T extends AssuranceProjectionResult>(
+	result: T,
 	taskId: string,
-): AssuranceProjectionResult & { error: null } {
+): T & { error: null } {
 	if (result.error !== null)
 		throw new Error(`cannot reconcile Kernel projection for ${taskId}: ${result.error}`);
-	return result as AssuranceProjectionResult & { error: null };
+	return result as T & { error: null };
 }
 
 /** Next pending child whose direct dependents are all committed. */
@@ -216,6 +227,29 @@ function reportFor(
 	};
 }
 
+/** Derived observation only: Parent must re-read Kernel ownership before execution. */
+function executorHandoff(
+	record: BatchRunStateRecord,
+	taskId: string,
+	fresh: AssuranceProjectionResult & { error: null; recovery_findings?: NonNullable<TaskRecordRead["record"]>["findings"] },
+	failure: { state?: string; environment_failure?: boolean; diagnostics?: QaCheckDiagnostic[] } = {},
+): BatchRunReport {
+	const recovery = deriveAssuranceRecovery(taskId, fresh, failure, fresh.recovery_findings);
+	return {
+		...reportFor(record, null, recovery?.next_action ?? (fresh.projection.artifact_state === "frozen"
+			? "The child is frozen with pending QA. Call advance_assurance once; follow its diagnostics before retrying, then submit any reserved Review before batch continuation."
+			: "Route the enrolled child to foreground Executor, implement and stage its scoped work, then call Kernel advance_assurance. Submit any reserved Review verdict before continuing start_unattended_batch with the same Initiative.")),
+		...(recovery ? { recovery } : {}),
+		...(failure.diagnostics?.length ? { diagnostics: failure.diagnostics } : {}),
+		handoff: recovery?.category === "authorization" ? undefined : {
+			role: "executor", task_id: taskId,
+			run_id: fresh.projection.run_id ?? null,
+			record_revision: fresh.projection.record_revision,
+			next_obligation: fresh.projection.next_obligation,
+		},
+	};
+}
+
 /** review-3(6th round): persist the single run report when the batch
  * stops — including a needs_human park, which ends the current run even
  * though the batch remains resumable after a human decision. */
@@ -224,8 +258,9 @@ function finalize(
 	record: BatchRunStateRecord,
 	reason: string | null,
 	nextAction: string,
+	details: Pick<BatchRunReport, "recovery" | "diagnostics"> = {},
 ): BatchRunReport {
-	const report = reportFor(record, reason, nextAction);
+	const report = { ...reportFor(record, reason, nextAction), ...details };
 	if (isTerminalBatchState(record.batch_state) || record.batch_state === "needs_human") {
 		writeBatchRunReport(root, report);
 	}
@@ -525,7 +560,6 @@ async function startBatchLocked(input: StartBatchInput): Promise<BatchRunReport>
 			authorization_expires_at: input.authorization_expires_at,
 			budget: input.budget,
 			batch_state: "running",
-			consecutive_qa_failures: 0,
 			children: resumedChildren,
 		});
 	}
@@ -786,105 +820,11 @@ async function startBatchLocked(input: StartBatchInput): Promise<BatchRunReport>
 			break;
 		}
 		}
-	// Drive the child through the Kernel obligation surface only; rework
-		// below the limit retries the same child in this inner loop.
-		let childTerminal = false;
-		while (!childTerminal) {
-		const terminal = await input.kernel.advanceTask(input.root, child.task_id);
-		if (terminal.state === "completed") {
-			childTerminal = true;
-			// review-6: a successful settlement resets the consecutive-QA-failure
-			// counter so separated failures do not park later children.
-			record.consecutive_qa_failures = 0;
-			record.children = record.children.map((c) =>
-				c.task_id === child.task_id ? { ...c, state: "settled", reason: null } : c,
-			);
-			persist();
-			// Scope-bound commit; a lineage failure fails the whole batch.
-			try {
-				const planChild = input.children.find((c) => c.task_id === child.task_id);
-				const intentPath = planChild?.intent_path ?? undefined;
-				const { commit } = input.git?.commitChild
-					? await input.git.commitChild(input.root, child.task_id, input.batch_id, head, record.branch, intentPath)
-					: input.kernel.commitChild
-						? await input.kernel.commitChild(input.root, child.task_id, input.batch_id, head, record.branch, intentPath)
-						: await commitBatchChild({
-							root: input.root,
-							taskId: child.task_id,
-							batchId: input.batch_id,
-							expectedHead: head,
-							branch: record.branch,
-							intentPath,
-						});
-				record.children = record.children.map((c) =>
-					c.task_id === child.task_id ? { ...c, state: "committed", commit } : c,
-				);
-				record.commits.push(commit);
-				head = commit;
-				persist();
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				record.children = record.children.map((c) =>
-					c.task_id === child.task_id ? { ...c, state: "needs_human", reason: message } : c,
-				);
-				// review-4: a commit failure is terminal; dependents must be
-				// skipped_blocked, not left pending.
-				skipDependents(record, child.task_id, `dependency ${child.task_id} failed to commit`);
-				record.batch_state = "failed";
-				persist();
-				break;
-			}
-		} else if (terminal.state === "stopped") {
-			record.children = record.children.map((c) =>
-				c.task_id === child.task_id
-					? { ...c, state: "needs_human", reason: "Kernel reported the child stopped" }
-					: c,
-			);
-			childTerminal = true;
-			skipDependents(record, child.task_id, `dependency ${child.task_id} parked`);
-			record.batch_state = "needs_human";
-			persist();
-		} else if (terminal.state === "rework" && terminal.operation === "qa") {
-			record.consecutive_qa_failures += 1;
-			if (record.consecutive_qa_failures >= record.budget.qa_failure_limit) {
-				record.children = record.children.map((c) =>
-					c.task_id === child.task_id
-						? { ...c, state: "needs_human", reason: `QA failure limit reached: ${terminal.summary}` }
-						: c,
-				);
-				record.batch_state = "needs_human";
-				childTerminal = true;
-				skipDependents(record, child.task_id, `dependency ${child.task_id} parked`);
-				persist();
-			} else {
-				// Below the limit: the inner loop re-drives the same child.
-				persist();
-			}
-		} else if (terminal.state === "failed" || terminal.state === "blocked" || terminal.state === "rework") {
-			const reason = terminal.state === "rework" ? terminal.summary : terminal.reason;
-			childTerminal = true;
-			record.children = record.children.map((c) =>
-				c.task_id === child.task_id ? { ...c, state: "needs_human", reason } : c,
-			);
-			skipDependents(record, child.task_id, `dependency ${child.task_id} parked`);
-			record.batch_state = "needs_human";
-			persist();
-		} else if (terminal.state === "review_ready") {
-			// A foreground Review reservation is owned by the calling host
-			// turn; the batch pauses here without parking the child.
-			record.children = record.children.map((c) =>
-				c.task_id === child.task_id
-					? { ...c, state: "enrolled", reason: `review reservation ${terminal.operation_id} open` }
-					: c,
-			);
-			persist();
-			return reportFor(
-				record,
-				`child ${child.task_id} holds an open Review reservation`,
-				"Submit the reserved foreground Review verdict, then call startBatch again to continue.",
-			);
-		}
-		}
+		const enrolled = requireFreshProjection(
+			await input.kernel.projectTask(input.root, child.task_id), child.task_id,
+		);
+		return executorHandoff(record, child.task_id, enrolled);
+
 	}
 
 	return finalize(input.root, record, stopReasonFor(record), "");
@@ -987,6 +927,26 @@ export async function resumeBatch(
 				});
 				return finalize(input.root, existing, "claim held by another batch", "needs-human-attention");
 			}
+			if (holdsClaim) {
+				const failures = Math.max(existing.consecutive_qa_failures, fresh.qa_failure_count ?? 0);
+				if (failures >= existing.budget.qa_failure_limit && fresh.last_qa_failure_at &&
+					Date.parse(fresh.last_qa_failure_at) > Date.parse(existing.confirmation_time)) {
+					const reason = "QA failure limit reached; repair and settle the own child through Kernel before resuming the batch";
+					skipDependents(existing, driven.task_id, `dependency ${driven.task_id} parked`);
+					existing = writeBatchRunState(input.root, {
+						...existing, batch_state: "needs_human", consecutive_qa_failures: failures,
+						children: existing.children.map((c) => c.task_id === driven.task_id ? { ...c, state: "needs_human", reason } : c),
+					});
+					return finalize(input.root, existing, reason, "Repair and settle the own child through Kernel, then re-confirm the batch.",
+						{ recovery: deriveAssuranceRecovery(driven.task_id, fresh, {}, fresh.recovery_findings) ?? undefined });
+				}
+				if (failures !== existing.consecutive_qa_failures)
+					existing = writeBatchRunState(input.root, { ...existing, consecutive_qa_failures: failures });
+				// A failed preparation can leave frozen inputs with run_qa pending.
+				// The Parent owns that attempt; batch re-entry never blindly reruns it.
+				if (fresh.projection.next_obligation === "run_qa" || fresh.projection.artifact_state !== "frozen")
+					return executorHandoff(existing, driven.task_id, fresh);
+			}
 			if (!holdsClaim) {
 				// review-1(4th round): a claimless projection still carries a
 				// projection body when the task is a terminal owner. If the fresh
@@ -1001,6 +961,7 @@ export async function resumeBatch(
 				if (settledRemotely) {
 					existing = writeBatchRunState(input.root, {
 						...existing,
+						consecutive_qa_failures: 0,
 						children: existing.children.map((c) =>
 							c.task_id === driven.task_id
 								? { ...c, state: "settled", reason: "crash after settlement; resuming at commit" }
@@ -1178,39 +1139,9 @@ async function driveInterruptedChild(
 			);
 			record.consecutive_qa_failures = 0;
 			persist();
-			try {
-				const planChild = input.children.find((c) => c.task_id === child.task_id);
-				const intentPath = planChild?.intent_path ?? undefined;
-				const { commit } = input.git?.commitChild
-					? await input.git.commitChild(input.root, child.task_id, input.batch_id, head, record.branch, intentPath)
-					: input.kernel.commitChild
-						? await input.kernel.commitChild(input.root, child.task_id, input.batch_id, head, record.branch, intentPath)
-						: await commitBatchChild({
-							root: input.root,
-							taskId: child.task_id,
-							batchId: input.batch_id,
-							expectedHead: head,
-							branch: record.branch,
-							intentPath,
-						});
-				record.children = record.children.map((c) =>
-					c.task_id === child.task_id ? { ...c, state: "committed", commit } : c,
-				);
-				record.commits.push(commit);
-				head = commit;
-				persist();
-				child = { ...child, state: "committed", commit };
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				record.children = record.children.map((c) =>
-					c.task_id === child.task_id ? { ...c, state: "needs_human", reason: message } : c,
-				);
-				// review-4: dependents are skipped_blocked, not left pending.
-				skipDependents(record, child.task_id, `dependency ${child.task_id} failed to commit`);
-				record.batch_state = "failed";
-				persist();
-				return finalize(input.root, record, message, "");
-			}
+			// Use the same lookup/commit path for new settlement and crash recovery.
+			child = { ...child, state: "settled", reason: null };
+			continue;
 		} else if (terminal.state === "review_ready") {
 			record.children = record.children.map((c) =>
 				c.task_id === child.task_id
@@ -1227,24 +1158,31 @@ async function driveInterruptedChild(
 		} else if (terminal.state === "rework" && terminal.operation === "qa") {
 			// review-3(3rd round): interrupted-child rework applies the same
 			// consecutive-failure limit as startBatch instead of parking on the
-			// first rework; below the limit the loop re-drives the same child.
+			// first rework; below the limit implementation returns to the Parent.
 			record.consecutive_qa_failures += 1;
 			if (record.consecutive_qa_failures >= record.budget.qa_failure_limit) {
-				const reason = `QA failure limit reached: ${terminal.summary}`;
+				const reason = "QA failure limit reached";
 				record.children = record.children.map((c) =>
 					c.task_id === child.task_id ? { ...c, state: "needs_human", reason } : c,
 				);
 				record.batch_state = "needs_human";
 				skipDependents(record, child.task_id, `dependency ${child.task_id} parked`);
 				persist();
-				return finalize(input.root, record, reason, "");
+				const fresh = requireFreshProjection(await input.kernel.projectTask(input.root, child.task_id), child.task_id);
+				return finalize(input.root, record, reason, "Repair and settle the own child through Kernel, then re-confirm the batch.",
+					{ recovery: deriveAssuranceRecovery(child.task_id, fresh, terminal, fresh.recovery_findings) ?? undefined, diagnostics: terminal.diagnostics });
 			}
 			persist();
+			const fresh = requireFreshProjection(await input.kernel.projectTask(input.root, child.task_id), child.task_id);
+			return executorHandoff(record, child.task_id, fresh, terminal);
+		} else if (terminal.state === "rework" || terminal.environment_failure || terminal.state === "review_preparation_failed" || terminal.recovery?.category === "repair") {
+			// Ordinary own-claim repair is a Parent handoff, not a new user gate.
+			const fresh = requireFreshProjection(await input.kernel.projectTask(input.root, child.task_id), child.task_id);
+			return executorHandoff(record, child.task_id, fresh, terminal);
 		} else {
 			// stopped | failed | blocked: park and stop.
 			const reason =
-				terminal.state === "stopped" ? "Kernel reported the child stopped"
-					: terminal.state === "rework" ? terminal.summary : terminal.reason;
+				terminal.state === "stopped" ? "Kernel reported the child stopped" : terminal.reason;
 			record.children = record.children.map((c) =>
 				c.task_id === child.task_id ? { ...c, state: "needs_human", reason } : c,
 			);

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

@@ -315,6 +315,17 @@ export interface BatchRunReport {
 	children: BatchChildRun[];
 	commits: string[];
 	reason: string | null;
+	/** Non-authoritative foreground implementation obligation, never persisted as readiness. */
+	handoff?: {
+		role: "executor";
+		task_id: string;
+		run_id: string | null;
+		record_revision: string;
+		next_obligation: import("../kernel/types").AssuranceObligation;
+	};
+	/** Safe observation only; never an execution-readiness certificate. */
+	recovery?: import("../assurance/coordinator").AssuranceRecovery;
+	diagnostics?: import("../assurance/qa").QaCheckDiagnostic[];
 	/** The single next action for the operator. */
 	next_action: string;
 	created_at: string;