immune-brain 5.2.0 → 5.5.1

package/plugins/immune-brain/.pi-extension/imm-canary-work.ts

@@ -28,6 +28,7 @@ import { Type } from "typebox";
 import { PLUGIN_VERSION } from "../runtime/plugin_version";
 import { findResumableBatchSlugForTask } from "../runtime/unattended/batch_preflight";
 import { executePiUnattendedBatch } from "./imm-unattended-batch";
+import { registerPiRunContinuation } from "./pi-run-continuation";
 import {
 } from "./pi-canary-verification";
 import {
@@ -102,10 +103,13 @@ import {
 import { inspectStorageLayout } from "../runtime/kernel/storage_paths";
 import { migrateLegacyLayout } from "../runtime/kernel/storage_layout_migration";
 import {
-	readTaskIntent,
-	parseTaskIntentV1,
+	assertScopeAdditionsAreFiles,
 	canonicalIntentHash,
+	parseProjectTaskIntent,
+	parseTaskIntentV1,
+	readTaskIntent,
 	type ReadTaskIntentResult,
+	withNextScope,
 } from "../runtime/kernel/intent";
 import { readBackendClaim, readTaskTombstone } from "../runtime/kernel/backend_claim";
 import {
@@ -121,8 +125,11 @@ import {
 } from "../runtime/kernel/canary_application";
 import { findingsDigestV2 } from "../runtime/kernel/reducer";
 import {
+	parseReworkChoice,
 	projectAssurance,
+	reworkExitLines,
 	type AssuranceProjectionResult,
+	type ReworkChoice,
 } from "../runtime/kernel/assurance_projection";
 import type { TaskRecord } from "../runtime/kernel/types";
 import type { RoleDelegationContext } from "../runtime/role_prompt_bridge";
@@ -131,7 +138,7 @@ import {
 	runGithubTrackerOperation,
 	type GithubTrackerResult,
 } from "../runtime/github_issue_tracker";
-import { reviewReworkFindings } from "../runtime/assurance/coordinator";
+import { projectTaskStatus, reviewReworkFindings, type StatusProjectionResult } from "../runtime/assurance/coordinator";
 import { laneWriteRefusal } from "../runtime/unattended/lane_workspace";
 import { activeTaskNotice } from "../runtime/assurance/active_task_notice";
 import {
@@ -355,7 +362,7 @@ export function piRunEntryRefusal(
 ): Extract<PhaseAdmission, { ok: false }> | null {
 	const sessionId = piSessionId(ctx);
 	const state = sessionId ? piPhaseEntries().get(sessionId) ?? NO_PHASE_ENTRY : null;
-	const admission = admitPhaseOperation({ kind: "tool", name: operation }, state, { activeClaim: false });
+	const admission = admitPhaseOperation({ kind: "tool", name: operation }, state);
 	return admission.ok ? null : admission;
 }
 
@@ -421,6 +428,10 @@ export default function (
 		return { action: "continue" } as const;
 	});
 
+	// Validate dispatch before the receipt observer records an Agent call.
+	const continuation = registerPiRunContinuation(pi, {
+		entry: (text, root) => recognizePhaseEntry(text, piAliasReader(root)),
+	});
 	pi.registerCommand("imm-tasks", {
 		handler: async (_args: string, ctx?: ExtensionContext) => {
 			if (!ctx || ctx.mode !== "tui") return;
@@ -658,12 +669,37 @@ export default function (
 					ctx,
 					taskId,
 					await enrichAssuranceResult(ctx, taskId, result as unknown as Record<string, unknown>),
+					(slug) => continuation.selectedParent(ctx.cwd, ctx.sessionManager.getSessionId(), slug),
 				);
 				presentTaskRailResult(ctx, taskId, enriched);
 				throwIfCanaryToolFailure(taskId, action.op, enriched);
 				return toolResult(JSON.stringify(enriched, null, 2), enriched);
 			}
-			const projection = await projectAssuranceForTask(ctx.cwd, taskId);
+			const requested = requestedScope(action as { op: string; next_intent?: unknown });
+			if (requested) {
+				// The directory rule is the compatible route's own refusal; it runs
+				// before the projection so a directory's files are not reported as
+				// unstaged scope changes instead (ADR 0021, D4).
+				let prior: ReadTaskIntentResult | null = null;
+				try {
+					prior = readTaskIntentForRecord(ctx.cwd, taskId);
+				} catch {
+					// An unreadable intent is the projection's diagnostic to report.
+				}
+				if (prior) {
+					try {
+						assertScopeAdditionsAreFiles(ctx.cwd, prior.intent.scope_hint, requested);
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						return failCanaryTool(taskId, action.op, "blocked", "scope_addition_is_directory", message, "name concrete files, or widen through approve_breaking_intent_revision");
+					}
+				}
+			}
+			// Status is a read: unstaged in-scope paths come back as a warning. Every
+			// other operation projects through the refusing delivery identity.
+			const projection: StatusProjectionResult = action.op === "status"
+				? await projectTaskStatus(ctx.cwd, taskId)
+				: await projectAssuranceForTask(ctx.cwd, taskId, requested);
 			if (projection.error) {
 				const nextAction = recoveryActionForAssuranceFailure(projection.error) ?? "inspect authority state";
 				const details = {
@@ -682,7 +718,8 @@ export default function (
 				const blockers = state.blocking_finding_ids.length
 					+ state.unresolved_user_decision_ids.length
 					+ state.replan_required_ids.length;
-				const status = { plugin_version: PLUGIN_VERSION, ...state };
+				const warnings = projection.warnings ?? [];
+				const status = { plugin_version: PLUGIN_VERSION, ...state, ...(warnings.length > 0 ? { warnings } : {}) };
 				const details = {
 					state: "status",
 					operation: "status",
@@ -690,7 +727,8 @@ export default function (
 					lifecycle: state.lifecycle,
 					artifact_state: state.artifact_state,
 					task_state: state,
-					result: `${fresh}/${total} acceptance items fresh; ${blockers} blocker${blockers === 1 ? "" : "s"}`,
+					...(warnings.length > 0 ? { warnings } : {}),
+					result: `${fresh}/${total} acceptance items fresh; ${blockers} blocker${blockers === 1 ? "" : "s"}${warnings.map((warning) => `; ${warning.message}`).join("")}`,
 					next_action: state.next_obligation,
 				};
 				presentTaskRailResult(ctx, taskId, details);
@@ -812,6 +850,7 @@ export default function (
 	type AuthorizationOutcome =
 		| { state: "applied"; operation: AuthorizeOperation; lifecycle?: string; delivery_error?: string }
 		| { state: "cancelled"; operation: AuthorizeOperation; reason: string }
+		| { state: "replan_selected"; operation: AuthorizeOperation; reason: string }
 		| { state: "blocked"; reason: string };
 
 	async function authorizeExactOperation(
@@ -826,7 +865,7 @@ export default function (
 		let nextIntentRef: { path: string; content_hash: string } | undefined;
 		if (operation === "approve-breaking-intent-revision") {
 			try {
-				nextIntent = await parseTaskIntentV1(nextIntentInput);
+				nextIntent = parseProjectTaskIntent(ctx.cwd, nextIntentInput);
 				if (nextIntent.task_id !== taskId)
 					throw new Error("next intent task_id must match the enrolled task");
 				nextIntentHash = await canonicalIntentHash(nextIntent);
@@ -849,7 +888,7 @@ export default function (
 			return { state: "blocked", reason };
 		}
 		try {
-		const projection = await projectAssuranceForTask(ctx.cwd, taskId);
+		const projection = await projectAssuranceForTask(ctx.cwd, taskId, nextIntent?.scope_hint);
 		if (projection.error || !projection.claim) {
 			const reason = projection.error ?? "no active backend claim";
 			notifyOnce(ctx, `authorization-claim:${taskId}:${reason}`, `cannot authorize ${taskId}: ${reason}`, "error");
@@ -880,7 +919,11 @@ export default function (
 				const stagedRecord = await readTaskRecordRaw(ctx.cwd, taskId);
 				if (!stagedRecord.record || stagedRecord.revision !== projection.projection.record_revision)
 					throw new Error("TaskRecord changed while preparing the breaking revision");
-				stagedNextDiffHash = taskDeliveryIdentity(ctx.cwd, stagedRecord.record).diff_hash;
+				// The revision is bound against the scope it asks for (ADR 0021, D6).
+				stagedNextDiffHash = taskDeliveryIdentity(
+					ctx.cwd,
+					withNextScope(stagedRecord.record, nextIntent.scope_hint),
+				).diff_hash;
 			} catch (error) {
 				let restoreError: unknown;
 				try { restoreStagedIntent(); } catch (err) { restoreError = err; }
@@ -907,6 +950,9 @@ export default function (
 				return { state: "blocked", reason };
 			}
 		}
+		// Only a replan boundary offers exits; both Hosts render the same ones.
+		const reworkExits = operation === "authorize-rework" ? projection.projection.authorization.exits : undefined;
+		let reworkChoice: ReworkChoice | undefined;
 		const dialogSummary = [
 			`Task: ${taskId}`,
 			`Decision: ${operation}`,
@@ -932,7 +978,10 @@ export default function (
 					]
 				: []),
 			...(operation === "authorize-rework"
-				? [`Replan boundaries: ${projection.projection.replan_required_ids.join(", ")}`]
+				? [
+						`Replan boundaries: ${projection.projection.replan_required_ids.join(", ")}`,
+						...(reworkExits ? reworkExitLines(reworkExits) : []),
+					]
 				: []),
 			...(nextIntent
 				? [
@@ -971,12 +1020,46 @@ export default function (
 				summary: dialogSummary,
 				details: dialogDetails,
 				signal: ctx.signal,
-				actions: [
-					{ value: "authorize", label: uxText(UX_LANG, "Authorize", "批准"), description: uxText(UX_LANG, `Apply ${operation} after re-checking state`, `重新校验状态后应用 ${operation}`) },
-					{ value: "cancel", label: uxText(UX_LANG, "Cancel", "取消"), description: uxText(UX_LANG, "Leave managed authority unchanged", "保持托管权限状态不变") },
-				],
+				actions: reworkExits
+					? [
+							{ value: "grant_rounds", label: uxText(UX_LANG, "Grant more Review rounds", "追加 Review 轮次"), description: uxText(UX_LANG, `Grant ${reworkExits.grant_rounds.min}-${reworkExits.grant_rounds.max} further rounds`, `追加 ${reworkExits.grant_rounds.min}-${reworkExits.grant_rounds.max} 轮`) },
+							...(reworkExits.accept_residual_risk
+								? [{ value: "accept_residual_risk", label: uxText(UX_LANG, "Accept residual risk", "接受残余风险"), description: uxText(UX_LANG, "Accept the open Review findings with a reason", "附理由接受未决 Review 发现") }]
+								: []),
+							{ value: "replan", label: uxText(UX_LANG, "Replan", "重新规划"), description: uxText(UX_LANG, "Revise the Intent instead", "改为修订 Intent") },
+							{ value: "cancel", label: uxText(UX_LANG, "Cancel", "取消"), description: uxText(UX_LANG, "Leave managed authority unchanged", "保持托管权限状态不变") },
+						]
+					: [
+							{ value: "authorize", label: uxText(UX_LANG, "Authorize", "批准"), description: uxText(UX_LANG, `Apply ${operation} after re-checking state`, `重新校验状态后应用 ${operation}`) },
+							{ value: "cancel", label: uxText(UX_LANG, "Cancel", "取消"), description: uxText(UX_LANG, "Leave managed authority unchanged", "保持托管权限状态不变") },
+						],
 			});
-			confirmed = selected === "authorize";
+			if (reworkExits) {
+				if (selected === "grant_rounds" || selected === "accept_residual_risk" || selected === "replan") {
+					const raw: Record<string, unknown> = { exit: selected };
+					if (selected === "grant_rounds") {
+						const text = await ctx.ui.input(
+							uxText(UX_LANG, `Further Review rounds (${reworkExits.grant_rounds.min}-${reworkExits.grant_rounds.max})`, `追加 Review 轮次(${reworkExits.grant_rounds.min}-${reworkExits.grant_rounds.max})`),
+							String(reworkExits.grant_rounds.min),
+							{ signal: ctx.signal },
+						);
+						if (text !== undefined && text.trim()) raw.rounds = Number(text.trim());
+						if (text === undefined) raw.exit = "cancelled";
+					} else if (selected === "accept_residual_risk") {
+						const text = await ctx.ui.input(uxText(UX_LANG, "Reason for accepting residual risk", "接受残余风险的理由"), "", { signal: ctx.signal });
+						if (text === undefined) raw.exit = "cancelled";
+						else raw.reason = text;
+					}
+					// The same parser the Claude Host uses, so the accepted shapes cannot drift.
+					reworkChoice = raw.exit === "cancelled" ? undefined : (parseReworkChoice(reworkExits, raw) ?? undefined);
+					confirmed = reworkChoice !== undefined;
+					if (raw.exit !== "cancelled" && !reworkChoice) {
+						notifyOnce(ctx, `authorization-exit:${taskId}`, `authorize ${operation}: the chosen exit was not valid; nothing applied`, "warning");
+					}
+				}
+			} else {
+				confirmed = selected === "authorize";
+			}
 		} catch (error) {
 			if (nextIntent) {
 				restoreStagedIntent();
@@ -1006,6 +1089,12 @@ export default function (
 			progression.closeInvocation(invocation);
 			return { state: "cancelled", operation, reason: "cancelled" };
 		}
+		// A replan is not a mutation of this operation: the Intent revision has
+		// its own gate, so nothing is written here.
+		if (reworkChoice?.exit === "replan") {
+			progression.closeInvocation(invocation);
+			return { state: "replan_selected", operation, reason: "revise the Intent, then authorize approve-breaking-intent-revision" };
+		}
 		if (!progression.sessionActiveValue() || progression.sessionGenerationValue() !== authorizationGeneration || progression.invocationState(invocation) !== "open") {
 			if (nextIntent) {
 				restoreStagedIntent();
@@ -1043,7 +1132,12 @@ export default function (
 							next_intent_ref: nextIntentRef!,
 						}
 					: operation === "authorize-rework"
-						? { op: "authorize_rework" as const }
+						? reworkChoice?.exit === "accept_residual_risk"
+							? { op: "accept_residual_risk" as const, reason: reworkChoice.reason }
+							: {
+									op: "authorize_rework" as const,
+									...(reworkChoice?.exit === "grant_rounds" ? { rounds: reworkChoice.rounds } : {}),
+								}
 						: userDecisionOperation!;
 				// The exact host-built operation is shared by capability digest and
 				// application payload; command arguments cannot inject authority fields.
@@ -1054,9 +1148,11 @@ export default function (
 					const liveRecord = nextIntent ? await readTaskRecordRaw(ctx.cwd, taskId) : null;
 					if (nextIntent && (!liveRecord?.record || liveRecord.revision !== projection.projection.record_revision || !stagedNextDiffHash))
 						throw new Error("TaskRecord changed before the breaking revision digest");
-					const operationDiffHash = liveRecord?.record
-						? taskDeliveryIdentity(ctx.cwd, liveRecord.record).diff_hash
-						: projection.projection.diff_hash;
+					const operationDiffHash = liveRecord?.record && nextIntent
+						? taskDeliveryIdentity(ctx.cwd, withNextScope(liveRecord.record, nextIntent.scope_hint)).diff_hash
+						: liveRecord?.record
+							? taskDeliveryIdentity(ctx.cwd, liveRecord.record).diff_hash
+							: projection.projection.diff_hash;
 					if (nextIntent && operationDiffHash !== stagedNextDiffHash)
 						throw new Error("staged next-state diff changed after native confirmation");
 					const capability = await mintCapability(registry, {
@@ -1075,7 +1171,8 @@ export default function (
 						...(exactOperation.op === "resolve_user_decision"
 							? { finding_id: exactOperation.finding_id, resolution: exactOperation.resolution }
 							: {}),
-						...(exactOperation.op === "stop" ? { reason: exactOperation.reason } : {}),
+						...(exactOperation.op === "stop" || exactOperation.op === "accept_residual_risk" ? { reason: exactOperation.reason } : {}),
+						...(exactOperation.op === "authorize_rework" && "rounds" in exactOperation ? { rounds: exactOperation.rounds } : {}),
 						now,
 					});
 					const result = (await app.execute({
@@ -1083,13 +1180,15 @@ export default function (
 						task_id: taskId,
 						operation: { ...exactOperation, capability, actor_id: LITERAL_USER_ACTOR_ID } as never,
 						prior_intent_token: priorIntent.token,
-						diffProvider: (root: string, record: TaskRecord) => diffSnapshotOf(root, record),
+						diffProvider: (root: string, record: TaskRecord) =>
+							diffSnapshotOf(root, nextIntent ? withNextScope(record, nextIntent.scope_hint) : record),
 						now,
 					})) as unknown as { record: { lifecycle: string; artifact_state: string; intent_ref: { path: string }; intent_snapshot: { scope_hint: string[] } } };
 					if (exactOperation.op === "stop") progression.releaseStoppedReview(taskId);
 					if (
 						exactOperation.op === "stop" ||
 						exactOperation.op === "authorize_rework" ||
+						exactOperation.op === "accept_residual_risk" ||
 						exactOperation.op === "approve_breaking_intent_revision"
 					) stagePlanningArtifactTransition(ctx.cwd, result.record);
 					return { state: "applied", operation, lifecycle: result.record.lifecycle };
@@ -1241,8 +1340,8 @@ export function buildUserDecisionOperation(record: {
  * as the Claude adapter's `readTaskIntentForRecord`.
  */
 export function readTaskIntentForRecord(root: string, taskId: string): ReadTaskIntentResult {
-	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);
 }
 
 /**
@@ -1343,8 +1442,34 @@ function overviewRailState(lifecycle: string, obligation: string): TaskRailState
 	return "Working";
 }
 
-export async function projectAssuranceForTask(root: string, taskId: string): Promise<AssuranceProjectionResult> {
-	return projectAssurance(root, taskId);
+export async function projectAssuranceForTask(
+	root: string,
+	taskId: string,
+	nextScope?: readonly string[],
+): Promise<AssuranceProjectionResult> {
+	// A scope revision is projected against the scope it asks for (ADR 0021, D6).
+	return projectAssurance(
+		root,
+		taskId,
+		nextScope
+			? (rootDir: string, record: TaskRecord) => diffSnapshotOf(rootDir, withNextScope(record, nextScope))
+			: undefined,
+	);
+}
+
+/**
+ * The canonical scope a `revise_intent` payload asks for. It goes through the
+ * Intent parser so entries it would fold away (covered by a directory) match the
+ * scope the Kernel later records; a payload the parser rejects is reported by
+ * the revision path itself, not here.
+ */
+function requestedScope(action: { op: string; next_intent?: unknown }): string[] | undefined {
+	if (action.op !== "revise_intent") return undefined;
+	try {
+		return parseTaskIntentV1(action.next_intent).scope_hint;
+	} catch {
+		return undefined;
+	}
 }
 
 /**
@@ -1418,6 +1543,7 @@ async function mintCapability(
 		next_intent?: unknown;
 		next_intent_ref?: unknown;
 		reason?: string;
+		rounds?: number;
 		finding_id?: string;
 		resolution?: string;
 		now: string;
@@ -1433,6 +1559,7 @@ async function mintCapability(
 		at: 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 } : {}),
@@ -1480,9 +1607,13 @@ async function executeOrdinaryOperation(
 ): Promise<unknown> {
 	const { app } = await authorityPair();
 	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
@@ -1503,7 +1634,8 @@ async function executeOrdinaryOperation(
 			task_id: input.taskId,
 			operation: operation as never,
 			prior_intent_token: priorIntent.token,
-			diffProvider: (root: string, record: TaskRecord) => diffSnapshotOf(root, record),
+			diffProvider: (root: string, record: TaskRecord) =>
+				diffSnapshotOf(root, nextScope ? withNextScope(record, nextScope) : record),
 			now: new Date().toISOString(),
 		});
 		if (operation.op === "freeze_artifacts" || operation.op === "stop")
@@ -1548,6 +1680,7 @@ async function closeOutBatchChild(
 	ctx: ExtensionContext,
 	taskId: string,
 	enriched: Record<string, unknown>,
+	selectedParent: (slug: string) => boolean,
 ): Promise<Record<string, unknown>> {
 	const taskState = enriched.task_state as { lifecycle?: unknown } | undefined;
 	if (taskState?.lifecycle !== "done") return enriched;
@@ -1559,6 +1692,7 @@ async function closeOutBatchChild(
 	}
 	if (!slug) return enriched;
 	try {
+		if (!selectedParent(slug)) return enriched;
 		// The batch commit takes exactly the scope envelope plus this task's own
 		// audit evidence and refuses unstaged changes: stage only that evidence.
 		if (existsSync(join(ctx.cwd, ".imm", "audit", taskId)))
@@ -1735,6 +1869,7 @@ function throwIfCanaryToolFailure(
 		// Preserve only the coordinator's bounded observation metadata.
 		{
 			...(details.diagnostics ? { diagnostics: details.diagnostics } : {}),
+			...(details.prepare_observation ? { prepare_observation: details.prepare_observation } : {}),
 			...(details.environment_failure ? { environment_failure: true } : {}),
 			...(details.recovery ? { recovery: details.recovery } : {}),
 			...(details.recovery_error ? { recovery_error: details.recovery_error } : {}),

package/plugins/immune-brain/.pi-extension/imm-unattended-batch.ts

@@ -12,12 +12,16 @@ import {
 } from "../runtime/kernel/batch_authority";
 import { createEnrollmentAuthorityRegistry } from "../runtime/kernel/enrollment_authority";
 import {
-	startBatch,
+	startBatch, completedParentReport,
 	type BatchRunnerKernelPort,
 	type BatchRunReport,
 	type BatchTrackerPort,
 } from "../runtime/unattended/batch_runner";
 import { createBatchKernelPort } from "../runtime/unattended/batch_kernel_port";
+import { observeInitiative } from "../runtime/unattended/batch_plan";
+import { integrateSettledCriticalSlices, advanceNativeParent } from "../runtime/unattended/batch_git";
+import { parseDeliveryConsolidation, type DeliveryConsolidation } from "../runtime/unattended/parent_delivery_consolidation";
+
 import type { BatchRunnerGitPort } from "../runtime/unattended/batch_git";
 import type { InitiativeObservationReader } from "../runtime/unattended/types";
 import { advancePiTask, piRunEntryRefusal } from "./imm-canary-work";
@@ -27,7 +31,7 @@ import { parseLaneRevision, REVISION_DELEGATION_TEXT, type LaneRevisionRequest }
 import { createBatchTrackerPort, laneRuntimeContractRefusal, parseLaneInstruction, type LaneInstructionRequest, parseLaneOffers, parseMaxParallel, resolveLaneParallel, type LaneOffer } from "../runtime/unattended/batch_lanes";
 import {
 	authorizeBatch,
-	projectBatchPreflight,
+	prepareBatchPreflight,
 } from "../runtime/unattended/batch_preflight";
 import { retireStaleBatch, type StaleBatchFacts } from "../runtime/unattended/batch_disposition";
 import type { BatchLaneRunReport } from "../runtime/unattended/batch_state";
@@ -113,6 +117,7 @@ export interface PiBatchExecutionOptions {
 	lane_offers?: LaneOffer[];
 	/** Lane mode: the project's full verification commands, run once every child is integrated. */
 	final_verification?: string[];
+	delivery_consolidation?: DeliveryConsolidation;
 	/** Lane mode: one instruction for an idle Lane session, recorded before it is sent. */
 	lane_instruction?: LaneInstructionRequest;
 	/** Lane mode, ADR 0018: one breaking Intent revision the coordinator approves under the batch's grant. */
@@ -134,6 +139,7 @@ export interface PiBatchExecutionOptions {
 }
 
 export type PiBatchExecutionResult =
+	| NonNullable<Awaited<ReturnType<typeof advanceNativeParent>>>
 	| { state: "started"; batch_id: string; report: BatchRunReport }
 	| { state: "rejected"; reason: string; recovery_action: string }
 	| { state: "cancelled"; reason: string; recovery_action: string }
@@ -154,13 +160,56 @@ function piConfirmationRef(input: {
 
 export async function executePiUnattendedBatch(
 	options: PiBatchExecutionOptions,
+): Promise<PiBatchExecutionResult> {
+	let commit: string | undefined;
+	try {
+		const result = await executePreparedPiBatch(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;
+	}
+}
+
+async function executePreparedPiBatch(
+	options: PiBatchExecutionOptions, onCommit: (commit: string | undefined) => void,
 ): Promise<PiBatchExecutionResult> {
 	const { root, initiativeSlug, signal } = options;
 	const reuseOnly = options.reuseOnly === true;
 	const interactive = options.interactive ?? true;
+	const consolidation = parseDeliveryConsolidation(options.delivery_consolidation);
 
 	if (!reuseOnly && !interactive) return { state: "rejected", ...nonInteractiveRefusal() };
-
+	if (!reuseOnly && !options.confirmBatch) return batchReason("confirmation_port_unavailable");
+
+	await integrateSettledCriticalSlices(root, initiativeSlug, options.readInitiative);
+	const completed = await completedParentReport(root, initiativeSlug, options.readInitiative, options.batchTracker);
+	if (completed) return { state: "started", batch_id: completed.batch_id, report: completed };
+	const native = await advanceNativeParent(root, initiativeSlug, options.final_verification, options.readInitiative, options.batchTracker ?? createBatchTrackerPort(root, initiativeSlug),
+		async (effects) => {
+			// A continuation never opens a gate; unconfirmed commands wait for a fresh explicit entry.
+			if (reuseOnly || !options.confirmBatch) return batchReason("confirmation_port_unavailable");
+			let decision: "accept" | "accept_delegate" | "decline" | "cancel";
+			try {
+				decision = await options.confirmBatch({
+					title: `Authorize Parent Final Verification: ${effects.initiative_slug}`,
+					summary: `Initiative: ${effects.initiative_slug}\nPlan digest: ${effects.plan_digest}\nNo batch run is started.\nFinal verification commands run in this workspace outside Host permission:\n${effects.final_commands.map((command) => `  - ${command}`).join("\n")}`,
+					details: `Parent Tasks (${effects.children.length}):\n${effects.children.map((child) => `  - ${child.task_id} (${child.slice_id})`).join("\n")}${effects.integrate_task_ids.length > 0 ? `\n\nSettled deliveries committed first (${effects.integrate_task_ids.length}):\n${effects.integrate_task_ids.map((id) => `  - ${id}`).join("\n")}` : ""}`,
+					planDigest: effects.plan_digest,
+					...(effects.delivery_consolidation ? { details: JSON.stringify(effects, null, 2) } : {}),
+					signal,
+				});
+			} catch (err) {
+				if (signal?.aborted) return batchReason("confirmation_cancelled");
+				return batchReason("confirmation_failed", err instanceof Error ? err.message : String(err));
+			}
+			if (decision === "cancel" || signal?.aborted) return batchReason("confirmation_cancelled");
+			if (decision === "decline") return batchReason("confirmation_declined");
+			if (decision !== "accept") return batchReason("confirmation_no_decision");
+			return null;
+		}, consolidation);
+	if (native) return native;
 	// A lane_offers-only call resumes the recorded lane batch; refused before any gate otherwise.
 	const resolvedParallel = resolveLaneParallel(root, initiativeSlug, options.max_parallel, options.lane_offers, options.lane_instruction ?? options.lane_revision);
 	if (resolvedParallel !== undefined) options = { ...options, max_parallel: resolvedParallel };
@@ -170,12 +219,14 @@ export async function executePiUnattendedBatch(
 	// 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,
 		initiative_slug: initiativeSlug,
 		now,
 		readInitiative: options.readInitiative,
+		signal, reuseOnly,
 	});
+	onCommit(preflight.precondition_commit);
 	if (!preflight.ok) {
 		return { state: preflight.state, reason: preflight.reason, recovery_action: preflight.recovery_action };
 	}
@@ -218,7 +269,7 @@ export async function executePiUnattendedBatch(
 			}
 			const confirmDetails = {
 				title: `Authorize Unattended Batch: ${facts.initiative_slug}`,
-				summary: `Initiative: ${facts.initiative_slug}\nBatch branch: ${facts.batch_branch}\nPlan digest: ${facts.plan_digest}\nBudget: max_children=${facts.budget.max_children}, qa_failure_limit=${facts.budget.qa_failure_limit}${options.max_parallel !== undefined ? `\nLane mode: max_parallel=${options.max_parallel}` : ""}${options.max_parallel !== undefined && options.final_verification ? `\nFinal verification: ${options.final_verification.join("; ")}` : ""}`,
+				summary: `Initiative: ${facts.initiative_slug}\nBatch branch: ${facts.batch_branch}\nPlan digest: ${facts.plan_digest}\nBudget: max_children=${facts.budget.max_children}, qa_failure_limit=${facts.budget.qa_failure_limit}${options.max_parallel !== undefined ? `\nLane mode: max_parallel=${options.max_parallel}` : ""}${options.final_verification ? `\nFinal verification: ${options.final_verification.join("; ")}` : ""}`,
 				details: `Ordered children (${facts.children.length}):\n${facts.children.map((child) => `  - ${child.task_id} (${child.slice_id}) [risk: ${child.risk}] [status: ${child.status === "already_settled" ? "completed" : "pending execution"}]`).join("\n")}${facts.excluded.length > 0 ? `\n\nExcluded children:\n${facts.excluded.map((child) => `  - ${child.task_id} (${child.slice_id}): ${child.reason}`).join("\n")}` : ""}${options.max_parallel !== undefined ? `\n\nParallel groups (${facts.parallel_groups.length}):\n${facts.parallel_groups.map((group) => `  - ${group.join(", ")}`).join("\n")}${facts.scope_conflicts.length > 0 ? `\n\nSerialized by overlapping scope:\n${facts.scope_conflicts.map((c) => `  - ${c.task_id} after ${c.overlaps_with.join(", ")}`).join("\n")}` : ""}` : ""}${facts.reuse_blockers.length > 0 ? `\n\nRe-confirmation required: ${facts.reuse_blockers.join(", ")}.\nRecovery: confirm to issue a fresh authorization bound to the current plan and HEAD.` : ""}`,
 				planDigest: facts.plan_digest,
 				signal,
@@ -294,6 +345,7 @@ export async function executePiUnattendedBatch(
 	// this Host supplies only its own advanceTask progression seam (D5).
 	const kernelPort = createBatchKernelPort({
 		root,
+		parent: await (options.readInitiative ?? observeInitiative)(root, initiativeSlug),
 		enrollmentRegistry,
 		registry: batchRegistry,
 		capability,
@@ -303,7 +355,7 @@ export async function executePiUnattendedBatch(
 		overrides: otherOverrides,
 	});
 
-	const report = await startBatch({
+	let report = await startBatch({
 		root,
 		batch_id: batchId,
 		initiative_slug: initiativeSlug,
@@ -317,11 +369,11 @@ export async function executePiUnattendedBatch(
 		now,
 		kernel: kernelPort,
 		git: options.batchGit,
+		...(options.final_verification ? { final_verification: options.final_verification } : {}),
 		...(options.max_parallel !== undefined
 			? {
 					max_parallel: options.max_parallel,
 					tracker: options.batchTracker ?? createBatchTrackerPort(root, 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 } : {}),
@@ -334,6 +386,8 @@ export async function executePiUnattendedBatch(
 		return batchReason("batch_run_rejected", report.reason ?? "");
 	}
 
+	if (report.batch_state === "completed" && report.final_verification?.passed)
+		report = await completedParentReport(root, initiativeSlug, options.readInitiative, options.batchTracker) ?? report;
 	return {
 		state: "started",
 		batch_id: batchId,
@@ -362,7 +416,7 @@ function retireConfirmationDetails(facts: StaleBatchFacts): {
 		details: `Children (${facts.children.length}):\n${facts.children
 			.map(
 				(child) =>
-					`  - ${child.task_id} (${child.slice_id}) [state: ${child.state}]${child.commit ? ` [commit: ${child.commit}]` : " [no commit]"}${child.lane_branch ? ` [lane: ${child.lane_branch}]` : ""}`,
+					`  - ${child.task_id} (${child.slice_id}) [state: ${child.state}]${child.commit ? ` [commit: ${child.commit}]` : " [no commit]"}${child.lane_branch ? ` [lane: ${child.lane_branch}]` : ""}${child.kernel_lifecycle ? ` [Kernel run: ${child.kernel_lifecycle}]` : ""}`,
 			)
 			.join("\n")}\n\nRetiring writes this record to the terminal superseded state. Child states, recorded commits and the batch branch are preserved as evidence; nothing is deleted and no batch trailer or approval is manufactured.\n\nA child without a commit was never executed by this batch: it carries no delivery evidence, and the retired authorization is never reused for a revised plan.\n\nAfter retiring, run each remaining child with imm-run under its own authorization, or start a new batch for this Initiative.`,
 	};
@@ -437,6 +491,11 @@ export default function (
 			lane_offers: Type.Optional(Type.Array(
 				Type.Object({ task_id: Type.String(), path: Type.String() }, { additionalProperties: false }),
 			)),
+			delivery_consolidation: Type.Optional(Type.Object({
+				task_id: Type.String(), run_id: Type.String(), source_runs: Type.Array(Type.Object({
+					task_id: Type.String(), run_id: Type.String(),
+				}, { additionalProperties: false }), { minItems: 1, maxItems: 16 }),
+			}, { additionalProperties: false })),
 			final_verification: Type.Optional(Type.Array(Type.String(), { minItems: 1, maxItems: 8 })),
 			lane_instruction: Type.Optional(Type.Object({
 				task_id: Type.String(),
@@ -451,7 +510,7 @@ export default function (
 		}, { additionalProperties: false }),
 		execute: async (
 			_toolCallId: string,
-			params: { initiative_slug: string; max_parallel?: number; lane_offers?: Array<{ task_id: string; path: string }>; final_verification?: string[]; lane_instruction?: unknown; lane_revision?: unknown },
+			params: { initiative_slug: string; max_parallel?: number; lane_offers?: Array<{ task_id: string; path: string }>; final_verification?: string[]; delivery_consolidation?: unknown; lane_instruction?: unknown; lane_revision?: unknown },
 			signal: AbortSignal | undefined,
 			_onUpdate: unknown,
 			ctx: ExtensionContext,
@@ -486,6 +545,7 @@ export default function (
 			const maxParallel = parseMaxParallel(params.max_parallel);
 			const laneOffers = parseLaneOffers(params.lane_offers);
 			const finalVerification = parseFinalVerification(params.final_verification);
+			const deliveryConsolidation = parseDeliveryConsolidation(params.delivery_consolidation);
 			const laneInstruction = parseLaneInstruction(params.lane_instruction);
 			const laneRevision = parseLaneRevision(params.lane_revision);
 
@@ -495,6 +555,7 @@ export default function (
 				...(maxParallel !== undefined ? { max_parallel: maxParallel } : {}),
 				...(laneOffers !== undefined ? { lane_offers: laneOffers } : {}),
 				...(finalVerification !== undefined ? { final_verification: finalVerification } : {}),
+				...(deliveryConsolidation !== undefined ? { delivery_consolidation: deliveryConsolidation } : {}),
 				...(laneInstruction !== undefined ? { lane_instruction: laneInstruction } : {}),
 				...(laneRevision !== undefined ? { lane_revision: laneRevision } : {}),
 				interactive: ctx.mode === "tui",
@@ -537,7 +598,7 @@ export default function (
 				},
 			});
 
-			if (result.state !== "started") {
+			if (result.state !== "started" && result.state !== "native_parent") {
 				const failureState = result.state === "blocked" ? "blocked" : "failed";
 				throwToolFailure({
 					tool: "imm_canary_enrollment",

package/plugins/immune-brain/.pi-extension/pi-canary-tool-failure.ts

@@ -1,7 +1,7 @@
 import type { AssuranceAdvanceResult } from "../runtime/assurance/coordinator";
 
 export type AssuranceFailureDetails = Pick<AssuranceAdvanceResult,
-	"diagnostics" | "environment_failure" | "recovery" | "recovery_error">;
+	"diagnostics" | "prepare_observation" | "environment_failure" | "recovery" | "recovery_error">;
 
 export interface ToolFailureV1 extends AssuranceFailureDetails {
 	contract: "immune_brain/tool_failure/v1";