immune-brain 5.1.1 → 5.1.2

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

@@ -0,0 +1,33 @@
+// Claude Code hook decisions that are not Review observation. PreToolUse guard for batch Lanes: an Edit, Write, MultiEdit or
+// NotebookEdit whose target resolves outside the Lane is denied before it
+// runs, the same rule the Pi extension applies to `edit`/`write`. Bash is not
+// intercepted. Outside a Lane the hook answers nothing and the tool runs as
+// configured.
+import { laneWriteRefusal } from "../unattended/lane_workspace";
+import { activeTaskNotice } from "../assurance/active_task_notice";
+
+const FILE_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+
+/** The hook's stdout for one PreToolUse payload, or null to stay silent. */
+export function laneGuardHookOutput(payload: Record<string, unknown>): string | null {
+	if (payload.hook_event_name !== "PreToolUse" || !FILE_TOOLS.has(String(payload.tool_name))) return null;
+	const input = (payload.tool_input ?? {}) as { file_path?: unknown; notebook_path?: unknown };
+	const cwd = typeof payload.cwd === "string" && payload.cwd ? payload.cwd : process.cwd();
+	const refusal = laneWriteRefusal(cwd, input.file_path ?? input.notebook_path);
+	if (!refusal) return null;
+	return JSON.stringify({
+		hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: refusal },
+	});
+}
+
+/**
+ * UserPromptSubmit: when the workspace has an active Managed task, add the
+ * advisory notice as context. It never resumes the task.
+ */
+export async function activeTaskHookOutput(payload: Record<string, unknown>): Promise<string | null> {
+	if (payload.hook_event_name !== "UserPromptSubmit") return null;
+	const cwd = typeof payload.cwd === "string" && payload.cwd ? payload.cwd : process.cwd();
+	const notice = await activeTaskNotice(cwd);
+	if (!notice) return null;
+	return JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: notice } });
+}

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

@@ -12,8 +12,11 @@ import {
 	type NativeConfirmationPort,
 } from "./interaction";
 import { ClaudeReviewHost, FileHookEventLog, parseHookStdin } from "./review_host";
+import { activeTaskHookOutput, laneGuardHookOutput } from "./lane_guard";
 import { ClaudeRuntime, type ToolMeta } from "./kernel_ports";
-import { parseLaneOffers, parseMaxParallel, resolveLaneParallel } from "../unattended/batch_lanes";
+import { parseLaneInstruction, parseLaneOffers, parseMaxParallel, resolveLaneParallel } from "../unattended/batch_lanes";
+import { parseFinalVerification } from "../unattended/batch_final_verification";
+import { parseLaneRevision, REVISION_DELEGATION_TEXT } from "../unattended/batch_delegation";
 import type { AssuranceCoordinatorPorts } from "../assurance/coordinator";
 
 export const MCP_PROTOCOL_VERSION = "2025-06-18";
@@ -56,6 +59,24 @@ export function listMcpTools() {
 											additionalProperties: false,
 										},
 									},
+									final_verification: { type: "array", items: { type: "string" }, minItems: 1, maxItems: 8 },
+									lane_instruction: {
+										type: "object",
+										properties: {
+											task_id: { type: "string" },
+											kind: { type: "string", enum: ["instruction", "correction"] },
+											text: { type: "string" },
+											session_state: { type: "string", enum: ["idle", "working", "blocked", "done"] },
+										},
+										required: ["task_id", "text", "session_state"],
+										additionalProperties: false,
+									},
+									lane_revision: {
+										type: "object",
+										properties: { task_id: { type: "string" }, next_intent: { type: "object" } },
+										required: ["task_id", "next_intent"],
+										additionalProperties: false,
+									},
 								}
 							: {}),
 						}
@@ -153,10 +174,16 @@ export function createMcpRuntime(options: McpRuntimeOptions = {}) {
 				};
 				const laneOffers = parseLaneOffers(args.lane_offers);
 				// A lane_offers-only call resumes the recorded lane batch; refused before any gate otherwise.
-				const maxParallel = resolveLaneParallel(options.cwd ?? process.cwd(), initiativeSlug, parseMaxParallel(args.max_parallel), laneOffers);
+				const laneInstruction = parseLaneInstruction(args.lane_instruction);
+				const laneRevision = parseLaneRevision(args.lane_revision);
+				const maxParallel = resolveLaneParallel(options.cwd ?? process.cwd(), initiativeSlug, parseMaxParallel(args.max_parallel), laneOffers, laneInstruction ?? laneRevision);
+				const finalVerification = parseFinalVerification(args.final_verification);
 				return runtime.startUnattendedBatch(initiativeSlug, toolMeta, {
 					...(maxParallel !== undefined ? { max_parallel: maxParallel } : {}),
 					...(laneOffers !== undefined ? { lane_offers: laneOffers } : {}),
+					...(finalVerification !== undefined ? { final_verification: finalVerification } : {}),
+					...(laneInstruction !== undefined ? { lane_instruction: laneInstruction } : {}),
+					...(laneRevision !== undefined ? { lane_revision: laneRevision } : {}),
 				});
 			}
 			if (name === "retire_stale_batch") {
@@ -445,11 +472,25 @@ export function elicitationParams(input: NativeConfirmationInput) {
 			b?.lane_mode ? `Lane mode: max_parallel=${b.lane_mode.max_parallel}` : null,
 			b?.lane_mode ? `Parallel groups (${b.lane_mode.parallel_groups.length}):\n${b.lane_mode.parallel_groups.map((group) => `  - ${group.join(", ")}`).join("\n")}` : null,
 			b?.lane_mode && b.lane_mode.serialized.length > 0 ? `Serialized by overlapping scope (${b.lane_mode.serialized.length}):\n${b.lane_mode.serialized.map((c) => `  - ${c.task_id} after ${c.overlaps_with.join(", ")}`).join("\n")}` : null,
+			b?.lane_mode?.final_verification ? `Final verification: ${b.lane_mode.final_verification.join("; ")}` : null,
+			b?.lane_mode?.offer_revision_delegation ? REVISION_DELEGATION_TEXT : null,
 		].filter(Boolean);
 		return {
 			mode: "form",
 			message: `Authorize this unattended batch run for ${input.initiativeSlug}?\n\n${details.join("\n")}`,
-			requestedSchema: { type: "object", properties: {} },
+			requestedSchema: b?.lane_mode?.offer_revision_delegation
+				? {
+						type: "object",
+						properties: {
+							delegate_in_lane_revisions: {
+								type: "boolean",
+								title: "Delegate in-envelope Lane Intent revisions to the batch coordinator",
+								description: REVISION_DELEGATION_TEXT,
+								default: false,
+							},
+						},
+					}
+				: { type: "object", properties: {} },
 		};
 	}
 	const details = [
@@ -527,13 +568,19 @@ export async function serveStdio(options: {
 			if (action !== "accept" && action !== "decline" && action !== "cancel") {
 				throw new NativeAuthorityError("correlation_missing", "MCP elicitation returned an invalid action");
 			}
+			let delegateRevisions = false;
 			if (action === "accept") {
 				const content = (result as { content?: unknown }).content;
-				if (typeof content !== "object" || content === null || Array.isArray(content) || Object.keys(content).length !== 0) {
+				const offered = input.operation === "start_unattended_batch" && input.batchDetails?.lane_mode?.offer_revision_delegation === true;
+				const keys = typeof content === "object" && content !== null && !Array.isArray(content) ? Object.keys(content) : null;
+				const valid = keys !== null && (keys.length === 0 ||
+					(offered && keys.length === 1 && keys[0] === "delegate_in_lane_revisions" && typeof (content as Record<string, unknown>).delegate_in_lane_revisions === "boolean"));
+				if (!valid) {
 					throw new NativeAuthorityError("correlation_missing", "MCP elicitation accept content did not match the requested schema");
 				}
+				delegateRevisions = offered && (content as Record<string, unknown>).delegate_in_lane_revisions === true;
 			}
-			return { decision: action, requestId };
+			return { decision: action, requestId, ...(delegateRevisions ? { delegateRevisions: true } : {}) };
 		} finally {
 			pending.delete(requestId);
 			if (abortListener) input.signal?.removeEventListener("abort", abortListener);
@@ -686,7 +733,20 @@ async function runHook(): Promise<void> {
 	const lines: string[] = [];
 	const rl = createInterface({ input: stdin });
 	for await (const line of rl) lines.push(line);
-	const event = parseHookStdin(lines.join("\n"));
+	const raw = lines.join("\n");
+	let payload: Record<string, unknown> | null = null;
+	try { payload = JSON.parse(raw) as Record<string, unknown>; } catch { payload = null; }
+	if (payload?.hook_event_name === "PreToolUse") {
+		const decision = laneGuardHookOutput(payload);
+		if (decision) process.stdout.write(`${decision}\n`);
+		return;
+	}
+	if (payload?.hook_event_name === "UserPromptSubmit") {
+		const notice = await activeTaskHookOutput(payload);
+		if (notice) process.stdout.write(`${notice}\n`);
+		return;
+	}
+	const event = parseHookStdin(raw);
 	if (!event) return;
 	new FileHookEventLog().append(event);
 }

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

@@ -8,6 +8,7 @@ import {
 } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { resolve } from "node:path";
+import { projectScopeOverlap } from "../unattended/batch_schedule";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 import {
@@ -858,6 +859,57 @@ function runIntentAuthor(args: string[], root: string): KernelExecution {
  * TaskRecord, claim, Ledger, Git index, or session write. Returns a stable
  * bounded projection.
  */
+/**
+ * Read-only: compare the `scope_hint` of two or more TaskIntents of one
+ * Initiative and report every overlapping entry pair plus the start waves the
+ * Batch Plan would use. Optional `--blocked-by a=b,c` edges order the waves the
+ * way the Initiative's dependencies do. Writes nothing.
+ */
+function runIntentOverlap(args: string[], root: string): KernelExecution {
+	const usage = "Run imm-kernel intent overlap <path> <path>... [--blocked-by <task-id>=<task-id>,...] --json.";
+	const reject = (message: string): KernelExecution => ({
+		result: errorResult("invalid_command", message, 2),
+		journal: journalFor("intent", null, "rejected", "invalid_command", null, usage),
+	});
+	const paths: string[] = [];
+	const blockedBy = new Map<string, string[]>();
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index]!;
+		if (arg === "--json") continue;
+		if (arg === "--blocked-by") {
+			const edge = args[++index] ?? "";
+			const match = /^([A-Za-z0-9][A-Za-z0-9._-]*)=([A-Za-z0-9._,-]+)$/.exec(edge);
+			if (!match) return reject(`invalid --blocked-by edge: ${edge}`);
+			blockedBy.set(match[1]!, match[2]!.split(",").filter(Boolean));
+			continue;
+		}
+		if (arg.startsWith("-")) return reject(`unsupported intent overlap option: ${arg}`);
+		paths.push(arg);
+	}
+	if (paths.length < 2) return reject("imm-kernel intent overlap requires at least two paths");
+	const children: Array<{ task_id: string; blocked_by: string[]; scope_hint: string[] }> = [];
+	for (const path of paths) {
+		let intent: { task_id?: unknown; scope_hint?: unknown };
+		try {
+			intent = JSON.parse(readFileSync(resolve(root, path), "utf8"));
+		} catch (error) {
+			return { result: errorResult("source_invalid", `cannot read ${path}: ${error instanceof Error ? error.message : String(error)}`, 1), journal: journalFor("intent", null, "rejected", "source_read_failed", null, usage) };
+		}
+		if (typeof intent.task_id !== "string" || !Array.isArray(intent.scope_hint) || intent.scope_hint.some((entry) => typeof entry !== "string"))
+			return { result: errorResult("source_invalid", `${path} has no task_id and string scope_hint`, 1), journal: journalFor("intent", null, "rejected", "source_invalid", null, usage) };
+		children.push({ task_id: intent.task_id, blocked_by: [], scope_hint: intent.scope_hint as string[] });
+	}
+	const known = new Set(children.map((child) => child.task_id));
+	for (const child of children) child.blocked_by = (blockedBy.get(child.task_id) ?? []).filter((id) => known.has(id));
+	let report: ReturnType<typeof projectScopeOverlap>;
+	try {
+		report = projectScopeOverlap(children);
+	} catch (error) {
+		return reject(error instanceof Error ? error.message : String(error));
+	}
+	return { result: jsonResult(report, 0), journal: journalFor("intent", null, "ok", "command_ok", null, null) };
+}
+
 function runIntentValidate(args: string[], root: string): KernelExecution {
 	const nonFlags = args.filter((arg) => !arg.startsWith("-"));
 	if (nonFlags.length !== 1)
@@ -1173,10 +1225,11 @@ function executeKernelCommand(args: string[], root: string): KernelExecution {
 		const sub = args[1] ?? "";
 		if (sub === "author") return runIntentAuthor(args.slice(2), root);
 		if (sub === "validate") return runIntentValidate(args.slice(2), root);
+		if (sub === "overlap") return runIntentOverlap(args.slice(2), root);
 		return {
 			result: errorResult(
 				"invalid_command",
-				"usage: imm-kernel intent author <path> --stdin --json | validate <path> --json",
+				"usage: imm-kernel intent author <path> --stdin --json | validate <path> --json | overlap <path> <path>... [--blocked-by <task-id>=<task-id>,...] --json",
 				2,
 			),
 			journal: journalFor(

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

@@ -8,6 +8,8 @@ const PROTOCOL_MARKER = "<!-- immune-brain-tracker:v1 -->";
 const KIND_INITIATIVE_MARKER = "<!-- immune-brain:kind=initiative -->";
 const KIND_TASK_MARKER = "<!-- immune-brain:kind=task -->";
 const ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+/** Public scenario identity: an upstream Brainstorm id or a Spec-local id. */
+const SCENARIO_ID_PATTERN = /^(?:BR-SCN|SCN)-[1-9][0-9]{0,8}$/;
 const MAX_GH_OUTPUT = 8 * 1024 * 1024;
 const MAX_DIAGNOSTIC = 512;
 const GH_TIMEOUT_MS = 20_000;
@@ -62,6 +64,23 @@ export interface InitiativeProjection {
 	out_of_scope?: string[];
 }
 
+/**
+ * One user scenario projected onto the Task that first makes it observable.
+ * Public projection only: it never widens TaskIntent scope or authority.
+ */
+export interface InitiativeTaskScenario {
+	id: string;
+	actor: string;
+	given: string;
+	when: string;
+	then: string;
+	mode: "automated" | "manual";
+	/** Canonical acceptance IDs this scenario maps to. Required for automated; optional for manual. */
+	acceptance?: string[];
+	/** Why a deterministic check cannot prove this scenario. Required for manual. */
+	manual_reason?: string;
+}
+
 export interface InitiativePublicationInput {
 	initiative_id: string;
 	goal: string;
@@ -71,6 +90,8 @@ export interface InitiativePublicationInput {
 		intent: string;
 		acceptance: Array<{ id: string; summary: string }>;
 		projection?: TaskProjection;
+		/** Optional. Omitted or empty renders no User scenarios section for this Task. */
+		scenarios?: InitiativeTaskScenario[];
 	}>;
 	/**
 	 * Explicit amendment input: binds the caller's desired pending frontier to
@@ -179,6 +200,15 @@ export type TrackerOperation =
 		goal: string;
 		slices: InitiativeSlice[];
 		projection?: InitiativeProjection;
+		/** Derived Parent listing. Absent or empty renders no User scenarios section. */
+		scenarios?: Array<{
+			slice_id: string;
+			id: string;
+			mode: "automated" | "manual";
+			when: string;
+			then: string;
+			manual_reason?: string;
+		}>;
 	}
 	| {
 		op: "upsert-task";
@@ -191,6 +221,8 @@ export type TrackerOperation =
 		projection?: TaskProjection;
 		/** The canonical TaskIntent content hash this Task was prepared from. */
 		intent_hash?: string;
+		/** Public scenarios owned by this Task. Absent renders no User scenarios section. */
+		scenarios?: InitiativeTaskScenario[];
 	}
 	| {
 		op: "mark-terminal";
@@ -270,7 +302,7 @@ function countLiteral(value: string, needle: string): number {
 	return count;
 }
 
-function marker(name: "repo-id" | "initiative-id" | "task-id" | "slice-id" | "intent-hash", value: string | number): string {
+function marker(name: "repo-id" | "initiative-id" | "task-id" | "slice-id" | "intent-hash" | "scenarios", value: string | number): string {
 	return `<!-- immune-brain:${name}=${value} -->`;
 }
 
@@ -730,8 +762,9 @@ function stripPublishedIntentHash(body: string): string {
 	return body.replace(/<!-- immune-brain:intent-hash=[A-Za-z0-9][A-Za-z0-9._:-]{0,127} -->\n?/g, "");
 }
 
-function ownershipMarkerValue(body: string, name: "initiative-id" | "slice-id" | "task-id"): string | null {
-	const values = [...body.matchAll(new RegExp(`<!-- immune-brain:${name}=([A-Za-z0-9][A-Za-z0-9._-]{0,127}) -->`, "g"))];
+function ownershipMarkerValue(body: string, name: "initiative-id" | "slice-id" | "task-id" | "scenarios"): string | null {
+	const pattern = name === "scenarios" ? "[A-Za-z0-9%_!*'()~.-]+" : "[A-Za-z0-9][A-Za-z0-9._-]{0,127}";
+	const values = [...body.matchAll(new RegExp(`<!-- immune-brain:${name}=(${pattern}) -->`, "g"))];
 	return values.length === 1 ? values[0][1] : null;
 }
 
@@ -953,6 +986,160 @@ function listText(values: string[] | undefined, fallback: string): string {
 	return values?.length ? values.map((value) => `- ${value}`).join("\n") : fallback;
 }
 
+/**
+ * Child section after Acceptance criteria. Empty input returns "" so a Task
+ * without scenarios, and a publication with none at all, stays byte-identical.
+ */
+function childScenarioSection(scenarios: InitiativeTaskScenario[] | undefined): string {
+	if (!scenarios?.length) return "";
+	const items = scenarios.map((scenario) => {
+		const mapped = scenario.acceptance?.length ? scenario.acceptance.map((id) => `\`${id}\``).join(", ") : "none";
+		const visible = `Actor: ${scenario.actor}. Given: ${scenario.given}. When: ${scenario.when}. Then: ${scenario.then}.`;
+		if (scenario.mode === "manual")
+			return `- [ ] \`${scenario.id}\` (manual, ${mapped}): ${visible} Reason: ${scenario.manual_reason}.`;
+		return `- \`${scenario.id}\` (automated, ${mapped}): ${visible}`;
+	});
+	return `\n## User scenarios\n\n${items.join("\n")}\n`;
+}
+
+/**
+ * Parent listing after Testing strategy, derived from the Tasks. One plain
+ * bullet per scenario; no checkboxes. Empty input returns "".
+ */
+function parentScenarioSection(scenarios: Array<{ slice_id: string; id: string; mode: "automated" | "manual"; actor?: string; given?: string; when: string; then: string; manual_reason?: string }> | undefined): string {
+	if (!scenarios?.length) return "";
+	const items = scenarios.map((scenario) => {
+		const prefix = scenario.actor && scenario.given ? `Actor: ${scenario.actor}. Given: ${scenario.given}. ` : "";
+		const reason = scenario.manual_reason ? ` Reason: ${scenario.manual_reason}.` : "";
+		return `- \`${scenario.id}\` (Slice \`${scenario.slice_id}\`, ${scenario.mode}): ${prefix}When: ${scenario.when}. Then: ${scenario.then}.${reason}`;
+	});
+	return `\n## User scenarios\n\n${items.join("\n")}\n`;
+}
+
+
+type HistoricalScenarioListing = InitiativeTaskScenario & { slice_id: string };
+
+/**
+ * Read the Parent listings already published by historical Children. Their
+ * Child bytes stay untouched, but an amendment must keep those listings and
+ * reserve their IDs before it rebuilds the Parent or accepts pending input.
+ */
+function historicalScenarioListings(children: Iterable<{ body?: unknown }>): HistoricalScenarioListing[] | string {
+	const listings: HistoricalScenarioListing[] = [];
+	for (const child of children) {
+		if (typeof child.body !== "string") continue;
+		const sliceId = ownershipMarkerValue(child.body, "slice-id");
+		if (!sliceId) continue;
+		const markerStarts = [...child.body.matchAll(/<!-- immune-brain:scenarios=/g)].length;
+		if (markerStarts > 1) return `historical Slice ${sliceId} has duplicate scenarios markers`;
+		const encoded = ownershipMarkerValue(child.body, "scenarios");
+		if (encoded === null) {
+			if (markerStarts === 0) continue;
+			return `historical Slice ${sliceId} has a malformed scenarios marker`;
+		}
+		const malformed = `historical Slice ${sliceId} has a malformed scenarios marker`;
+		let decoded: unknown;
+		try { decoded = JSON.parse(decodeURIComponent(encoded)); }
+		catch { return malformed; }
+		let scenarios: InitiativeTaskScenario[] | undefined;
+		try { scenarios = normalizeTaskScenarios(decoded, `historical Slice ${sliceId}`, undefined, new Set()); }
+		catch { return malformed; }
+		// The marker is the only source of historical scenarios, so it must hold
+		// exactly what the publish path writes for these values: the same
+		// validator, re-encoded byte for byte. Anything else is an unamendable
+		// Child, and the batch is rejected before any remote write.
+		if (scenarios === undefined || encodeURIComponent(JSON.stringify(scenarios)) !== encoded) return malformed;
+		for (const scenario of scenarios) listings.push({ ...scenario, slice_id: sliceId });
+	}
+	return listings;
+}
+
+function retainHistoricalScenarioIds(children: Iterable<{ body?: unknown }>, seenScenarioIds = new Set<string>()): string | null {
+	const listings = historicalScenarioListings(children);
+	if (typeof listings === "string") return listings;
+	for (const listing of listings) {
+		if (seenScenarioIds.has(listing.id)) return `historical Slice ${listing.slice_id} repeats scenario id ${listing.id}`;
+		seenScenarioIds.add(listing.id);
+	}
+	return null;
+}
+
+/**
+ * Reject the whole batch, before any remote write, when a scenario is malformed
+ * or names an acceptance ID its TaskIntent lacks. Text uses the same public
+ * projection rules as every other projected field. When `acceptanceIds` is
+ * omitted the TaskIntent-bound existence check is skipped, which is what the
+ * historical read-back needs: a published marker already passed it once.
+ */
+function normalizeTaskScenarios(
+	value: unknown,
+	taskId: string,
+	acceptanceIds: Set<string> | undefined,
+	seenScenarioIds: Set<string>,
+): InitiativeTaskScenario[] | undefined {
+	if (value === undefined) return undefined;
+	if (!Array.isArray(value)) throw new Error(`Task ${taskId} scenarios must be an array`);
+	if (value.length === 0) return undefined;
+	return value.map((item, index) => {
+		const name = `Task ${taskId} scenarios[${index}]`;
+		if (!item || typeof item !== "object" || Array.isArray(item)) throw new Error(`${name} must be an object`);
+		const raw = item as Record<string, unknown>;
+		const required = ["id", "actor", "given", "when", "then", "mode"] as const;
+		for (const field of required) {
+			if (raw[field] === undefined) throw new Error(`${name} is missing ${field}`);
+		}
+		const id = typeof raw.id === "string" && SCENARIO_ID_PATTERN.test(raw.id) ? raw.id : null;
+		if (!id) throw new Error(`${name} id must match BR-SCN-<n> or SCN-<n>`);
+		if (seenScenarioIds.has(id)) throw new Error(`Task ${taskId} repeats scenario id ${id}`);
+		seenScenarioIds.add(id);
+		if (raw.mode !== "automated" && raw.mode !== "manual")
+			throw new Error(`${name} mode must be automated or manual`);
+		const acceptance = raw.acceptance === undefined
+			? undefined
+			: normalizedList(raw.acceptance, `${name}.acceptance`, 128)?.map((acceptanceId) => identifier(acceptanceId, `${name}.acceptance`));
+		if (acceptance && new Set(acceptance).size !== acceptance.length)
+			throw new Error(`${name} repeats an acceptance id`);
+		for (const acceptanceId of acceptance ?? []) {
+			if (acceptanceIds && !acceptanceIds.has(acceptanceId))
+				throw new Error(`Task ${taskId} scenario ${id} names unknown acceptance id ${acceptanceId}`);
+		}
+		if (raw.mode === "automated" && !acceptance?.length)
+			throw new Error(`Task ${taskId} scenario ${id} is automated with no acceptance id`);
+		if (raw.mode === "manual" && raw.manual_reason === undefined)
+			throw new Error(`Task ${taskId} scenario ${id} is manual without manual_reason`);
+		const scenario: InitiativeTaskScenario = {
+			id,
+			actor: projectionText(raw.actor, `${name}.actor`, 500),
+			given: projectionText(raw.given, `${name}.given`, 500),
+			when: projectionText(raw.when, `${name}.when`, 500),
+			then: projectionText(raw.then, `${name}.then`, 500),
+			mode: raw.mode,
+			...(acceptance ? { acceptance } : {}),
+			...(raw.manual_reason === undefined ? {} : { manual_reason: projectionText(raw.manual_reason, `${name}.manual_reason`, 500) }),
+		};
+		// The historical read-back re-applies these rules to the stored values, so
+		// each one must survive its own projection a second time. Escaping can grow
+		// a value past its bound and a restricted-context acceptance ID passes the
+		// pending path; either would make a published Child unamendable.
+		const roundTrip: Array<[string, string]> = [
+			["actor", scenario.actor],
+			["given", scenario.given],
+			["when", scenario.when],
+			["then", scenario.then],
+			...(scenario.manual_reason === undefined ? [] : [["manual_reason", scenario.manual_reason] as [string, string]]),
+		];
+		for (const [label, value] of roundTrip) {
+			if (projectionText(value, `${name}.${label}`, 500) !== value)
+				throw new Error(`${name}.${label} fails the public-projection round-trip`);
+		}
+		for (const acceptanceId of acceptance ?? []) {
+			if (projectionText(acceptanceId, `${name}.acceptance`, 128) !== acceptanceId || identifier(acceptanceId, `${name}.acceptance`) !== acceptanceId)
+				throw new Error(`${name}.acceptance fails the public-projection round-trip`);
+		}
+		return scenario;
+	});
+}
+
 function bodyLimitFailure(operation: TrackerOperation["op"], body: string, reserve = 0): GithubTrackerResult | null {
 	return Buffer.byteLength(body, "utf8") + reserve <= GITHUB_ISSUE_BODY_LIMIT
 		? null
@@ -973,7 +1160,7 @@ function createInitiativeBody(
 		KIND_INITIATIVE_MARKER,
 		marker("repo-id", repository.id),
 		marker("initiative-id", operation.initiative_id),
-	].join("\n")}\n\n${provenance}## How to use this Issue\n\n- Edit planning prose and Slice ordering directly after creation.\n- Keep each Slice marker attached to exactly one stable Slice entry.\n- The tracker never rewrites this Parent after creation; the tracker closes it as completed once every Slice Child is completed, and never closes it otherwise.\n\n## Problem\n\n${publicText(projection.problem ?? "The Initiative addresses the bounded delivery described below.", "projection.problem")}\n\n## Result\n\n${publicText(projection.result ?? operation.goal, "projection.result")}\n\n## Initiative design\n\n${publicText(projection.design ?? "Each Child preserves the shared Initiative decisions and boundaries recorded here.", "projection.design")}\n\n## Decisions\n\n${listText(projection.decisions, "- No additional Initiative decisions recorded.")}\n\n## Testing strategy\n\n${publicText(projection.testing_strategy ?? "Each Child closes from its focused acceptance verification.", "projection.testing_strategy")}\n\n## Out of scope\n\n${listText(projection.out_of_scope, "- Unrelated work outside this Initiative.")}\n\n## Slices\n\n${operation.slices.length + historicalSlices.length === 0 ? "No Slices recorded yet." : [...historicalSlices, ...operation.slices.map((slice) => `- [ ] ${marker("slice-id", slice.id)} **${slice.id}**: ${slice.result ?? slice.goal}${slice.blocked_by?.length ? ` (blocked by: ${slice.blocked_by.join(", ")})` : ""}`)].join("\n")}\n\n${ISSUE_FOOTER}\n`;
+	].join("\n")}\n\n${provenance}## How to use this Issue\n\n- Edit planning prose and Slice ordering directly after creation.\n- Keep each Slice marker attached to exactly one stable Slice entry.\n- The tracker never rewrites this Parent after creation; the tracker closes it as completed once every Slice Child is completed, and never closes it otherwise.\n\n## Problem\n\n${publicText(projection.problem ?? "The Initiative addresses the bounded delivery described below.", "projection.problem")}\n\n## Result\n\n${publicText(projection.result ?? operation.goal, "projection.result")}\n\n## Initiative design\n\n${publicText(projection.design ?? "Each Child preserves the shared Initiative decisions and boundaries recorded here.", "projection.design")}\n\n## Decisions\n\n${listText(projection.decisions, "- No additional Initiative decisions recorded.")}\n\n## Testing strategy\n\n${publicText(projection.testing_strategy ?? "Each Child closes from its focused acceptance verification.", "projection.testing_strategy")}\n${parentScenarioSection(operation.scenarios)}\n## Out of scope\n\n${listText(projection.out_of_scope, "- Unrelated work outside this Initiative.")}\n\n## Slices\n\n${operation.slices.length + historicalSlices.length === 0 ? "No Slices recorded yet." : [...historicalSlices, ...operation.slices.map((slice) => `- [ ] ${marker("slice-id", slice.id)} **${slice.id}**: ${slice.result ?? slice.goal}${slice.blocked_by?.length ? ` (blocked by: ${slice.blocked_by.join(", ")})` : ""}`)].join("\n")}\n\n${ISSUE_FOOTER}\n`;
 }
 
 async function createInitiative(
@@ -1056,7 +1243,8 @@ function childBody(
 		// idempotent replay can compare against what was actually published
 		// instead of against whatever bytes it happens to read this time.
 		...(operation.intent_hash ? [marker("intent-hash", operation.intent_hash)] : []),
-	].join("\n")}\n\n## Parent\n\n| Initiative | \`${operation.initiative_id}\` |\n| Parent Issue | [#${parent.number}](${parent.url}) |\n| Slice | \`${operation.slice_id}\` |\n| Risk | \`${operation.risk}\` |\n\n## Current behavior\n\n${publicText(projection.current_behavior ?? "The current behavior is defined by the repository's existing contract.", "projection.current_behavior")}\n\n## Desired behavior\n\n${publicText(projection.desired_behavior ?? projection.result ?? operation.goal, "projection.desired_behavior")}\n\n## Key interfaces\n\n${listText(projection.key_interfaces, "- Canonical TaskIntent acceptance and Kernel lifecycle remain authoritative.")}\n\n## Acceptance criteria\n\n${acceptance}\n\n## Verification\n\n${publicText(projection.verification ?? "Run the focused acceptance verification declared by the TaskIntent.", "projection.verification")}\n\n## Blocked by\n\n${projection.blocked_by?.length ? projection.blocked_by.map((id) => `- \`${identifier(id, "blocked_by task_id")}\``).join("\n") : "None"}\n\n## Out of scope\n\n${listText(projection.out_of_scope, "- Scope not declared by the validated TaskIntent.")}\n\n## Agent handoff\n\n${publicText(projection.agent_handoff ?? "Implement only the bounded TaskIntent result and run the focused checks. Do not widen scope or treat GitHub as authorization.", "projection.agent_handoff")}\n\n${ISSUE_FOOTER}\n`;
+		...(operation.scenarios?.length ? [marker("scenarios", encodeURIComponent(JSON.stringify(operation.scenarios)))] : []),
+	].join("\n")}\n\n## Parent\n\n| Initiative | \`${operation.initiative_id}\` |\n| Parent Issue | [#${parent.number}](${parent.url}) |\n| Slice | \`${operation.slice_id}\` |\n| Risk | \`${operation.risk}\` |\n\n## Current behavior\n\n${publicText(projection.current_behavior ?? "The current behavior is defined by the repository's existing contract.", "projection.current_behavior")}\n\n## Desired behavior\n\n${publicText(projection.desired_behavior ?? projection.result ?? operation.goal, "projection.desired_behavior")}\n\n## Key interfaces\n\n${listText(projection.key_interfaces, "- Canonical TaskIntent acceptance and Kernel lifecycle remain authoritative.")}\n\n## Acceptance criteria\n\n${acceptance}\n${childScenarioSection(operation.scenarios)}\n## Verification\n\n${publicText(projection.verification ?? "Run the focused acceptance verification declared by the TaskIntent.", "projection.verification")}\n\n## Blocked by\n\n${projection.blocked_by?.length ? projection.blocked_by.map((id) => `- \`${identifier(id, "blocked_by task_id")}\``).join("\n") : "None"}\n\n## Out of scope\n\n${listText(projection.out_of_scope, "- Scope not declared by the validated TaskIntent.")}\n\n## Agent handoff\n\n${publicText(projection.agent_handoff ?? "Implement only the bounded TaskIntent result and run the focused checks. Do not widen scope or treat GitHub as authorization.", "projection.agent_handoff")}\n\n${ISSUE_FOOTER}\n`;
 }
 
 /** Derived approved-final content and baseline-derived historical evidence for an amendment. */
@@ -1094,6 +1282,26 @@ function approvedAmendmentContent(
 			blocked_by: operation.projection?.blocked_by,
 		})),
 	}) as Extract<TrackerOperation, { op: "create-initiative" }>;
+	const historicalScenarios = historicalScenarioListings([...amendment.historical.values()].map((binding) => ({ body: binding.body })));
+	if (typeof historicalScenarios === "string") return historicalScenarios;
+	parent.scenarios = [
+		...historicalScenarios.map((scenario) => ({
+			slice_id: scenario.slice_id,
+			id: scenario.id,
+			mode: scenario.mode,
+			when: scenario.when,
+			then: scenario.then,
+			...(typeof scenario.manual_reason === "string" ? { manual_reason: scenario.manual_reason } : {}),
+		})),
+		...prepared.order.flatMap((operation) =>
+			(operation.scenarios ?? []).map((scenario) => ({
+				slice_id: operation.slice_id,
+				id: scenario.id,
+				mode: scenario.mode,
+				when: scenario.when,
+				then: scenario.then,
+			}))),
+	];
 	const historicalSliceIds: Set<string> = new Set();
 	for (const child of amendment.historical.values()) {
 		const sliceId = ownershipMarkerValue(child.body, "slice-id");
@@ -1120,7 +1328,7 @@ function approvedAmendmentContent(
 	void sourceStub;
 	// The approved final Parent body fixes the Slices checklist, so every Child
 	// title is numbered from the Initiative order rather than from this batch.
-	const parentBody = createInitiativeBody(sourceStub.repository, parent, historicalSlices);
+	const parentBody = createInitiativeBody(sourceStub.repository, { ...parent, scenarios: parent.scenarios }, historicalSlices);
 	const oversizedParent = bodyLimitFailure("create-initiative", parentBody);
 	if (oversizedParent) return `${oversizedParent.status}: ${oversizedParent.message}`;
 	const pendingContent = new Map<string, { title: string; body: string }>();
@@ -1587,6 +1795,7 @@ function validateOperation(operation: TrackerOperation): TrackerOperation {
 				id: identifier(item.id, `acceptance[${index}].id`),
 				summary: projectionText(item.summary, `acceptance[${index}].summary`, 500),
 			})),
+			scenarios: operation.scenarios,
 		};
 		taskIssueTitle(normalized);
 		return normalized;
@@ -1727,10 +1936,16 @@ function preflightPublication(root: string, input: InitiativePublicationInput):
 	// projection is stamped with them, so a missing or oversized display name
 	// fails the batch closed with zero remote writes.
 	const initiativeShortName = initiativeDisplayNames(input.projection).shortName;
+	const seenScenarioIds = new Set<string>();
+	if (input.amendment) {
+		const historicalBindings = (input.amendment.historical ?? []).map((child) => (child as { binding?: { body?: unknown } }).binding ?? {});
+		const historicalScenarioError = retainHistoricalScenarioIds(historicalBindings, seenScenarioIds);
+		if (historicalScenarioError) throw new Error(historicalScenarioError);
+	}
 	const publications = input.tasks.map((task, index) => {
 		if (!task || typeof task !== "object" || Array.isArray(task)) throw new Error(`tasks[${index}] must be an object`);
 		if (typeof task.intent !== "string") throw new Error(`tasks[${index}].intent must be a string`);
-		return taskPublication(root, input.initiative_id, task.slice_id, task.intent, task.acceptance, task.projection, index + 1, initiativeShortName);
+		return taskPublication(root, input.initiative_id, task.slice_id, task.intent, task.acceptance, task.projection, task.scenarios, index + 1, initiativeShortName, seenScenarioIds);
 	});
 	const historicalIds = new Set<string>();
 	if (input.amendment) {
@@ -1772,6 +1987,15 @@ function preflightPublication(root: string, input: InitiativePublicationInput):
 			blocked_by: operation.projection?.blocked_by,
 		})),
 	}) as Extract<TrackerOperation, { op: "create-initiative" }>;
+	initiative.scenarios = operations.flatMap((operation) =>
+		(operation.scenarios ?? []).map((scenario) => ({
+			slice_id: operation.slice_id,
+			id: scenario.id,
+			mode: scenario.mode,
+			when: scenario.when,
+			then: scenario.then,
+		})),
+	);
 	const intentBindings = new Map(publications.map((publication) => [publication.operation.task_id, {
 		intent_path: publication.intent_path,
 		intent_content_hash: publication.intent_content_hash,
@@ -2874,8 +3098,10 @@ function taskPublication(
 	intentPath: string,
 	acceptance: unknown,
 	projection: TaskProjection | undefined,
+	scenarios: unknown,
 	ordinal: number,
 	initiativeShortName: string,
+	seenScenarioIds: Set<string>,
 ): PreparedPublicationTask {
 	const absoluteRoot = resolve(root);
 	const absolutePath = resolve(absoluteRoot, intentPath);
@@ -2901,6 +3127,7 @@ function taskPublication(
 	});
 	const missingIds = [...expectedIds].filter((id) => !publicById.has(id));
 	if (missingIds.length) throw new Error(`Task ${taskId} is missing public acceptance ids: ${missingIds.join(", ")}`);
+	const normalizedScenarios = normalizeTaskScenarios(scenarios, taskId, expectedIds, seenScenarioIds);
 	// Display names are stamped from the Initiative so every Child title carries
 	// the same short name and its declared Slice position; an explicitly
 	// supplied value must agree, never silently override.
@@ -2924,6 +3151,7 @@ function taskPublication(
 			acceptance: intent.acceptance.map((item) => publicById.get(item.id)!),
 			projection: stampedProjection,
 			intent_hash: read.content_hash,
+			scenarios: normalizedScenarios,
 		}) as Extract<TrackerOperation, { op: "upsert-task" }>,
 		intent_path: read.intent_ref.path,
 		intent_content_hash: read.content_hash,

package/plugins/immune-brain/runtime/kernel/runtime_contracts.json

@@ -0,0 +1,7 @@
+{
+  "contract": "immune_brain/runtime_contracts/v1",
+  "task_record": "assurance_kernel/task_record/v4",
+  "task_tombstone": "assurance_kernel/task_tombstone/v2",
+  "assurance_projection": "assurance_kernel/assurance_projection/v1",
+  "kernel_store_schema": 1
+}