immune-brain 4.6.0 → 5.1.0

package/plugins/immune-brain/runtime/kernel/storage.ts

@@ -56,7 +56,7 @@ import {
 	stateDatabasePath,
 } from "./storage_paths";
 import { canonicalRecordHash } from "./reducer";
-import { parseTaskRecord } from "./validation";
+import { KernelInvariantError, parseTaskRecord } from "./validation";
 import { parseTaskRecordV2, parseTaskRecordV3, type TaskRecordV2 } from "./legacy_task_record";
 import {
 	assertRunBinding,
@@ -101,6 +101,7 @@ import type {
 	StoredTaskMutationV3,
 	V3AuthorityObservation,
 } from "./types";
+import { TASK_RECORD_CONTRACT_V4 } from "./types";
 
 export {
 	KernelSchemaError,
@@ -898,13 +899,33 @@ export function readWorkspaceStateRaw(root: string): {
 	};
 }
 
-function recordFromRun(run: KernelRunRow): TaskRecord {
-	const record = parseTaskRecord(JSON.parse(run.record_json) as Record<string, unknown>);
+/**
+ * The record a settled run carries, for a run of any historical contract.
+ *
+ * A migrated store preserves the terminal record bytes it was imported with:
+ * a genuine legacy v3 record is settled evidence the same way a live v4 one
+ * is, so the settled read parses both and validates nothing less. A record
+ * satisfying neither parser is unreadable and fails closed.
+ */
+function settledRecordFromRun(run: KernelRunRow): TaskRecord | TaskRecordV3 {
+	let record: TaskRecord | TaskRecordV3;
+	try {
+		record = parseTaskRecord(JSON.parse(run.record_json) as Record<string, unknown>);
+	} catch {
+		record = parseTaskRecordV3(JSON.parse(run.record_json) as Record<string, unknown>);
+	}
 	if (record.task_id !== run.task_id)
 		throw new KernelStoreSecurityError("task record identity is inconsistent with its run");
 	return record;
 }
 
+function recordFromRun(run: KernelRunRow): TaskRecord {
+	const record = settledRecordFromRun(run);
+	if (record.contract !== TASK_RECORD_CONTRACT_V4)
+		throw new KernelInvariantError([`a live run must hold a v4 record, found ${record.contract}`]);
+	return record;
+}
+
 export function readTaskRecordRaw(
 	root: string,
 	taskId: string,
@@ -948,6 +969,93 @@ export function readCommittedRecord(
 	return read ?? null;
 }
 
+/** The one definition of the enrollment Run-id convention: `enroll-<task>-<created_at>`. */
+export function enrollmentEventIdFor(taskId: string, createdAt: string): string {
+	validateTaskId(taskId);
+	return `enroll-${taskId}-${createdAt}`;
+}
+
+/**
+ * The Authority Store's answer to "the settled Run of this Task": this
+ * worktree's run row, its identity-validated record, its proof, whether its
+ * audit pair is exported, and the raw bytes for byte-exact comparison. Run
+ * resolution and proof matching happen behind this read, so a Task with
+ * several Runs never yields another Run's evidence, and an active Task or a
+ * Task with no Run reads as null.
+ */
+export interface SettledRunEvidence {
+	contract: "assurance_kernel/settled_run_evidence/v1";
+	task_id: string;
+	run_id: string;
+	created_at: string;
+	enrollment_event_id: string;
+	lifecycle: "done" | "stopped";
+	/** The settled record, which may be a migrated historical v3. */
+	record: TaskRecord | TaskRecordV3;
+	/** canonicalRecordHash(record): the record's canonical CAS identity. */
+	record_revision: string;
+	/** revisionForContent(record_json): the identity the proof binds. */
+	record_revision_raw: string;
+	/** The store's raw record bytes; equal to the exported audit record. */
+	record_json: string;
+	proof: TaskTombstone;
+	/** The store's raw proof bytes; equal to the exported audit proof. */
+	proof_json: string;
+	audit_exported: boolean;
+}
+
+export function readSettledRunEvidence(root: string, taskId: string): SettledRunEvidence | null {
+	validateTaskId(taskId);
+	const read = withKernelRead(root, (db) => {
+		const run = readRunRowByTask(db, taskId);
+		if (!run || run.state === "active") return null;
+		// A settled run always carries the proof its settlement committed; a
+		// store missing it is corrupt and must never project as a settled task.
+		if (run.terminal_proof_json === null)
+			throw new KernelStoreSecurityError(
+				`task ${taskId} is ${run.state} without a committed terminal proof`,
+			);
+		const record = settledRecordFromRun(run);
+		const record_revision = canonicalRecordHash(record as TaskRecord);
+		// The proof binds the raw committed bytes, not the canonical
+		// re-serialization: a store migrated from the prior runtime keeps
+		// historical record bytes whose serialization need not be canonical.
+		const record_revision_raw = revisionForContent(run.record_json);
+		const proof = parseTaskTombstone(
+			JSON.parse(run.terminal_proof_json) as Record<string, unknown>,
+		);
+		if (proof.task_id !== taskId)
+			throw new KernelStoreSecurityError("settled run proof identity is inconsistent");
+		if (proof.final_record_hash !== record_revision_raw)
+			throw new KernelStoreSecurityError("settled run proof does not match its task record");
+		// Three independent facts of one settlement must agree before the
+		// read answers: the run row's state, the record's own lifecycle, and
+		// the proof's terminal lifecycle. A store that disagrees with itself
+		// is corrupt evidence and must fail closed rather than project a
+		// settled task whose record is still live.
+		if (record.lifecycle !== run.state || proof.terminal_lifecycle !== run.state)
+			throw new KernelStoreSecurityError(
+				`settled run facts disagree: run state ${run.state}, record lifecycle ${record.lifecycle}, proof terminal ${proof.terminal_lifecycle}`,
+			);
+		return {
+			contract: "assurance_kernel/settled_run_evidence/v1" as const,
+			task_id: taskId,
+			run_id: run.run_id,
+			created_at: run.created_at,
+			enrollment_event_id: run.enrollment_event_id,
+			lifecycle: run.state as "done" | "stopped",
+			record,
+			record_revision,
+			record_revision_raw,
+			record_json: run.record_json,
+			proof,
+			proof_json: run.terminal_proof_json,
+			audit_exported: run.audit_exported_at !== null,
+		};
+	});
+	return read ?? null;
+}
+
 /**
  * Read the immutable terminal audit pair for one task:
  * `.imm/audit/<task-id>/task-record.json` plus `terminal-proof.json`.
@@ -1023,13 +1131,6 @@ export function readAuditTaskPair(
 	return { recordRevision, record, proof };
 }
 
-export function readTaskRecord(
-	root: string,
-	taskId: string,
-): { revision: string; record: TaskRecord | null } {
-	return readTaskRecordRaw(root, taskId);
-}
-
 // ---------------------------------------------------------------------------
 // Audit export: deterministic, idempotent, retryable, never authority.
 // ---------------------------------------------------------------------------
@@ -1073,6 +1174,60 @@ function convergePendingRelocations(root: string, db: DatabaseSync): void {
 	}
 }
 
+/** Settled task evidence: the terminal record and proof of a task's own run. */
+export interface SettledTaskEvidence {
+	/** The run that owns this evidence; `null` for the legacy flat layout. */
+	runId: string | null;
+	record: TaskRecordV2 | TaskRecordV3 | TaskRecord;
+	recordRevision: string;
+	proof: TaskTombstone;
+}
+
+/**
+ * The settled evidence of a task, read run-aware.
+ *
+ * One read decides which of three worlds this worktree is in, because a
+ * decision made from two reads can be stale between them:
+ *
+ * - **absent** (no Kernel store, or no row for the task): a pre-store terminal
+ *   or a repository fixture, whose single flat audit pair is this worktree's
+ *   evidence. This is the only world where the flat layout is read at all.
+ * - **active**: the task's run is in flight, so it has no settled evidence; an
+ *   exported or fetched pair of the same task is another run's and never
+ *   answers while this worktree's own run is live.
+ * - **terminal**: the task's own terminal run, read run-scoped; until its
+ *   export exists the evidence is unreadable (fail closed), never another run's.
+ *
+ * A settlement committed between two reads cannot turn the terminal world into
+ * the absent one, because the world is decided before any pair is resolved.
+ */
+export function readSettledTaskEvidence(root: string, taskId: string): SettledTaskEvidence | null {
+	validateTaskId(taskId);
+	const localRun = withKernelRead(root, (db) => readRunRowByTask(db, taskId));
+	if (!localRun) {
+		const legacy = readAuditTaskPair(root, taskId);
+		if (!legacy) return null;
+		return {
+			runId: null,
+			record: legacy.record as SettledTaskEvidence["record"],
+			recordRevision: legacy.recordRevision,
+			proof: legacy.proof,
+		};
+	}
+	if (localRun.state === "active") return null;
+	const settled = readSettledRunEvidence(root, taskId);
+	if (!settled) return null;
+	return {
+		runId: settled.run_id,
+		record: settled.record,
+		// The pair identity is the raw committed bytes the proof binds; the
+		// canonical revision stays available on the run evidence for callers
+		// that need the TaskRecord's canonical CAS identity.
+		recordRevision: settled.record_revision_raw,
+		proof: settled.proof,
+	};
+}
+
 // ---------------------------------------------------------------------------
 // Journal.
 // ---------------------------------------------------------------------------
@@ -1755,7 +1910,11 @@ export function reconcileKernelAuthority(
 	const legacy = projected ? null : retiredFileStoreDiagnostic(root, null, taskId);
 	if (legacy) return conflictProjection(taskId, legacy);
 	try {
-		const audit = readAuditTaskPair(root, taskId);
+		// Run-aware: when this worktree's store carries the task's run, only that
+		// run's own evidence may classify the task; the resolved/flat fallback
+		// below serves only pre-run-layout evidence of a task with no local run.
+		const localRun = localRunId(root, taskId);
+		const audit = readAuditTaskPair(root, taskId, localRun ?? undefined);
 		if (audit)
 			return {
 				contract: "assurance_kernel/authority_projection/v1",

package/plugins/immune-brain/runtime/kernel/storage_paths.ts

@@ -212,6 +212,19 @@ export function auditTerminalProofPath(taskId: string): string {
 	return `${auditTaskDirPath(taskId)}/terminal-proof.json`;
 }
 
+/** Unattended batch run state: `.imm/state/batches/<batch-id>.json`. */
+export function batchStatePath(batchId: string): string {
+	if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(batchId))
+		throw new Error(`invalid batch identity: ${batchId}`);
+	return `${BATCH_STATE_RELATIVE}/${batchId}.json`;
+}
+
+/** Durable batch child commit evidence: `.imm/state/batches/commits/<batch-id>-<task-id>.json`. */
+export function batchCommitEvidencePath(batchId: string, taskId: string): string {
+	validateTaskId(taskId);
+	return `${BATCH_STATE_RELATIVE}/commits/${batchId}-${taskId}.json`;
+}
+
 /** Historical v3 machine evidence root under the tracked audit store. */
 export function legacyV3Path(...segments: string[]): string {
 	for (const segment of segments)

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

@@ -0,0 +1,94 @@
+// Reads the Local Initiative carrier, `docs/initiatives/<slug>.md`, into the
+// same Task list the GitHub carrier yields, so an unattended batch can be
+// projected without any GitHub operation. Read-only: this parses a human-owned
+// file and grants, records, and repairs nothing.
+
+import { lstatSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+export interface LocalInitiativeObservation {
+	contract: "immune_brain/local_initiative_observation/v1";
+	initiative_id: string;
+	path: string;
+	tasks: Array<{
+		task_id: string;
+		slice_id: string;
+		blocked_by: string[];
+	}>;
+}
+
+const ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const SLICE_HEADING = /^##\s+([^\s:]+)\s*:/;
+const BLOCKED_BY = /^blocked by\s*:(.*)$/i;
+const TASKS = /^tasks\s*:\s*$/i;
+const BULLET = /^[-*]\s+(.*)$/;
+
+export function localInitiativePath(initiativeSlug: string): string {
+	return `docs/initiatives/${initiativeSlug}.md`;
+}
+
+/** True when the Local carrier owns this slug: a regular file, never a symlink. */
+export function hasLocalInitiative(root: string, initiativeSlug: string): boolean {
+	const stat = lstatSync(resolve(root, localInitiativePath(initiativeSlug)), { throwIfNoEntry: false });
+	if (!stat) return false;
+	if (!stat.isFile()) throw new Error(`${localInitiativePath(initiativeSlug)} must be a regular file`);
+	return true;
+}
+
+function unquote(value: string): string {
+	return value.trim().replace(/^`(.*)`$/, "$1");
+}
+
+/**
+ * Each `## <slice-id>: <result>` section names its Task under `Tasks:` and may
+ * add one `Blocked by: <task-id>, <task-id>` line. A batch child is one Slice,
+ * so a section with no Task or several is refused rather than guessed at.
+ */
+export function observeLocalInitiative(root: string, initiativeSlug: string): LocalInitiativeObservation {
+	if (!ID_PATTERN.test(initiativeSlug)) throw new Error("initiative_slug is invalid");
+	const path = localInitiativePath(initiativeSlug);
+	if (!hasLocalInitiative(root, initiativeSlug)) throw new Error(`Local Initiative ${path} does not exist`);
+	const slices: Array<{ slice_id: string; tasks: string[]; blocked_by: string[] }> = [];
+	let inTasks = false;
+	let fence = false;
+	for (const raw of readFileSync(resolve(root, path), "utf8").split(/\r?\n/)) {
+		const line = raw.trim();
+		if (line.startsWith("```")) {
+			fence = !fence;
+			continue;
+		}
+		if (fence) continue;
+		const heading = SLICE_HEADING.exec(line);
+		if (heading) {
+			slices.push({ slice_id: heading[1]!, tasks: [], blocked_by: [] });
+			inTasks = false;
+			continue;
+		}
+		const slice = slices.at(-1);
+		if (!slice) continue;
+		if (TASKS.test(line)) {
+			inTasks = true;
+			continue;
+		}
+		const blocked = BLOCKED_BY.exec(line);
+		if (blocked) {
+			slice.blocked_by.push(...blocked[1]!.split(",").map(unquote).filter(Boolean));
+			inTasks = false;
+			continue;
+		}
+		const bullet = BULLET.exec(line);
+		if (inTasks && bullet) slice.tasks.push(unquote(bullet[1]!));
+		else if (line) inTasks = false;
+	}
+	if (!slices.length) throw new Error(`Local Initiative ${path} declares no Slice`);
+	return {
+		contract: "immune_brain/local_initiative_observation/v1",
+		initiative_id: initiativeSlug,
+		path,
+		tasks: slices.map((slice) => {
+			if (slice.tasks.length !== 1)
+				throw new Error(`Local Initiative Slice ${slice.slice_id} must name exactly one Task to run as a batch child`);
+			return { task_id: slice.tasks[0]!, slice_id: slice.slice_id, blocked_by: slice.blocked_by };
+		}),
+	};
+}

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

@@ -1,5 +1,5 @@
 /**
- * Runtime validation for `imm-loop` subagent output.
+ * Runtime validation for `imm-run` subagent output.
  *
  * The loop parent collects QA and reviewer decisions from isolated children.
  * Those decisions are untrusted input: they arrive as free-form JSON produced
@@ -9,6 +9,7 @@
  */
 import {
 	buildRoleDelegationPacket,
+	LANE_EXECUTOR_HOSTS,
 	type RoleDelegationContext,
 	type RoleDelegationPacket,
 	type InternalRole,
@@ -30,7 +31,8 @@ export type LoopRouteTarget =
 	| "pr-repair"
 	| "architecture-exploration"
 	| "advisory-review"
-	| "compounder";
+	| "compounder"
+	| "lane-supply";
 export type LoopRouteNext =
 	| "executor"
 	| "test-fixer"
@@ -38,11 +40,12 @@ export type LoopRouteNext =
 	| "arch-explorer"
 	| "advisory-reviewer"
 	| "compounder"
+	| "lane-steward"
 	| "imm_kernel_canary"
 	| "imm-planner";
 
 export interface LoopRoute {
-	entry: "imm-loop";
+	entry: "imm-run";
 	next: LoopRouteNext;
 }
 
@@ -55,27 +58,33 @@ export function resolveLoopRoute(input: {
 	target: LoopRouteTarget;
 	scope_expansion?: boolean;
 }): LoopRoute {
-	if (input.scope_expansion) return { entry: "imm-loop", next: "imm-planner" };
+	if (input.scope_expansion) return { entry: "imm-run", next: "imm-planner" };
 	if (
 		input.target === "architecture-exploration" &&
 		(input.ownership === "brainstorm" || input.ownership === "planner")
 	) {
-		return { entry: "imm-loop", next: "arch-explorer" };
+		return { entry: "imm-run", next: "arch-explorer" };
 	}
 	if (
 		input.target === "advisory-review" &&
 		(input.ownership === "brainstorm" || input.ownership === "planner")
 	) {
-		return { entry: "imm-loop", next: "advisory-reviewer" };
+		return { entry: "imm-run", next: "advisory-reviewer" };
 	}
 	if (input.target === "compounder") {
 		if (input.ownership !== "loop") {
 			throw new Error("Compounder routing requires Loop ownership");
 		}
-		return { entry: "imm-loop", next: "compounder" };
+		return { entry: "imm-run", next: "compounder" };
+	}
+	if (input.target === "lane-supply") {
+		if (input.ownership !== "loop") {
+			throw new Error("Lane supply routing requires Loop ownership");
+		}
+		return { entry: "imm-run", next: "lane-steward" };
 	}
 	if (input.ownership === "kernel") {
-		return { entry: "imm-loop", next: "imm_kernel_canary" };
+		return { entry: "imm-run", next: "imm_kernel_canary" };
 	}
 	const nextByTarget: Record<"step" | "test-repair" | "pr-repair", LoopRouteNext> = {
 		step: "executor",
@@ -88,7 +97,7 @@ export function resolveLoopRoute(input: {
 		);
 	}
 	return {
-		entry: "imm-loop",
+		entry: "imm-run",
 		next: nextByTarget[
 			input.target as "step" | "test-repair" | "pr-repair"
 		],
@@ -96,14 +105,20 @@ export function resolveLoopRoute(input: {
 }
 
 export type LoopAction =
-	| { entry: "imm-loop"; next: "executor"; context: LoopRoleContext }
+	| { entry: "imm-run"; next: "executor"; context: LoopRoleContext }
 	| {
-			entry: "imm-loop";
-			next: "test-fixer" | "pr-fix" | "arch-explorer" | "advisory-reviewer" | "compounder";
+			entry: "imm-run";
+			next:
+				| "test-fixer"
+				| "pr-fix"
+				| "arch-explorer"
+				| "advisory-reviewer"
+				| "compounder"
+				| "lane-steward";
 			dispatch: LoopRoleDispatch;
 	  }
 	| {
-			entry: "imm-loop";
+			entry: "imm-run";
 			next: "imm_kernel_canary";
 			tool: {
 				name: "imm_kernel_canary";
@@ -116,8 +131,8 @@ export type LoopAction =
 					| "complete";
 			};
 	  }
-	| { entry: "imm-loop"; next: "imm-planner"; reason: "scope_expansion" }
-	| { entry: "imm-loop"; next: "none"; reason: "no_reusable_learning" };
+	| { entry: "imm-run"; next: "imm-planner"; reason: "scope_expansion" }
+	| { entry: "imm-run"; next: "none"; reason: "no_reusable_learning" };
 
 function hasReusableLearningEvidence(context: RoleDelegationContext): boolean {
 	if (
@@ -140,6 +155,36 @@ function hasReusableLearningEvidence(context: RoleDelegationContext): boolean {
 	});
 }
 
+/**
+ * A lane-steward dispatch carries exactly one batch handoff. A provision names
+ * the branch, the base and the Executor Hosts to choose from, limited to the
+ * allowlist, so a handoff offering any other Host is refused before a role
+ * prompt is built. A release names the Lane branch.
+ */
+function assertLaneStewardHandoff(context: RoleDelegationContext): void {
+	if (!nonEmptyString(context.lane_branch)) {
+		throw new Error("lane-steward dispatch requires a lane_branch");
+	}
+	if (context.action === "release") return;
+	if (context.action !== "provision") {
+		throw new Error("lane-steward dispatch requires action provision or release");
+	}
+	if (!nonEmptyString(context.base_head)) {
+		throw new Error("lane-steward provision requires a base_head");
+	}
+	const hosts = context.executor_hosts;
+	const allowed: readonly string[] = LANE_EXECUTOR_HOSTS;
+	if (
+		!Array.isArray(hosts) ||
+		hosts.length === 0 ||
+		!hosts.every((host) => typeof host === "string" && allowed.includes(host))
+	) {
+		throw new Error(
+			`lane-steward provision offers only ${LANE_EXECUTOR_HOSTS.join(", ")}`,
+		);
+	}
+}
+
 export function buildLoopAction(input: {
 	ownership: LoopRouteOwnership;
 	target: LoopRouteTarget;
@@ -149,18 +194,18 @@ export function buildLoopAction(input: {
 }): LoopAction {
 	const route = resolveLoopRoute(input);
 	if (route.next === "imm-planner") {
-		return { entry: "imm-loop", next: "imm-planner", reason: "scope_expansion" };
+		return { entry: "imm-run", next: "imm-planner", reason: "scope_expansion" };
 	}
 	if (route.next === "compounder") {
 		if (!input.context || !hasReusableLearningEvidence(input.context)) {
 			return {
-				entry: "imm-loop",
+				entry: "imm-run",
 				next: "none",
 				reason: "no_reusable_learning",
 			};
 		}
 		return {
-			entry: "imm-loop",
+			entry: "imm-run",
 			next: "compounder",
 			dispatch: buildLoopRoleDispatch({ role: "compounder", context: input.context }),
 		};
@@ -168,44 +213,52 @@ export function buildLoopAction(input: {
 	if (!input.context) throw new Error(`Loop ${route.next} action requires context`);
 	if (route.next === "executor") {
 		return {
-			entry: "imm-loop",
+			entry: "imm-run",
 			next: "executor",
 			context: buildRoleDelegationPacket({ role: "executor", context: input.context }),
 		};
 	}
 	if (route.next === "test-fixer") {
 		return {
-			entry: "imm-loop",
+			entry: "imm-run",
 			next: "test-fixer",
 			dispatch: buildLoopRoleDispatch({ role: "test-fixer", context: input.context }),
 		};
 	}
 	if (route.next === "pr-fix") {
 		return {
-			entry: "imm-loop",
+			entry: "imm-run",
 			next: "pr-fix",
 			dispatch: buildLoopRoleDispatch({ role: "pr-fix", context: input.context }),
 		};
 	}
 	if (route.next === "arch-explorer") {
 		return {
-			entry: "imm-loop",
+			entry: "imm-run",
 			next: "arch-explorer",
 			dispatch: buildLoopRoleDispatch({ role: "arch-explorer", context: input.context }),
 		};
 	}
+	if (route.next === "lane-steward") {
+		assertLaneStewardHandoff(input.context);
+		return {
+			entry: "imm-run",
+			next: "lane-steward",
+			dispatch: buildLoopRoleDispatch({ role: "lane-steward", context: input.context }),
+		};
+	}
 	if (route.next === "advisory-reviewer") {
 		if (!nonEmptyString(input.context.lens)) {
 			throw new Error("advisory review requires an explicit lens");
 		}
 		return {
-			entry: "imm-loop",
+			entry: "imm-run",
 			next: "advisory-reviewer",
 			dispatch: buildLoopRoleDispatch({ role: "advisory-reviewer", context: input.context }),
 		};
 	}
 	return {
-		entry: "imm-loop",
+		entry: "imm-run",
 		next: "imm_kernel_canary",
 		tool: {
 			name: "imm_kernel_canary",

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.6.0" as const;
+export const PLUGIN_VERSION = "5.1.0" as const;

package/plugins/immune-brain/runtime/prompts/code-review.md

@@ -46,6 +46,13 @@ covers the whole lifecycle including cleanup, ranking tolerates missing
 embeddings, the budget covers the complete serialized request, and each success,
 failure, and timeout outcome carries its own duration evidence.
 
+When an acceptance assertion, or the Spec it references, names an agreed seam,
+check that the delivered tests exercise that acceptance at that seam. A missing
+seam, or a seam silently replaced by a different one, is a finding carrying
+`violated.kind` of `acceptance` with `ref` the acceptance id. When no seam is
+named, its absence is not a finding: candidates written before this rule carries
+no defect for lacking one.
+
 A required check that is skipped, that matches zero tests, or whose prerequisite
 is absent does not prove the acceptance; do not accept it as evidence. Full
 suite coverage reported at a coarse pass count is not per-invariant evidence.

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

@@ -12,8 +12,9 @@ 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
+Before handoff, run the permitted diagnostic checks, complete the Delivery
+Evidence check below and return its table to the Parent as structured diagnostic
+evidence. The read-only Loop
 runtime action only constructs the dispatch envelope; it does not store
 evidence or change task state. Preserve failed and blocked attempts. Do not
 perform QA,
@@ -21,6 +22,38 @@ review, plan mutation, successor approval, Compounder work, or authority
 writes. If the requested change needs scope expansion, stop and return an
 `imm-planner` route with the concrete missing scope and verification reason.
 
+## Delivery Evidence
+
+Reuse the TaskIntent and any bound Spec's agreed seams and controls. Before the
+first Assurance attempt, return one compact row per acceptance; update affected
+rows after repair. This is handoff evidence, not a new artifact or approval gate.
+
+| Acceptance / invariant | Entry and consumers | Positive / negative / boundary controls | Command, outcome and input | Finding coverage |
+|---|---|---|---|---|
+
+For changed shared behavior, trace the real entry through its state owner,
+write, serialization, reload and downstream consumer as applicable. Include
+both affected hosts and recovery/replay branches. An async, return-type or
+exception-contract change requires checking every affected caller's await,
+cancellation and error propagation.
+
+Use the real producer for the success control where available. Derive rejection
+controls from a successful state, change only the target condition, and assert
+the intended rejection reason and required side effects. A control must fail
+when its target protection is removed. For byte-preservation claims compare the
+relevant raw files, index and refs; for observed behavior link each required
+criterion to its concrete observation.
+
+Name whether each check consumed worktree or delivery bytes. Before Assurance,
+verify task-owned changes are staged within scope, generated mirrors match,
+and applicable type/build checks pass. On QA failure, reproduce the reported
+failure under its delivery conditions before another attempt. For rework, name
+the violated invariant, all known trigger classes and their controls in Finding
+coverage; account for affected callers sharing that invariant within scope.
+Record missing evidence as blocked and repair it before handoff. The Loop owns
+verdict submission, finding disposition and the second-rework generalize-or-refute
+rule.
+
 ## Code Quality Guard
 
 Before handoff, check the implementation for real implementation rather than