immune-brain 4.5.0 → 5.0.0

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

@@ -1,3 +1,7 @@
+import { buildAssuranceSnapshot, stagePlanningArtifactTransition } from "../runtime/assurance/verdict_authority";
+export { buildSnapshot, ensureReviewRevision as ensureTaskReviewRevision } from "../runtime/assurance/verdict_authority";
+export type { SnapshotDescriptorInput } from "../runtime/assurance/verdict_authority";
+import type { ConfirmationReferenceSource } from "../runtime/assurance/host_port";
 // P3 Pi lifecycle extension: the only production route for Kernel canary
 // assurance after enrollment.
 //
@@ -21,19 +25,14 @@ import { join, resolve } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 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 {
-	parseVerificationDescriptor,
-	type VerificationDescriptor,
 } from "./pi-canary-verification";
 import {
-	captureReviewBundle,
-	captureReviewManifest,
 	listReviewRefs,
 	reconcileReviewRefs,
 	writeNativeReviewEvidence,
-	type ReviewBundle,
-	type ReviewManifestV5,
-	type ReviewRevision,
 } from "./pi-canary-review-bundle";
 import type { InvocationToken } from "./pi-canary-invocations";
 import { runDeterministicQa } from "../runtime/assurance/qa";
@@ -44,7 +43,6 @@ import {
 import {
 	renderCanaryCall,
 	renderCanaryResult,
-	type AssuranceRole,
 } from "./pi-canary-assurance";
 import {
 	USER_ATTENTION_EVENT,
@@ -69,8 +67,7 @@ import { resolveUxLanguage, uxText } from "./ux-language";
 
 /** Host-native UI language; see ux-language.ts. Resolved once per process. */
 const UX_LANG = resolveUxLanguage();
-import { taskDiffIdentity, taskRevisionIdentity, captureGitTaskSnapshot } from "../runtime/workspace_scope";
-import { reviewAdvisoryRecords, reviewReworkFindings } from "../runtime/assurance/coordinator";
+import { taskDeliveryIdentity } from "../runtime/workspace_scope";
 import {
 	AssuranceProgression,
 	buildReviewPrompt,
@@ -85,44 +82,54 @@ import {
 	REVIEW_TIMING_PROFILES,
 	REVIEW_VERDICT_VALIDATION_TIMEOUT_MS,
 	type AssuranceProgressionPorts,
-	type AssuranceVerdict,
 	type HostContext,
-	type SnapshotDescriptor,
 } from "./pi-canary-assurance-progression";
 
-// The Kernel runtime graph is never type-checked from this extension: static
-// imports resolve to ./runtime-stub.ts (relative so the Pi extension loader
-// can resolve them at runtime), and the stub forwards to the real Kernel
-// modules via dynamic import.
+// The Pi adapter imports the host-neutral runtime modules statically, exactly
+// as the Claude adapter does; the retired dynamic-import isolation layer is
+// gone. The adapter-owned logic that used to live behind it (the
+// record-aware intent read, the tracker terminal wrapper, the shared batch
+// progression accessors) is defined below, next to the machinery it uses.
+import { LITERAL_USER_ACTOR_ID } from "../runtime/kernel/actor_identity";
 import {
-	createMutationAuthorityRegistry,
-	createCanaryApplication,
-	buildLoopAction,
-	buildLoopRoleDispatch,
-	readBackendClaim,
-	readTaskTombstone,
-	markGithubTaskTerminal,
 	reconcileKernelAuthority,
 	repairKernelAuthority,
-	readTaskRecord,
+	readTaskRecordRaw,
 	withKernelStoreLockForTask,
-	inspectStorageLayout,
-	migrateLegacyLayout,
+} from "../runtime/kernel/storage";
+import { inspectStorageLayout } from "../runtime/kernel/storage_paths";
+import { migrateLegacyLayout } from "../runtime/kernel/storage_layout_migration";
+import {
 	readTaskIntent,
 	parseTaskIntentV1,
 	canonicalIntentHash,
-	projectAssurance,
-	findingsDigestV2,
-	capabilityActionFor,
+	type ReadTaskIntentResult,
+} from "../runtime/kernel/intent";
+import { readBackendClaim, readTaskTombstone } from "../runtime/kernel/backend_claim";
+import {
+	createMutationAuthorityRegistry,
 	digestOfAction,
-	type AssuranceProjectionResult,
-	type TaskRecordRead,
-	type CanaryApplication,
-	type MutationAuthorityRegistry,
 	type CapabilityBindingV2,
-	LITERAL_USER_ACTOR_ID,
-} from "./runtime-stub";
-import { invocationRegistry } from "./pi-canary-assurance-progression";
+	type MutationAuthorityRegistry,
+} from "../runtime/kernel/authority_port";
+import {
+	createCanaryApplication,
+	capabilityActionFor,
+	type CanaryApplication,
+} from "../runtime/kernel/canary_application";
+import { findingsDigestV2 } from "../runtime/kernel/reducer";
+import {
+	projectAssurance,
+	type AssuranceProjectionResult,
+} from "../runtime/kernel/assurance_projection";
+import type { TaskRecord } from "../runtime/kernel/types";
+import type { RoleDelegationContext } from "../runtime/role_prompt_bridge";
+import { buildLoopAction, buildLoopRoleDispatch } from "../runtime/loop_contract";
+import {
+	runGithubTrackerOperation,
+	type GithubTrackerResult,
+} from "../runtime/github_issue_tracker";
+import { reviewReworkFindings } from "../runtime/assurance/coordinator";
 
 const LOOP_OWNERS = ["plan", "kernel", "brainstorm", "planner", "loop"] as const;
 const LOOP_TARGETS = [
@@ -176,60 +183,6 @@ export type AuthorizeOperation =
 	| "authorize-rework"
 	| "stop";
 
-export interface SnapshotDescriptorInput {
-	root: string;
-	task_id: string;
-	role: AssuranceRole;
-	run_id?: string | null;
-	record_revision: string;
-	workspace_revision: string;
-	intent_revision: number;
-	intent_content_hash: string;
-	diff_hash: string;
-	lifecycle: string;
-	artifact_state: string;
-	risk?: "routine" | "material" | "critical";
-	fresh_acceptance_ids: string[];
-	missing_acceptance_ids: string[];
-	stale_attestation_ids: string[];
-	acceptance: Array<{ id: string; assertion: string; verification: string }>;
-	dirty_files?: string[];
-	review_bundle_digest?: string | null;
-	/** Present only when Review authority binds an immutable Git revision (v4). */
-	review_revision?: {
-		contract: "assurance_kernel/review_revision_identity/v1";
-		base_head: string;
-		review_commit: string;
-		review_tree: string;
-		manifest_digest: string;
-	};
-}
-
-export function buildSnapshot(input: SnapshotDescriptorInput): SnapshotDescriptor {
-	return {
-		contract: "assurance_kernel/assurance_snapshot/v2",
-		task_id: input.task_id,
-		run_id: input.run_id ?? null,
-		role: input.role,
-		record_revision: input.record_revision,
-		workspace_revision: input.workspace_revision,
-		intent_revision: input.intent_revision,
-		intent_content_hash: input.intent_content_hash,
-		diff_hash: input.diff_hash,
-		lifecycle: input.lifecycle,
-		artifact_state: input.artifact_state,
-		risk: input.risk ?? "material",
-		fresh_acceptance_ids: input.fresh_acceptance_ids,
-		missing_acceptance_ids: input.missing_acceptance_ids,
-		stale_attestation_ids: input.stale_attestation_ids,
-		acceptance: input.acceptance,
-		dirty_files: [...(input.dirty_files ?? [])].sort(),
-		review_bundle_digest: input.review_bundle_digest ?? null,
-		...(input.review_revision ? { review_revision: input.review_revision } : {}),
-		root: resolve(input.root),
-	};
-}
-
 export interface CanaryWorkExtensionDependencies {
 	buildAssurance?: typeof buildAssuranceSnapshot;
 	runQa?: typeof runDeterministicQa;
@@ -275,25 +228,15 @@ export function createPiAssuranceProgressionPorts(
 	dependencies: CanaryWorkExtensionDependencies = {},
 ): AssuranceProgressionPorts {
 	return {
-		projectTask: (root, taskId) => projectAssuranceState(root, taskId),
-		readTaskRecord: (root, taskId) => readTaskRecord(root, taskId),
-		readTaskIntent: (root, taskId) => readTaskIntent(root, taskId),
-		buildAssurance: (root, taskId, role, projection) =>
-			(dependencies.buildAssurance ?? buildAssuranceSnapshot)(root, taskId, role, projection),
-		ensureReviewRevision: (root, taskId, projection) => ensureTaskReviewRevision(root, taskId, projection),
+		confirmationReference: piConfirmationReference,
+		onReworkApplied: (ctx, taskId, count) => notifyHost(ctx, `rework-parked:${taskId}`, `rework applied: review parked for replan with ${count} finding(s)`, "warning"),
+		projectTask: (root, taskId) => projectAssuranceForTask(root, taskId),
+		readTaskRecord: async (root, taskId) => readTaskRecordRaw(root, taskId),
+		readTaskIntent: async (root, taskId) => readTaskIntentForRecord(root, taskId),
 		runQa: (snapshot, descriptors, options) =>
 			(dependencies.runQa ?? runDeterministicQa)(snapshot, descriptors, options),
 		writeReviewEvidence: (input) =>
 			(dependencies.writeReviewEvidence ?? writeNativeReviewEvidence)(input),
-		applyVerdict: (ctx, input) =>
-			applyAssuranceVerdict(
-				ctx,
-				input.snapshot,
-				input.verdict,
-				input.invocation,
-				input.actorId,
-				input.hooks,
-			),
 		applyOrdinaryOperation: (ctx, input) => executeOrdinaryOperation(ctx, input),
 		advanceBeforeProjection: dependencies.advanceBeforeProjection,
 		qaBeforeProjection: dependencies.qaBeforeProjection,
@@ -301,11 +244,46 @@ export function createPiAssuranceProgressionPorts(
 		qaOnAuthorityCommit: dependencies.qaOnAuthorityCommit,
 		qaAfterAuthorityCommit: dependencies.qaAfterAuthorityCommit,
 		qaJobTimeoutMs: dependencies.qaJobTimeoutMs,
+		...(dependencies.buildAssurance ? { authorityOverrides: { buildAssurance: dependencies.buildAssurance } } : {}),
 	} satisfies AssuranceProgressionPorts;
 }
 
 const GLOBAL_PI_PROGRESSION_KEY = Symbol.for("immune_brain.pi_assurance_progression");
 
+/**
+ * The shared session progression the batch adapter advances children through.
+ * The work extension publishes the instance at load; this accessor is the
+ * lazy fallback that builds one from the production ports when no extension
+ * factory has run (tests, direct batch drives). Both paths publish under the
+ * same global key, so a batch Review reservation and the session's
+ * submit_review always share one progression instance.
+ */
+export async function getSharedPiProgression(): Promise<AssuranceProgression> {
+	let progression = (globalThis as any)[GLOBAL_PI_PROGRESSION_KEY] as AssuranceProgression | undefined;
+	if (!progression) {
+		progression = new AssuranceProgression(createPiAssuranceProgressionPorts());
+		(globalThis as any)[GLOBAL_PI_PROGRESSION_KEY] = progression;
+	}
+	return progression;
+}
+
+/**
+ * Advance one task through the shared session progression and translate the
+ * progression result into the batch runner's advance report shape.
+ */
+export async function advancePiTask(root: string, taskId: string): Promise<any> {
+	const progression = await getSharedPiProgression();
+	const result = await progression.advance(taskId, { cwd: root });
+	const facts = { diagnostics: result.diagnostics, environment_failure: result.environment_failure, recovery: result.recovery };
+	if (result.state === "completed") return { state: "completed", ...facts };
+	if (result.state === "stopped") return { state: "stopped", ...facts };
+	if (result.state === "rework") return { state: "rework", operation: result.operation, summary: result.summary, ...facts };
+	if (result.state === "review_ready") return { state: "review_ready", operation_id: result.operation_id, agent_params: result.agent_params, ...facts };
+	if (result.state === "review_preparation_failed") return { state: result.state, operation: result.operation, operation_id: result.operation_id, reason: result.reason, ...facts };
+	if (result.state === "blocked") return { state: "blocked", reason: result.reason, ...facts };
+	return { state: "failed", reason: (result as { reason?: string }).reason ?? "advance failed", ...facts };
+}
+
 export default function (
 	pi: ExtensionAPI,
 	dependencies: CanaryWorkExtensionDependencies = {},
@@ -321,7 +299,7 @@ export default function (
 		try {
 			const claim = await readBackendClaim(ctx.cwd);
 			if (!claim) return;
-			const projection = await projectAssuranceState(ctx.cwd, claim.task_id);
+			const projection = await projectAssuranceForTask(ctx.cwd, claim.task_id);
 			if (projection.error) {
 				presentTaskRail(ctx, {
 					task_id: claim.task_id,
@@ -581,12 +559,16 @@ export default function (
 							: action.op === "request_stop"
 								? await authorizeExactOperation(taskId, "stop", { ...ctx, signal: signal && ctx.signal ? AbortSignal.any([signal, ctx.signal]) : signal ?? ctx.signal })
 								: await requestAuthorization(taskId, ctx);
-				const enriched = await enrichAssuranceResult(ctx, taskId, result as unknown as Record<string, unknown>);
+				const enriched = await closeOutBatchChild(
+					ctx,
+					taskId,
+					await enrichAssuranceResult(ctx, taskId, result as unknown as Record<string, unknown>),
+				);
 				presentTaskRailResult(ctx, taskId, enriched);
 				throwIfCanaryToolFailure(taskId, action.op, enriched);
 				return toolResult(JSON.stringify(enriched, null, 2), enriched);
 			}
-			const projection = await projectAssuranceState(ctx.cwd, taskId);
+			const projection = await projectAssuranceForTask(ctx.cwd, taskId);
 			if (projection.error) {
 				const nextAction = recoveryActionForAssuranceFailure(projection.error) ?? "inspect authority state";
 				const details = {
@@ -628,7 +610,7 @@ export default function (
 					taskId,
 					operation: toCanaryOperation(action, "executor") as { op: string; actor_id: string },
 				})) as unknown as { revision: string; record: { lifecycle: string; artifact_state: string } };
-				const updated = await projectAssuranceState(ctx.cwd, taskId);
+				const updated = await projectAssuranceForTask(ctx.cwd, taskId);
 				const taskState = updated.error
 					? { lifecycle: result.record.lifecycle, artifact_state: result.record.artifact_state }
 					: updated.projection;
@@ -704,15 +686,18 @@ export default function (
 			_ctx: ExtensionContext,
 		) => {
 			const { action } = params;
+			// The Tool schema is intentionally broader than loop_contract's input
+			// types (model-supplied JSON); loop_contract narrows and validates at
+			// runtime, so these boundary casts are type-level only.
 			const result = action.op === "route"
 				? await buildLoopAction({
 					ownership: action.ownership,
 					target: action.target,
-					context: action.context,
+					context: action.context as RoleDelegationContext | undefined,
 					scope_expansion: action.scope_expansion,
-					kernel_operation: action.kernel_operation,
+					kernel_operation: action.kernel_operation as Parameters<typeof buildLoopAction>[0]["kernel_operation"],
 				})
-				: await buildLoopRoleDispatch({ role: action.role, context: action.context });
+				: await buildLoopRoleDispatch({ role: action.role, context: action.context as RoleDelegationContext });
 			const details = loopResultDetails(result, action.op);
 			return toolResult(JSON.stringify(result, null, 2), details);
 		},
@@ -769,14 +754,14 @@ export default function (
 			return { state: "blocked", reason };
 		}
 		try {
-		const projection = await projectAssuranceState(ctx.cwd, taskId);
+		const projection = await projectAssuranceForTask(ctx.cwd, taskId);
 		if (projection.error || !projection.claim) {
 			const reason = projection.error ?? "no active backend claim";
 			notifyOnce(ctx, `authorization-claim:${taskId}:${reason}`, `cannot authorize ${taskId}: ${reason}`, "error");
 			progression.closeInvocation(invocation);
 			return { state: "blocked", reason };
 		}
-		const priorIntent = await readTaskIntent(ctx.cwd, taskId);
+		const priorIntent = await readTaskIntentForRecord(ctx.cwd, taskId);
 		const sidecar = nextIntent ? join(ctx.cwd, priorIntent.intent_ref.path) : undefined;
 		const priorBytes = sidecar ? readFileSync(sidecar) : undefined;
 		const stagedSnapshot = sidecar ? captureStagedIntent(ctx.cwd, priorIntent.intent_ref.path) : undefined;
@@ -797,10 +782,10 @@ export default function (
 					cwd: ctx.cwd,
 					stdio: ["ignore", "pipe", "pipe"],
 				});
-				const stagedRecord = await readTaskRecord(ctx.cwd, taskId);
+				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 = diffHashOf(ctx.cwd, stagedRecord.record);
+				stagedNextDiffHash = taskDeliveryIdentity(ctx.cwd, stagedRecord.record).diff_hash;
 			} catch (error) {
 				let restoreError: unknown;
 				try { restoreStagedIntent(); } catch (err) { restoreError = err; }
@@ -815,7 +800,7 @@ export default function (
 		let userDecisionOperation: ReturnType<typeof buildUserDecisionOperation> | undefined;
 		if (operation === "resolve-user-decision") {
 			try {
-				const current = await readTaskRecord(ctx.cwd, taskId);
+				const current = await readTaskRecordRaw(ctx.cwd, taskId);
 				if (!current.record) throw new Error(`task ${taskId} has no TaskRecord v2`);
 				if (current.revision !== projection.projection.record_revision)
 					throw new Error("task record changed while preparing user decision");
@@ -971,11 +956,11 @@ export default function (
 					if (nextIntent) await dependencies.authorizationAfterSidecarStage?.();
 					// Re-read the owner record after confirmation and compare the staged
 					// candidate digest immediately before capability issuance.
-					const liveRecord = nextIntent ? await readTaskRecord(ctx.cwd, taskId) : null;
+					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
-						? diffHashOf(ctx.cwd, 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");
@@ -1003,7 +988,7 @@ 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: NonNullable<TaskRecordRead["record"]>) => diffSnapshotOf(root, record),
+						diffProvider: (root: string, record: TaskRecord) => diffSnapshotOf(root, 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);
@@ -1015,7 +1000,7 @@ export default function (
 					return { state: "applied", operation, lifecycle: result.record.lifecycle };
 			} catch (error) {
 				if (stagedSnapshot) {
-					const current = await readTaskRecord(ctx.cwd, taskId);
+					const current = await readTaskRecordRaw(ctx.cwd, taskId);
 					if (current.record?.intent_snapshot.revision === priorIntent.intent.revision) restoreStagedIntent();
 				}
 				throw error;
@@ -1023,7 +1008,7 @@ export default function (
 			} catch (error) {
 				const reason = error instanceof Error ? error.message : String(error);
 				if (operation === "stop") {
-					const terminal = await projectAssuranceState(ctx.cwd, taskId).catch(() => null);
+					const terminal = await projectAssuranceForTask(ctx.cwd, taskId).catch(() => null);
 					if (terminal && !terminal.error && terminal.projection.lifecycle === "stopped") {
 						progression.releaseStoppedReview(taskId);
 						return { state: "applied", operation, lifecycle: "stopped", delivery_error: reason };
@@ -1040,11 +1025,11 @@ export default function (
 		if (ctx.mode !== "tui") return { state: "blocked", reason: "imm_kernel_canary mutation is TUI-only" };
 		if (progression.isInvocationOpen(taskId))
 			return { state: "blocked", reason: `task ${taskId} already has an open invocation; concurrent assure/authorize is rejected` };
-		const projection = await projectAssuranceState(ctx.cwd, taskId);
+		const projection = await projectAssuranceForTask(ctx.cwd, taskId);
 		if (projection.error || !projection.claim)
 			return { state: "blocked", reason: projection.error ?? "no active backend claim" };
 		await dependencies.authorizationBeforeRecordRead?.();
-		const read = await readTaskRecord(ctx.cwd, taskId);
+		const read = await readTaskRecordRaw(ctx.cwd, taskId);
 		if (!read.record) return { state: "blocked", reason: `task ${taskId} has no TaskRecord v3` };
 		if (read.revision !== projection.projection.record_revision)
 			return { state: "blocked", reason: "TaskRecord changed while deriving authorization operation" };
@@ -1108,7 +1093,7 @@ export async function recordCancelledUserDecision(
 	snapshotDigestRef: string,
 ): Promise<{ recorded: boolean; finding_id: string }> {
 	const findingId = `user-decision-${operation}`;
-	const current = await readTaskRecord(ctx.cwd, taskId);
+	const current = await readTaskRecordRaw(ctx.cwd, taskId);
 	const openDecision = current.record?.findings.find(
 		(finding) =>
 			finding.kind === "unresolved_user_decision" && finding.status === "open",
@@ -1130,8 +1115,8 @@ export async function recordCancelledUserDecision(
 			},
 			actor_id: LITERAL_USER_ACTOR_ID,
 		} as never,
-		prior_intent_token: (await readTaskIntent(ctx.cwd, taskId)).token,
-		diffProvider: (root: string, record: NonNullable<TaskRecordRead["record"]>) => diffSnapshotOf(root, record),
+		prior_intent_token: (await readTaskIntentForRecord(ctx.cwd, taskId)).token,
+		diffProvider: (root: string, record: TaskRecord) => diffSnapshotOf(root, record),
 		now: new Date().toISOString(),
 	});
 	return { recorded: true, finding_id: findingId };
@@ -1153,24 +1138,36 @@ export function buildUserDecisionOperation(record: {
 }
 
 /**
- * One record-aware freshness identity. v4 derives the scoped revision digest
- * from the immutable Enrollment base so committed and staged task work share a
- * single diff_hash with Review; v3 keeps the legacy HEAD -> index digest.
+ * Read the TaskIntent through the TaskRecord's `intent_ref.path`.
+ *
+ * `freeze_artifacts` binds the sidecar in place, so a post-freeze read must
+ * follow the record instead of guessing a default path; with no record yet
+ * (pre-enrollment) the Kernel resolves the sidecar that exists. Same contract
+ * 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);
+}
+
+async function markGithubTaskTerminal(
+	root: string,
+	input: { task_id: string; phase: "done" | "stopped"; terminal_event_id: string },
+): Promise<GithubTrackerResult> {
+	return runGithubTrackerOperation(root, { op: "mark-terminal", ...input });
+}
+
+/**
+ * The shared delivery identity selector: one function in workspace_scope.ts
+ * picks the identity family per TaskRecord contract. This adapter-level alias
+ * only narrows the record type for the Kernel ports that expect it; the dual-host
+ * conformance seam imports it so both hosts' reportable identity is comparable.
  */
-function diffSnapshotOf(root: string, record: NonNullable<TaskRecordRead["record"]>): {
+export function diffSnapshotOf(root: string, record: TaskRecord): {
 	diff_hash: string;
 	changed_paths: string[];
 } {
-	if (record.contract === "assurance_kernel/task_record/v4") {
-		if (!record.git_base_head)
-			throw new Error("TaskRecord v4 is missing git_base_head");
-		return taskRevisionIdentity(root, record.intent_snapshot.scope_hint, record.git_base_head, record.task_id);
-	}
-	return taskDiffIdentity(root, record.intent_snapshot.scope_hint, record.task_id);
-}
-
-function diffHashOf(root: string, record: NonNullable<TaskRecordRead["record"]>): string {
-	return diffSnapshotOf(root, record).diff_hash;
+	return taskDeliveryIdentity(root, record);
 }
 
 // Translation-only adapter for the internal Kernel assurance projection. All
@@ -1190,7 +1187,7 @@ async function buildTaskOverview(root: string): Promise<{
 	const claim = await readBackendClaim(root);
 	let active: TaskOverviewEntry | null = null;
 	if (claim) {
-		const projection = await projectAssuranceState(root, claim.task_id);
+		const projection = await projectAssuranceForTask(root, claim.task_id);
 		if (!projection.error) {
 			const state = projection.projection;
 			const obligation = String(state.next_obligation);
@@ -1241,56 +1238,14 @@ function overviewRailState(lifecycle: string, obligation: string): TaskRailState
 	return "Working";
 }
 
-async function projectAssuranceState(root: string, taskId: string): Promise<AssuranceProjectionResult> {
-	return projectAssurance(root, taskId, diffSnapshotOf);
+export async function projectAssuranceForTask(root: string, taskId: string): Promise<AssuranceProjectionResult> {
+	return projectAssurance(root, taskId);
 }
 
 /**
  * Publish and prove the task-scoped synthetic revision for a v4 record. v3
  * records keep the legacy full-source bundle and return null here.
  */
-export async function ensureTaskReviewRevision(
-	root: string,
-	taskId: string,
-	projection: AssuranceProjectionResult,
-): Promise<ReviewRevision | null> {
-	const current = await readTaskRecord(root, taskId);
-	const record = current.record;
-	if (!record) throw new Error(`task ${taskId} has no TaskRecord before Review preparation`);
-	if (current.revision !== projection.projection.record_revision)
-		throw new Error("TaskRecord changed before Review preparation");
-	if (record.contract !== "assurance_kernel/task_record/v4") return null;
-	if (!record.git_base_head)
-		throw new Error("Review revision requires a TaskRecord v4 git_base_head");
-	const manifest = captureReviewManifest(root, {
-		taskId,
-		baseHead: record.git_base_head,
-		scopeHint: record.intent_snapshot.scope_hint,
-		expectedDiffHash: projection.projection.diff_hash,
-		intentRevision: projection.projection.intent_revision,
-		intentContentHash: projection.projection.intent_content_hash,
-		recordRevision: projection.projection.record_revision,
-		workspaceRevision: projection.projection.workspace_revision,
-		lifecycle: projection.projection.lifecycle,
-		artifactState: projection.projection.artifact_state,
-		risk: record.intent_snapshot.risk,
-		// The same outcomes the Review snapshot is built from. A preflight stand-in
-		// only matched the settled QA attestation because deterministic QA happens to
-		// write that exact summary, so the submit-time digest comparison held by
-		// coincidence rather than by construction.
-		outcomes: qaOutcomes(record),
-	});
-	return {
-		contract: "assurance_kernel/review_revision/v1",
-		base_head: manifest.base_head,
-		review_tree: manifest.review_tree,
-		review_commit: manifest.review_commit,
-		review_ref: manifest.review_ref,
-		diff_hash: manifest.diff_hash,
-		manifest_digest: manifest.manifest_digest,
-	};
-}
-
 /**
  * Review refs are reconstructible evidence transport, never workflow authority.
  * A ref survives only while its task owns a nonterminal TaskRecord.
@@ -1308,7 +1263,7 @@ async function reconcileReviewRevisionRefs(root: string): Promise<{ removed: str
 		for (const entry of listed) {
 			if (live.has(entry.taskId)) continue;
 			try {
-				const record = await readTaskRecord(root, entry.taskId);
+				const record = await readTaskRecordRaw(root, entry.taskId);
 				if (record.record && record.record.lifecycle === "active" && claim?.task_id === entry.taskId)
 					live.add(entry.taskId);
 			} catch {
@@ -1334,267 +1289,13 @@ function notifyHost(ctx: HostContext, key: string, message: string, level: "warn
 	if (ui) notifyOnce({ ui }, key, message, level);
 }
 
-async function applyAssuranceVerdict(
-	// The coordinator port hands these a `HostContext`, not the Pi
-	// `ExtensionContext`. Both functions only ever read `cwd`; declaring the
-	// wider host type made the port assignment unsound.
-	ctx: HostContext,
-	snapshot: SnapshotDescriptor,
-	verdict: AssuranceVerdict,
-	invocation: InvocationToken,
-	actorId: string,
-	hooks: { beforeCommit?: () => Promise<void>; onCommit?: () => void; afterCommit?: () => Promise<void> } = {},
-	authorityKind: "qa" | "review" | "user" = snapshot.role,
-): Promise<void> {
-	const fresh = await projectAssuranceState(ctx.cwd, snapshot.task_id);
-	if (
-		fresh.error ||
-		fresh.claim?.task_id !== snapshot.task_id ||
-		fresh.projection.record_revision !== snapshot.record_revision ||
-		fresh.projection.workspace_revision !== snapshot.workspace_revision ||
-		fresh.projection.intent_revision !== snapshot.intent_revision ||
-		fresh.projection.intent_content_hash !== snapshot.intent_content_hash ||
-		fresh.projection.diff_hash !== snapshot.diff_hash ||
-		fresh.projection.lifecycle !== snapshot.lifecycle ||
-		fresh.projection.artifact_state !== snapshot.artifact_state
-	) {
-		throw new Error(`assurance snapshot changed before authority application: ${[
-			fresh.error,
-			fresh.claim?.task_id !== snapshot.task_id ? "claim" : null,
-			fresh.projection.record_revision !== snapshot.record_revision ? "record_revision" : null,
-			fresh.projection.workspace_revision !== snapshot.workspace_revision ? "workspace_revision" : null,
-			fresh.projection.intent_revision !== snapshot.intent_revision ? "intent_revision" : null,
-			fresh.projection.intent_content_hash !== snapshot.intent_content_hash ? "intent_content_hash" : null,
-			fresh.projection.diff_hash !== snapshot.diff_hash ? "diff_hash" : null,
-			fresh.projection.lifecycle !== snapshot.lifecycle ? `lifecycle(${snapshot.lifecycle}->${fresh.projection.lifecycle})` : null,
-			fresh.projection.artifact_state !== snapshot.artifact_state ? `artifact_state(${snapshot.artifact_state}->${fresh.projection.artifact_state})` : null,
-		].filter(Boolean).join(", ")}`);
-	}
-	const { registry, app } = await authorityPair();
-	const priorIntentToken = (await readTaskIntent(ctx.cwd, snapshot.task_id)).token;
-	const commitAndApply = async <T>(apply: () => Promise<T>): Promise<T> => {
-		invocationRegistry.commit(invocation);
-		const settlement = apply();
-		let hookError: unknown;
-		try { hooks.onCommit?.(); } catch (error) { hookError = error; }
-		const result = await settlement;
-		try { await hooks.afterCommit?.(); } catch (error) { hookError ??= error; }
-		if (hookError) throw hookError;
-		return result;
-	};
-	if (verdict.decision === "rework") {
-		const findings = reviewReworkFindings(verdict);
-		const now = new Date().toISOString();
-		const capability = await mintCapability(registry, {
-			authority_kind: authorityKind,
-			task_id: snapshot.task_id,
-			run_id: snapshot.run_id,
-			action_kind: "request_rework",
-			expected_record_hash: snapshot.record_revision,
-			intent_revision: snapshot.intent_revision,
-			intent_content_hash: snapshot.intent_content_hash,
-			diff_hash: snapshot.diff_hash,
-			actor_id: actorId,
-			findings,
-			now,
-		});
-		await hooks.beforeCommit?.();
-		const result = (await commitAndApply(async () => app.execute({
-			root: ctx.cwd,
-			task_id: snapshot.task_id,
-			operation: {
-				op: "request_rework",
-				capability,
-				findings: findings as never[],
-				actor_id: actorId,
-			},
-			prior_intent_token: priorIntentToken,
-			diffProvider: (root: string, record: NonNullable<TaskRecordRead["record"]>) => diffSnapshotOf(root, record),
-			now,
-		}))) as unknown as { record: { lifecycle: string; artifact_state: string; intent_ref: { path: string }; intent_snapshot: { scope_hint: string[] }; findings?: Array<{ kind: string; status: string }> } };
-		stagePlanningArtifactTransition(ctx.cwd, result.record);
-		const parked = (result.record as { findings?: Array<{ kind: string; status: string }> }).findings?.some(
-			(finding) => finding.kind === "replan_required" && finding.status === "open",
-		);
-		if (parked) notifyHost(
-			ctx,
-			`rework-parked:${snapshot.task_id}`,
-			`rework applied: review parked for replan with ${findings.length} finding(s)`,
-			"warning",
-		);
-		return;
-	}
-	const now = new Date().toISOString();
-	const advisories = verdict.decision === "pass" ? reviewAdvisoryRecords(verdict) : [];
-	const approval = {
-		id: `approval-${snapshot.role}-${randomUUID().slice(0, 8)}`,
-		kind: snapshot.role === "qa" ? "qa" : "review",
-		authority_role: snapshot.role === "qa" ? "qa" : "reviewer",
-		task_revision: snapshot.intent_revision,
-		intent_content_hash: snapshot.intent_content_hash,
-		diff_hash: snapshot.diff_hash,
-		actor_id: actorId,
-		summary: verdict.approval!.summary,
-		// Trusted revision identity comes from the host-verified snapshot, never
-		// from the reviewer payload.
-		...(snapshot.role === "review" && snapshot.review_revision
-			? { review_revision: snapshot.review_revision }
-			: {}),
-		...(snapshot.role === "review" && advisories.length > 0
-			? { advisory_findings: advisories }
-			: {}),
-	};
-	const capability = await mintCapability(registry, {
-		authority_kind: snapshot.role,
-		task_id: snapshot.task_id,
-		run_id: snapshot.run_id,
-		action_kind: "record_approval",
-		expected_record_hash: snapshot.record_revision,
-		intent_revision: snapshot.intent_revision,
-		intent_content_hash: snapshot.intent_content_hash,
-		diff_hash: snapshot.diff_hash,
-		actor_id: actorId,
-		approval,
-		now,
-	});
-	await hooks.beforeCommit?.();
-	await commitAndApply(async () => app.execute({
-		root: ctx.cwd,
-		task_id: snapshot.task_id,
-		operation: { op: "record_approval", capability, approval, actor_id: actorId },
-		prior_intent_token: priorIntentToken,
-		diffProvider: (root: string, record: NonNullable<TaskRecordRead["record"]>) => diffSnapshotOf(root, record),
-		now,
-	}));
-}
-
-async function buildAssuranceSnapshot(
-	root: string,
-	taskId: string,
-	role: AssuranceRole,
-	projection: AssuranceProjectionResult,
-): Promise<{
-	snapshot: SnapshotDescriptor;
-	descriptors: Map<string, VerificationDescriptor>;
-	reviewBundle: ReviewBundle | null;
-	reviewManifest: ReviewManifestV5 | null;
-}> {
-	const record = await readTaskRecord(root, taskId);
-	if (
-		!record.record ||
-		record.revision !== projection.projection.record_revision ||
-		record.record.intent_snapshot.revision !== projection.projection.intent_revision ||
-		record.record.intent_ref.content_hash !== projection.projection.intent_content_hash
-	) {
-		throw new Error("TaskRecord changed before assurance snapshot capture");
-	}
-	const intent = record.record.intent_snapshot;
-	const acceptance = intent.acceptance;
-	const descriptors = new Map<string, VerificationDescriptor>();
-	// Review resumes from settled outcomes without resolving verification tools.
-	for (const item of role === "qa" ? acceptance : []) {
-		const descriptor = parseVerificationDescriptor(item.verification);
-		descriptors.set(item.id, descriptor);
-	}
-	// `git_base_head` is optional on the read shape because v3 records carry
-	// none, so the contract test alone does not prove it is present.
-	const baseHead = record.record.contract === "assurance_kernel/task_record/v4"
-		? record.record.git_base_head
-		: undefined;
-	if (record.record.contract === "assurance_kernel/task_record/v4" && !baseHead)
-		throw new Error("TaskRecord v4 is missing its Enrollment git_base_head");
-	const reviewRevision = baseHead
-		? {
-			contract: "assurance_kernel/review_revision_identity/v1" as const,
-			base_head: baseHead,
-			review_commit: "",
-			review_tree: "",
-			manifest_digest: "",
-		}
-		: null;
-	const reviewBundle = role === "review" && !reviewRevision
-		? captureReviewBundle(
-				root,
-				intent.scope_hint,
-				projection.projection.diff_hash,
-				qaOutcomes(record.record),
-			)
-		: null;
-	const reviewManifest = role === "review" && reviewRevision
-		? captureReviewManifest(root, {
-				taskId,
-				baseHead: reviewRevision.base_head,
-				scopeHint: intent.scope_hint,
-				expectedDiffHash: projection.projection.diff_hash,
-				intentRevision: projection.projection.intent_revision,
-				intentContentHash: projection.projection.intent_content_hash,
-				recordRevision: projection.projection.record_revision,
-				workspaceRevision: projection.projection.workspace_revision,
-				lifecycle: projection.projection.lifecycle,
-				artifactState: projection.projection.artifact_state,
-				risk: intent.risk,
-				outcomes: qaOutcomes(record.record),
-			})
-		: null;
-	const taskSnapshot = !reviewBundle && !reviewManifest
-		? captureGitTaskSnapshot(root, intent.scope_hint, taskId)
-		: null;
-	const dirtyFiles = reviewManifest
-		? Object.keys(reviewManifest.changed_paths)
-		: reviewBundle
-			? Object.keys(reviewBundle.dirty_files)
-			: Object.keys(taskSnapshot!.staged_files);
-	return {
-		snapshot: buildSnapshot({
-				root,
-				task_id: taskId,
-				role,
-				run_id: projection.projection.run_id,
-				record_revision: projection.projection.record_revision,
-				workspace_revision: projection.projection.workspace_revision,
-				intent_revision: projection.projection.intent_revision,
-				intent_content_hash: projection.projection.intent_content_hash,
-				diff_hash: projection.projection.diff_hash,
-				lifecycle: projection.projection.lifecycle,
-				artifact_state: projection.projection.artifact_state,
-				risk: intent.risk,
-				fresh_acceptance_ids: projection.projection.fresh_acceptance_ids,
-				missing_acceptance_ids: projection.projection.missing_acceptance_ids,
-				stale_attestation_ids: projection.projection.stale_attestation_ids,
-				acceptance,
-				dirty_files: dirtyFiles,
-				review_bundle_digest: reviewManifest?.manifest_digest ?? reviewBundle?.bundle_digest ?? null,
-				review_revision: reviewManifest
-					? {
-							contract: "assurance_kernel/review_revision_identity/v1",
-							base_head: reviewManifest.base_head,
-							review_commit: reviewManifest.review_commit,
-							review_tree: reviewManifest.review_tree,
-							manifest_digest: reviewManifest.manifest_digest,
-						}
-						: undefined,
-		}),
-		descriptors,
-		reviewBundle,
-		reviewManifest,
-	};
-}
-
-function qaOutcomes(
-	record: NonNullable<TaskRecordRead["record"]>,
-): Record<string, { status: "passed" | "failed" | "blocked"; summary: string }> {
-	return Object.fromEntries(
-		record.attestations
-			.filter((item) => item.kind === "qa")
-			.flatMap((item) => item.acceptance_results)
-			.map((result) => [result.acceptance_id, { status: result.status, summary: result.summary }]),
-	);
-}
-
 // The invocation registry is shared with the progression module's
 // module-scoped registry (see the top-level import above); commit/cancel
 // semantics are identical to the previous extension implementation.
 
+const piConfirmationReference: ConfirmationReferenceSource = ({ snapshot, now }) =>
+	`pi-confirm-${createHash("sha256").update(`${snapshot.task_id}\0${now}\0${snapshot.intent_revision}\0${snapshot.intent_content_hash}\0${snapshot.diff_hash}`).digest("hex").slice(0, 16)}`;
+
 async function mintCapability(
 	registry: MutationAuthorityRegistry,
 	input: {
@@ -1648,7 +1349,6 @@ async function mintCapability(
 		confirmation_ref: `pi-confirm-${createHash("sha256").update(
 			`${input.task_id}\0${now}\0${input.intent_revision}\0${input.intent_content_hash}\0${input.diff_hash}`,
 		).digest("hex").slice(0, 16)}`,
-		expires_at: new Date(Date.now() + 10 * 60 * 1000).toISOString(),
 		findings_digest:
 			input.action_kind === "request_rework"
 				? await findingsDigestV2(input.findings as never[])
@@ -1677,7 +1377,7 @@ async function executeOrdinaryOperation(
 	const operation = input.operation.op === "revise_intent"
 		? { ...input.operation, next_intent: await parseTaskIntentV1(input.operation.next_intent) }
 		: input.operation;
-	const priorIntent = await readTaskIntent(ctx.cwd, input.taskId);
+	const priorIntent = await readTaskIntentForRecord(ctx.cwd, input.taskId);
 	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
@@ -1698,7 +1398,7 @@ async function executeOrdinaryOperation(
 			task_id: input.taskId,
 			operation: operation as never,
 			prior_intent_token: priorIntent.token,
-			diffProvider: (root: string, record: NonNullable<TaskRecordRead["record"]>) => diffSnapshotOf(root, record),
+			diffProvider: (root: string, record: TaskRecord) => diffSnapshotOf(root, record),
 			now: new Date().toISOString(),
 		});
 		if (operation.op === "freeze_artifacts" || operation.op === "stop")
@@ -1709,7 +1409,7 @@ async function executeOrdinaryOperation(
 		return result;
 	} catch (error) {
 		if (priorBytes) {
-			const current = await readTaskRecord(ctx.cwd, input.taskId);
+			const current = await readTaskRecordRaw(ctx.cwd, input.taskId);
 			if (current.record?.intent_snapshot.revision === priorIntent.intent.revision && priorStaged) {
 				restoreStagedIntentShared(ctx.cwd, priorStaged);
 			}
@@ -1732,6 +1432,46 @@ async function reconcileRefsQuietly(root: string): Promise<void> {
 	}
 }
 
+/**
+ * Gate-free closeout: a batch child that reached Kernel `done` in the foreground
+ * re-enters the batch in the same call, reusing its authorization. Only `done`
+ * continues; stopped, parked and Review-pending children end where they do
+ * today. The continuation is transport: the Kernel result is returned
+ * unchanged, and any failure is reported beside it with one retry action.
+ */
+async function closeOutBatchChild(
+	ctx: ExtensionContext,
+	taskId: string,
+	enriched: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+	const taskState = enriched.task_state as { lifecycle?: unknown } | undefined;
+	if (taskState?.lifecycle !== "done") return enriched;
+	let slug: string | null;
+	try {
+		slug = findResumableBatchSlugForTask(ctx.cwd, taskId);
+	} catch {
+		return enriched;
+	}
+	if (!slug) return enriched;
+	try {
+		// 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)))
+			execFileSync("git", ["-C", ctx.cwd, "add", "--", `.imm/audit/${taskId}`], { stdio: "ignore" });
+		const batch = await executePiUnattendedBatch({ root: ctx.cwd, initiativeSlug: slug, reuseOnly: true, signal: ctx.signal });
+		return { ...enriched, batch };
+	} catch (error) {
+		return {
+			...enriched,
+			batch: {
+				state: "rejected",
+				reason: `batch continuation failed: ${error instanceof Error ? error.message : String(error)}`,
+				recovery_action: "call start_unattended_batch with the same Initiative to continue the batch",
+			},
+		};
+	}
+}
+
 async function enrichAssuranceResult(
 	ctx: ExtensionContext,
 	taskId: string,
@@ -1742,7 +1482,7 @@ async function enrichAssuranceResult(
 		const taskState = { error: typeof result.reason === "string" ? result.reason : "authority projection unavailable" };
 		return { ...result, task_state: taskState, next_action: nextActionForAssuranceResult(result, taskState) };
 	}
-	const projection = await projectAssuranceState(ctx.cwd, taskId);
+	const projection = await projectAssuranceForTask(ctx.cwd, taskId);
 	const taskState: AssuranceTaskState = projection.error
 		? { error: projection.error }
 		: projection.projection;
@@ -1843,33 +1583,6 @@ function prepareActionArgs<Params>(args: unknown): Params {
 	return input as Params;
 }
 
-function stagePlanningArtifactTransition(root: string, record: {
-	intent_ref: { path: string };
-	intent_snapshot: { scope_hint: string[] };
-}): void {
-	const intentActive = record.intent_ref.path.replace("docs/plans/archive/", "docs/plans/");
-	const intentArchive = intentActive.replace("docs/plans/", "docs/plans/archive/");
-	const specActive = record.intent_snapshot.scope_hint.find((path) =>
-		/^docs\/specs\/(?!archive\/)[^/]+\.spec\.md$/.test(path)
-		&& record.intent_snapshot.scope_hint.includes(path.replace("docs/specs/", "docs/specs/archive/")),
-	);
-	const candidates = [
-		intentActive,
-		intentArchive,
-		...(specActive ? [specActive, specActive.replace("docs/specs/", "docs/specs/archive/")] : []),
-	];
-	const paths = candidates.filter((path) => existsSync(join(root, path)) || execFileSync(
-		"git",
-		["ls-files", "--cached", "--", path],
-		{ cwd: root, encoding: "utf8" },
-	).trim().length > 0);
-	if (paths.length === 0) return;
-	execFileSync("git", ["add", "--", ...paths], {
-		cwd: root,
-		stdio: ["ignore", "pipe", "pipe"],
-	});
-}
-
 function failCanaryTool(
 	taskId: string,
 	operation: string,