immune-brain 5.2.0 → 5.5.1

package/README.md

@@ -556,9 +556,9 @@ Key invariants:
 
 ## Unattended Batch Runs
 
-When an Initiative contains multiple ready children, developers can run the entire batch unattended via the Host's privileged `start_unattended_batch` tool without manually driving `imm-run` for each child task.
+Enter `imm-run <Parent Issue>` to execute its complete approved plan through the Host's `start_unattended_batch` tool and native authorization. Enter `imm-run <Slice/Child Issue>` to execute only that Slice after prerequisite delivery checks; it starts no siblings or predecessors.
 
-Immune-Brain supports two batch execution modes: **Default Serial Mode** and **Parallel Batch Lanes**.
+The Parent chooses **Managed Serial Mode** or **Parallel Batch Lanes** before confirmation, using dependency readiness, scope conflicts, Lane capacity and supervised Host capability. Without Lane supervision it runs serially in the same Host. Status questions preserve the binding; explicit cancellation releases continuation.
 
 ### 1. Batch Execution Modes Overview
 
@@ -573,9 +573,9 @@ Immune-Brain supports two batch execution modes: **Default Serial Mode** and **P
 
 ### 2. Batch Authority & Invariants
 
-- **Explicit Entry & Single Authorization:** No batch state or branch exists before calling `start_unattended_batch`; without it, `imm-run` behaves identically to single-task enrollment. The native gate (Pi TUI dialog or Claude MCP elicitation) displays the ordered child list and global `plan_digest`; this single user confirmation constitutes complete Batch Authorization.
+- **Explicit Entry & Single Authorization:** Parent selection invokes `start_unattended_batch` directly; a standalone Task or Child uses single-task Enrollment. Critical-only and delivered-only Parents use native task gates and final observations without an empty batch grant. The native gate (Pi TUI dialog or Claude MCP elicitation) displays the ordered child list and global `plan_digest`; this single user confirmation constitutes complete Batch Authorization.
 - **Child Authority Invariance:** A batch merely bundles authorization scope without weakening engineering rigor. Every child is still individually enrolled, scope-frozen, QA-verified via authentic child processes, reviewed in isolation, and settled with its own `TaskRecord`. A batch is a scope of authorization, not a new authority layer.
-- **Deterministic Boundaries:** Only runs published, non-`critical` children. Any required human decision (`needs_human`), budget/timeout interruption, or integration error halts the batch safely, marking dependent children as `skipped_blocked` rather than reordering. Runners never push, open PRs, or make arbitrary decisions.
+- **Deterministic Boundaries:** Ordinary children use batch authorization; ready `critical` children use separate native Enrollment. Ordinary failures receive bounded repair. A blocker parks its dependent branch while independent work continues. Parent success and closure require every necessary delivery integrated and final verification passing on the final HEAD; later code defects receive a validated repair candidate and fresh native Enrollment. Runners never push, open PRs, or make arbitrary decisions.
 
 ### 3. Parallel Batch Lanes Lifecycle & Architecture
 

package/README.zh-CN.md

@@ -559,9 +559,9 @@ flowchart TD
 
 ## 无人值守批次运行
 
-当一个 Initiative 下包含多个已就绪的 child 任务时，开发者无需逐个手动触发 `imm-run`，可通过 Host 原生 privileged tool `start_unattended_batch` 进行整批无人值守推进。
+输入 `imm-run <Parent Issue>`，会自动选择完整已批准计划，通过 Host 的 `start_unattended_batch` 和 native 授权执行。输入 `imm-run <Slice/Child Issue>` 则先检查前置交付，只执行该 Slice，不启动前置或兄弟任务。
 
-系统支持两种批次运行形态：**默认串行模式** 与 **多 Lane 并行模式（Parallel Batch Lanes）**。
+Parent 在确认前根据依赖、scope 冲突、Lane 容量及受监督 Host 能力，选择 **Managed 串行模式** 或 **多 Lane 并行模式**；缺少 Lane supervision 时在同一 Host 串行执行。状态询问保留运行绑定，显式取消解除续接。
 
 ### 1. 批次运行模式概览
 
@@ -576,9 +576,9 @@ flowchart TD
 
 ### 2. 批次授权与运行红线
 
-- **入口显式且单一授权：** 未调用 `start_unattended_batch` 之前不存在任何批次状态或分支；未调用时 `imm-run` 行为与逐任务 Enrollment 完全一致。调用时由原生 gate（Pi TUI 弹窗或 Claude MCP elicitation）一次性展示有序任务清单与全局 `plan_digest`，用户的单次确认即为整批执行提供完备授权。
+- **入口显式且单一授权：** Parent 入口直接调用 `start_unattended_batch`；独立 Task 和 Child 走单任务 Enrollment。critical-only 和 delivered-only Parent 使用单任务 native gate 和最终验证观察，不制造空批次授权。调用时由原生 gate（Pi TUI 弹窗或 Claude MCP elicitation）一次性展示有序任务清单与全局 `plan_digest`，用户的单次确认即为整批执行提供完备授权。
 - **Child Authority 守恒：** 批次仅代表授权范围的聚合，绝非降低工程标准。每个 child 依然由 Kernel 单独执行 Enrollment、物理 Scope 冻结、真实子进程 QA、隔离 Review 与独立的 `TaskRecord` 结算。批次只是一次授权的覆盖范围，不是新的授权层级。
-- **确定性执行边界：** 仅推进已发布且非 `critical` 的 child 任务；遇到人工决策挂起（`needs_human`）、预算/超时中断或提交异常时立即安全暂停批次，被阻断任务的下游依赖标记为跳过（`skipped_blocked`）而非无序推进。批次运行器不擅自 push、不开 PR、不代替用户结算决策。
+- **确定性执行边界：** 普通 child 使用批次授权，已就绪的 `critical` child 单独 native Enrollment。普通失败自动进行有界修复；阻塞只停放其依赖分支，独立任务继续。所有必需交付集成、最终 HEAD 验证通过后才报告 Parent 成功并关闭 Issue；结算后发现的代码缺陷先生成、验证修复候选，再打开新的 native Enrollment。批次运行器不擅自 push、不开 PR、不代替用户结算决策。
 
 ### 3. 多 Lane 并行流水线与架构（Parallel Batch Lanes）
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "immune-brain",
-  "version": "5.2.0",
+  "version": "5.5.1",
   "description": "Immune-Brain agent skill system",
   "publishConfig": {
     "access": "public",
@@ -83,6 +83,7 @@
     "plugins/immune-brain/runtime/role_prompt_bridge.ts",
     "plugins/immune-brain/runtime/loop_contract.ts",
     "plugins/immune-brain/runtime/plugin_version.ts",
+    "plugins/immune-brain/runtime/plugin_source_skew.ts",
     "plugins/immune-brain/runtime/assurance",
     "plugins/immune-brain/runtime/unattended",
     "plugins/immune-brain/runtime/claude",

package/plugins/immune-brain/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "immune-brain",
-  "version": "5.2.0",
+  "version": "5.5.1",
   "description": "Immune-Brain Claude Code Host: native Enrollment, QA, Review, and Kernel settlement.",
   "author": {
     "name": "Immune-Brain Team"

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

@@ -15,16 +15,20 @@ import { resolve } from "node:path";
 // from the Kernel's own prepare module.
 import { LITERAL_USER_ACTOR_ID } from "../runtime/kernel/actor_identity";
 import { createEnrollmentAuthorityRegistry } from "../runtime/kernel/enrollment_authority";
+import { assertIsolatedTaskPrerequisites } from "../runtime/github_issue_tracker";
 import { preparePiCanary, revalidatePiCanary } from "../runtime/assurance/enrollment";
 import { evaluateCanaryEligibility } from "../runtime/kernel/canary_eligibility";
-import { enrollTask, EnrollmentRehearsalError } from "../runtime/kernel/enrollment";
+import { enrollmentScopeDisclosure, enrollTask, EnrollmentRehearsalError } from "../runtime/kernel/enrollment";
 import { reconcileKernelAuthority, withKernelStoreLock } from "../runtime/kernel/storage";
 import { inspectStorageLayout } from "../runtime/kernel/storage_paths";
-import { migrateLegacyLayout } from "../runtime/kernel/storage_layout_migration";
+import { commitPendingMigrationDiff, migrateAndCommitLegacyLayout } from "../runtime/kernel/storage_layout_migration";
 import {
+	commitEnrollmentPreconditions,
+	commitUnbornEnrollmentPreconditions,
 	inspectEnrollmentGitBase,
 	enrollmentGitBaseNotice,
 	initializeEnrollmentGitBase,
+	preconditionCommitNote,
 } from "../runtime/assurance/enrollment_git_base";
 import { piRunEntryRefusal, readTaskIntentForRecord } from "./imm-canary-work";
 import {
@@ -280,6 +284,8 @@ async function classifyCommitFailure(
 	);
 }
 
+const terminalWithoutCommitNote = terminal;
+
 async function executeForegroundEnrollment(
 	root: string,
 	action: EnrollmentAction,
@@ -293,6 +299,14 @@ async function executeForegroundEnrollment(
 ): Promise<EnrollmentTerminal> {
 	let stage = "preparing";
 	let gitBaseNote = "";
+	// Every unsuccessful exit reports the Git effects that preceded authority.
+	const terminal: typeof terminalWithoutCommitNote = (action, taskId, state, stage, summary, nextAction) => {
+		if (state !== "completed" && gitBaseNote) {
+			if (summary.endsWith(gitBaseNote)) summary = summary.slice(0, -gitBaseNote.length);
+			summary = `${summary.slice(0, 4_096 - gitBaseNote.length)}${gitBaseNote}`;
+		}
+		return terminalWithoutCommitNote(action, taskId, state, stage, summary, nextAction);
+	};
 	const progress = (nextStage: string, summary: string) => {
 		stage = nextStage;
 		const update = updateResult(action, taskId, nextStage, summary);
@@ -314,75 +328,32 @@ async function executeForegroundEnrollment(
 		const now = new Date().toISOString();
 		let taskIntent: Awaited<ReturnType<typeof readTaskIntentForRecord>>;
 
-		// Storage-layout gate (BR-REQ-005/006): enrollment is the stateful
-		// mutation boundary. Kernel transaction markers recover under the
-		// store lock; the one-release migrator relocates an owner-free legacy
-		// layout and stops, and the literal user retries after committing the
-		// affected migration diff. Repreparation never proceeds on a dirty
-		// or blocked layout.
+		// Recover markers first; only a pending diff or supported legacy import may advance.
 		{
-			const recoverLayout = async (): Promise<
-				EnrollmentTerminal | undefined
-			> => {
-				try {
-					await withKernelStoreLock(root, () => undefined);
-				} catch (error) {
-					return terminal(
-						action,
-						taskId,
-						"blocked",
-						stage,
-						`Kernel transaction recovery failed before enrollment: ${errorMessage(error)}`,
-						"resolve the pending Kernel transaction marker and retry",
-					);
-				}
-				const inspection = await inspectStorageLayout(root);
-				if (inspection.layout === "ready") return undefined;
-				if (
-					inspection.layout === "migration_required" ||
-					inspection.layout === "recovery_required"
-				) {
-					const migration = await migrateLegacyLayout(root);
-					if (migration.outcome === "migrated")
-						return terminal(
-							action,
-							taskId,
-							"blocked",
-							stage,
-							`Legacy storage migrated (${migration.affected_paths.length} paths); commit the affected migration diff and retry enrollment`,
-							"commit .imm/audit/** and .imm/legacy paths, then retry",
-						);
-					if (migration.outcome === "migration_uncommitted")
-						return terminal(
-							action,
-							taskId,
-							"blocked",
-							stage,
-							`Migration completed but affected paths are uncommitted: ${migration.affected_paths.join(", ")}`,
-							"commit the affected migration diff, then retry",
-						);
-					return terminal(
-						action,
-							taskId,
-						"blocked",
-						stage,
-						`Enrollment blocked by storage layout (${migration.outcome}): ${migration.reason ?? inspection.reason ?? ""}`,
-						"resolve the reported layout condition and retry",
-					);
-				}
-				return terminal(
-					action,
-					taskId,
-					"blocked",
-					stage,
-					`Enrollment blocked by storage layout (${inspection.layout}): ${inspection.reason ?? ""}`,
-					"resolve the reported layout condition and retry",
-				);
-			};
-			const blocked = await recoverLayout();
-			if (blocked) return blocked;
+			let inspection = inspectStorageLayout(root);
+			if (inspection.layout === "migration_uncommitted") {
+				gitBaseNote += preconditionCommitNote(commitPendingMigrationDiff(root, signal));
+				inspection = inspectStorageLayout(root);
+			}
+			if (inspection.layout === "migration_required") {
+				const migration = migrateAndCommitLegacyLayout(root, signal);
+				for (const commit of migration.commits)
+					gitBaseNote += preconditionCommitNote({ committed: true, commit, paths: migration.affected_paths });
+				if (migration.outcome !== "migrated" && migration.outcome !== "already_migrated")
+					return terminal(action, taskId, "blocked", stage, `Enrollment blocked by storage layout (${migration.outcome}): ${migration.reason ?? ""}`, "resolve the reported layout condition and retry");
+				inspection = inspectStorageLayout(root);
+			}
+			if (inspection.layout !== "ready")
+				return terminal(action, taskId, "blocked", stage, `Enrollment blocked by storage layout (${inspection.layout}): ${inspection.reason ?? ""}`, "resolve the reported layout condition and retry");
+			await withKernelStoreLock(root, () => undefined);
 		}
 
+		// Commit the task's own dirty preconditions first, so every read and the
+		// confirmation below bind the HEAD that results. An owned workspace
+		// commits nothing.
+		gitBaseNote += preconditionCommitNote(await commitEnrollmentPreconditions(root, taskId, signal));
+		signal.throwIfAborted();
+
 		try {
 			taskIntent = await readTaskIntentForRecord(root, taskId);
 		} catch (error) {
@@ -438,6 +409,7 @@ async function executeForegroundEnrollment(
 				`task ${taskId} is terminal in this worktree`,
 				"inspect authority state; do not retry enrollment",
 			);
+		await assertIsolatedTaskPrerequisites(root, taskId);
 		let preparation = await preparePiCanary(root, { task_id: taskId, now });
 		signal.throwIfAborted();
 		if (!preparation.intent)
@@ -479,6 +451,9 @@ async function executeForegroundEnrollment(
 		// Enrollment binds authority to the validated intent. Acceptance descriptors
 		// execute only during post-implementation deterministic QA.
 		const confirmedContentHash = preparation.intent.content_hash;
+		// In-scope changes that already exist are shown in the gate and only the
+		// ones shown are claimed as task work on confirmation.
+		const disclosure = enrollmentScopeDisclosure(root, taskId);
 		{
 			const confirmationSummary = [
 				`Task: ${taskId}`,
@@ -487,6 +462,7 @@ async function executeForegroundEnrollment(
 				`Scope: ${taskIntent.intent.scope_hint.length > 0 ? taskIntent.intent.scope_hint.join(", ") : "(none)"}`,
 				`Acceptance: ${taskIntent.intent.acceptance.length} descriptor(s)`,
 				...(gitNotice ? [gitNotice] : []),
+				...(disclosure.notice ? [disclosure.notice] : []),
 			].join("\n");
 			const confirmationDetails = [
 				`Acceptance descriptors:`,
@@ -510,7 +486,7 @@ async function executeForegroundEnrollment(
 			);
 			if (signal.aborted) return cancelled();
 			if (!confirmed)
-				return terminal(action, taskId, "rejected", stage, "Enrollment confirmation was rejected; zero authority writes were requested", "invoke the launcher again only if enrollment is still intended");
+				return terminal(action, taskId, "rejected", stage, `Enrollment confirmation was rejected; zero authority writes were requested${gitBaseNote}`, "invoke the launcher again only if enrollment is still intended");
 		}
 		{
 			let liveEarly: string | null = null;
@@ -541,7 +517,14 @@ async function executeForegroundEnrollment(
 		signal.throwIfAborted();
 
 		preparation = await initializeEnrollmentGitBase(root, { task_id: taskId, now }, preparation, gitBase, signal);
-		if (gitBase.state === "unborn") gitBaseNote = `; empty initial commit ${preparation.git_base_head} remains`;
+		if (gitBase.state === "unborn") {
+			gitBaseNote += `; empty initial commit ${preparation.git_base_head} remains`;
+			// The scope could not be compared with an unborn HEAD; commit it now
+			// that a base exists and bind the HEAD that results.
+			const late = await commitUnbornEnrollmentPreconditions(root, { task_id: taskId, now }, preparation, signal);
+			gitBaseNote += preconditionCommitNote(late.result);
+			preparation = late.preparation;
+		}
 		if (!preparation.intent) throw new Error("Enrollment requires a readable TaskIntent");
 		signal.throwIfAborted();
 
@@ -565,6 +548,7 @@ async function executeForegroundEnrollment(
 			// zero writes, and once it accepts, commit is no longer cancellable.
 			const outcome = await enrollTask(root, registry, {
 				binding,
+				disclosed_scope_paths: disclosure.paths,
 				now,
 				checkpoint: () => {
 					if (signal.aborted) return false;