immune-brain 3.3.0 → 3.5.0

package/README.md

@@ -14,7 +14,7 @@ Immune-Brain adds a structured engineering workflow on top of Pi:
 - **Plans become trackable tasks** (`TaskIntent` + `TaskRecord`) so progress survives across sessions, not just chat history.
 - **Quality is enforced by code, not promises** — automated QA and isolated review must pass before a task is marked done.
 
-Pi and Claude Code are the supported hosts. Undeclared adapters remain unsupported. Minimum Claude Code is `2.1.199`. Historical real-Host evidence is archived under [docs/verification/archive/](docs/verification/archive/); deterministic package and authority checks gate current releases. Either host can use the model provider you configure — Immune-Brain works on top of Kernel authority, not a vendor chat.
+Pi and Claude Code are the supported hosts. Undeclared adapters remain unsupported. Minimum Claude Code is `2.1.236`, the lowest version verified with interactive server-initiated MCP elicitation. Current real-Host evidence is recorded in [Claude native elicitation conformance](docs/verification/claude-native-elicitation-authority-conformance.md); historical reports remain under [docs/verification/archive/](docs/verification/archive/). Either host can use the model provider you configure — Immune-Brain works on top of Kernel authority, not a vendor chat.
 
 ---
 
@@ -191,7 +191,7 @@ docs/specs/                           # Living specs (updated in place)
 
 **QA failed — what now?** QA returns `rework` or `replan_required`. `imm-loop` routes back to the executor or to `imm-planner` for scope changes. No manual reset needed.
 
-**Can I use it outside Pi?** Yes. Local interactive Claude Code is supported from version `2.1.199`; use the Claude plugin for the same Kernel-backed workflow.
+**Can I use it outside Pi?** Yes. Local interactive Claude Code is supported from version `2.1.236`; its plugin uses a digest-bound native MCP elicitation gate for the same Kernel-backed workflow.
 
 ---
 

package/README.zh-CN.md

@@ -14,7 +14,7 @@ Immune-Brain 在 Pi 之上提供结构化的工程工作流：
 - **计划变为可追踪的任务**（`TaskIntent` + `TaskRecord`），进度落盘持久化，不依赖对话历史。
 - **质量由代码强制保障** — 自动化 QA 与隔离式 Review 必须通过，任务才会完成。
 
-Pi 与 Claude Code 是支持的宿主。未声明的适配器仍不受支持。Claude Code 最低版本为 `2.1.199`。历史真实 Host 证据归档于 `docs/verification/archive/`；当前发布由确定性的 package 与 authority 检查把关。
+Pi 与 Claude Code 是支持的宿主。未声明的适配器仍不受支持。Claude Code 最低版本为 `2.1.236`，这是已通过交互式 server-initiated MCP elicitation 验证的最低版本。当前真实 Host 证据见 `docs/verification/claude-native-elicitation-authority-conformance.md`；历史报告归档于 `docs/verification/archive/`。
 
 ---
 
@@ -64,7 +64,7 @@ mise run check-dist-sync    # 校验生成文档同步
 
 Pi 会自动路由：需求模糊走澄清，目标明确走规划。
 
-**2. 确认计划** — Planner 会在 `docs/plans/` 生成 `TaskIntent`（范围、风险等级、验收条件）。检查无误后在 TUI 弹窗中确认 Enrollment（所有风险等级都需要确认，确认前零写入）。
+**2. 确认计划** — Planner 会在 `docs/plans/` 生成 `TaskIntent`（范围、风险等级、验收条件）。检查无误后由当前 Host 的原生 gate 确认 Enrollment（所有风险等级都需要确认，确认前零 authority 写入）。
 
 **3. 开始执行** — `imm-loop` 按计划执行、跑 QA、触发 Review。按提示暂存任务拥有的文件：
 
@@ -191,7 +191,7 @@ docs/specs/                           # Living specs（原地更新）
 
 **QA 失败怎么办？** QA 返回 `rework` 或 `replan_required`，`imm-loop` 会自动路由回 Executor 或 `imm-planner` 调整范围，无需手动重置。
 
-**可以在 Pi 之外使用吗？** 可以在本地交互式 Claude Code 中使用同一套 Kernel；未声明的适配器不受支持。
+**可以在 Pi 之外使用吗？** 可以从 `2.1.236` 起在本地交互式 Claude Code 中使用同一套 Kernel；Claude plugin 通过绑定 digest 的原生 MCP elicitation gate 获取 authority，未声明的适配器不受支持。
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "immune-brain",
-  "version": "3.3.0",
+  "version": "3.5.0",
   "description": "Immune-Brain agent skill system",
   "publishConfig": {
     "access": "public",

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

@@ -1,6 +1,6 @@
 {
   "name": "immune-brain",
-  "version": "3.3.0",
+  "version": "3.5.0",
   "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-work.ts

@@ -16,7 +16,7 @@
 
 import { execFileSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
@@ -58,12 +58,15 @@ import {
 	clearTerminalTaskRailOnInput,
 	loopResultDetails,
 	notifyOnce,
+	presentTaskOverviewOverlay,
 	presentTaskRail,
 	presentTaskRailResult,
 	renderStructuredCall,
 	renderStructuredResult,
 	requestAuthorityDialog,
 	resetInteractionPresentation,
+	type TaskOverviewEntry,
+	type TaskRailState,
 	type UserAttentionEventV1,
 	type UserAttentionReason,
 } from "./pi-canary-interaction";
@@ -346,6 +349,23 @@ export default function (
 		return { action: "continue" } as const;
 	});
 
+	pi.registerCommand("imm-tasks", {
+		handler: async (_args: string, ctx?: ExtensionContext) => {
+			if (!ctx || ctx.mode !== "tui") return;
+			try {
+				const view = await buildTaskOverview(ctx.cwd);
+				await presentTaskOverviewOverlay(ctx, view);
+			} catch (error) {
+				notifyOnce(
+					ctx,
+					"task-overview:command",
+					`Task overview failed: ${error instanceof Error ? error.message : String(error)}`,
+					"warning",
+				);
+			}
+		},
+	});
+
 	pi.on("session_start", async (_event: unknown, ctx?: ExtensionContext) => {
 		progression.onSessionStart();
 		if (!ctx) return;
@@ -1107,6 +1127,69 @@ function diffHashOf(root: string, record: NonNullable<TaskRecordRead["record"]>)
 // Kernel module; this wrapper only binds the host diff provider. The retired
 // active-v2 migrator is gone: a v2 TaskRecord in the state layout is a
 // fail-closed projection error, never an automatic migration trigger.
+/**
+ * Read-only task overview for the /imm-tasks overlay: the active claim's
+ * task plus every not-enrolled docs/plans/*.intent.json draft. Settled
+ * history stays on the CLI (BR-DEC-3); no second state source is created.
+ */
+async function buildTaskOverview(root: string): Promise<{
+	active: TaskOverviewEntry | null;
+	pending: TaskOverviewEntry[];
+}> {
+	const claim = await readBackendClaim(root);
+	let active: TaskOverviewEntry | null = null;
+	if (claim) {
+		const projection = await projectAssuranceState(root, claim.task_id);
+		if (!projection.error) {
+			const state = projection.projection;
+			const obligation = String(state.next_obligation);
+			active = {
+				task_id: claim.task_id,
+				state: overviewRailState(state.lifecycle, obligation),
+				result: `Assurance: ${obligation.replace(/_/g, " ")}`,
+				next: `${state.fresh_acceptance_ids.length}/${state.fresh_acceptance_ids.length + state.missing_acceptance_ids.length} acceptance fresh · ${state.artifact_state}`,
+			};
+		} else {
+			active = {
+				task_id: claim.task_id,
+				state: "Blocked",
+				result: projection.error,
+				next: "inspect authority state",
+			};
+		}
+	}
+	const pending: TaskOverviewEntry[] = [];
+	const plansDir = resolve(root, "docs/plans");
+	if (existsSync(plansDir)) {
+		for (const name of readdirSync(plansDir).sort()) {
+			if (!name.endsWith(".intent.json")) continue;
+			const taskId = name.slice(0, -".intent.json".length);
+			if (claim && taskId === claim.task_id) continue;
+			if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(taskId)) continue;
+			let summary: string;
+			try {
+				if (await readTaskTombstone(root, taskId)) continue;
+				const intent = await parseTaskIntentV1(JSON.parse(readFileSync(join(plansDir, name), "utf8")));
+				if (intent.task_id !== taskId) continue;
+				summary = intent.goal;
+			} catch {
+				continue;
+			}
+			pending.push({ task_id: taskId, state: "Planning", result: summary, next: "not enrolled" });
+		}
+	}
+	return { active, pending };
+}
+
+function overviewRailState(lifecycle: string, obligation: string): TaskRailState {
+	if (lifecycle === "done") return "Completed";
+	if (lifecycle === "stopped") return "Stopped";
+	if (obligation === "run_review") return "Reviewing";
+	if (obligation === "submit_assurance" || obligation === "run_qa") return "Verifying";
+	if (obligation === "resolve_findings" || obligation === "resolve_user_decision" || obligation === "revise_intent") return "Blocked";
+	return "Working";
+}
+
 async function projectAssuranceState(root: string, taskId: string): Promise<AssuranceProjectionResult> {
 	return projectAssurance(root, taskId, diffSnapshotOf);
 }

package/plugins/immune-brain/.pi-extension/pi-canary-interaction.ts

@@ -28,11 +28,35 @@ export type TaskRailState =
 	| "Completed"
 	| "Stopped";
 
+export interface TaskRailAcceptanceProgress {
+	current: number;
+	total: number;
+	acceptance_id: string;
+	state: "running" | "passed" | "failed";
+	elapsed_ms?: number;
+}
+
 export interface TaskRailView {
 	task_id: string;
 	state: TaskRailState;
 	result: string;
 	next: string;
+	/** Assurance phase label derived from the normalized Rail state. */
+	phase?: string;
+	/** Latest per-descriptor QA fact; rendered only while present. */
+	acceptance_progress?: TaskRailAcceptanceProgress;
+}
+
+export interface TaskOverviewEntry {
+	task_id: string;
+	state: TaskRailState;
+	result: string;
+	next: string;
+}
+
+export interface TaskOverviewView {
+	active: TaskOverviewEntry | null;
+	pending: TaskOverviewEntry[];
 }
 
 export interface AuthorityDialogAction<T extends string> {
@@ -187,11 +211,35 @@ export function presentTaskRailResult(
 	const rawState = string(details.state);
 	const result = string(details.result) ?? string(details.reason) ?? operation ?? rawState ?? "Task state updated";
 	const next = string(details.next_action) ?? "Follow the projected Obligation";
+	const current = details.current;
+	const total = details.total;
+	const acceptanceId = string(details.acceptance_id);
+	const progressPhase = string(details.acceptance_phase);
+	const hasAcceptanceProgress = typeof current === "number"
+		&& typeof total === "number"
+		&& acceptanceId !== undefined
+		&& (progressPhase === "running" || progressPhase === "passed" || progressPhase === "failed");
 	presentTaskRail(ctx, {
 		task_id: taskId,
-		state: railState({ lifecycle, obligation: string(taskState?.next_obligation), operation, state: rawState }),
+		state: railState({
+			lifecycle,
+			obligation: string(taskState?.next_obligation),
+			operation,
+			state: rawState,
+			stage: string(details.stage),
+		}),
 		result,
 		next,
+		phase: string(details.stage),
+		acceptance_progress: hasAcceptanceProgress
+			? {
+					current,
+					total,
+					acceptance_id: acceptanceId,
+					state: progressPhase,
+					elapsed_ms: typeof details.elapsed_ms === "number" ? details.elapsed_ms : undefined,
+			}
+			: undefined,
 	});
 }
 
@@ -200,6 +248,33 @@ export function clearTerminalTaskRailOnInput(ctx: UiContext): void {
 	clearTaskRail(ctx);
 }
 
+export async function presentTaskOverviewOverlay(
+	ctx: UiContext & { mode?: string },
+	view: TaskOverviewView,
+): Promise<void> {
+	if (ctx.mode !== undefined && ctx.mode !== "tui") {
+		// Non-TUI hosts have no overlay surface; the command stays a no-op.
+		return;
+	}
+	try {
+		await ctx.ui.custom<void>((_tui, theme, _keybindings, done) => {
+			const container = new Container();
+			const lines = renderTaskOverview(view, 120, theme);
+			for (const line of lines) container.addChild(new Text(line, 0, 0));
+			container.addChild(new Text(theme.fg("dim", "esc: close"), 1, 0));
+			return {
+				render: (width: number) => container.render(width),
+				invalidate: () => container.invalidate(),
+				handleInput: (data: string) => {
+					if (data === "\u001b" || data === "q") done(undefined);
+				},
+			};
+		}, { overlay: true, overlayOptions: { anchor: "center", width: "80%", maxHeight: "80%" } });
+	} catch {
+		notifyOnce(ctx, "task-overview:render", "Task overview is unavailable; projections remain authoritative.", "warning");
+	}
+}
+
 export function clearTaskRail(ctx: UiContext): void {
 	try {
 		ctx.ui.setWidget(TASK_RAIL_KEY, undefined);
@@ -315,20 +390,63 @@ function renderTaskRail(view: TaskRailView, width = 120, theme?: Theme): string[
 	const stateFormatted = formatTaskRailState(view.state, theme);
 	const label = (text: string) => (theme ? theme.fg("muted", text) : text);
 	const body = (text: string) => (theme ? theme.fg("dim", text) : text);
-
-	return [
+	const lines = [
 		`Task ${boundedMiddle(view.task_id, taskIdWidth)} · ${stateFormatted}`,
+	];
+	if (view.phase) {
+		lines.push(`${label("Phase:")} ${body(bounded(view.phase, availableContentWidth))}`);
+	}
+	if (view.acceptance_progress) {
+		const progress = view.acceptance_progress;
+		const symbol = progress.state === "passed" ? "✓" : progress.state === "failed" ? "✗" : "●";
+		const color = progress.state === "failed" ? "warning" : progress.state === "passed" ? "success" : "accent";
+		const elapsed = typeof progress.elapsed_ms === "number" ? ` ${progress.elapsed_ms}ms` : "";
+		const body = `${symbol} ${bounded(progress.acceptance_id, availableContentWidth - 12)}${elapsed}`;
+		lines.push(
+			theme
+				? `${label("Acceptance:")} ${theme.fg(color, `${progress.current}/${progress.total} `)}${theme.fg(color, body)}`
+				: `Acceptance: ${progress.current}/${progress.total} ${body}`,
+		);
+	}
+	lines.push(
 		`${label("Result:")} ${body(bounded(view.result, availableContentWidth))}`,
 		`${label("Next:")} ${body(bounded(view.next, availableContentWidth))}`,
-	];
+	);
+	return lines;
+}
+
+export function renderTaskOverview(view: TaskOverviewView, width = 120, theme?: Theme): string[] {
+	const label = (text: string) => (theme ? theme.fg("muted", text) : text);
+	const head = (text: string) => (theme ? theme.fg("accent", theme.bold(text)) : text);
+	const lines = [head("Managed Tasks (read-only)")];
+	if (!view.active && view.pending.length === 0) {
+		lines.push(label("No active task; no pending TaskIntent drafts."));
+		return lines;
+	}
+	if (view.active) {
+		lines.push(`${label("Active:")} ${formatTaskRailState(view.active.state, theme)} ${bounded(view.active.task_id, 60)}`);
+		lines.push(`${label("  Result:")} ${bounded(view.active.result, 100)}`);
+		lines.push(`${label("  Next:")} ${bounded(view.active.next, 100)}`);
+	} else {
+		lines.push(label("Active: none"));
+	}
+	if (view.pending.length > 0) {
+		lines.push(label(`Pending enrollment (${view.pending.length}):`));
+		for (const entry of view.pending) {
+			lines.push(`  ${formatTaskRailState(entry.state, theme)} ${bounded(entry.task_id, 60)} · ${bounded(entry.result, 60)}`);
+		}
+	} else {
+		lines.push(label("Pending enrollment: none"));
+	}
+	return lines;
 }
 
-function railState(input: { lifecycle?: string; obligation?: string; operation?: string; state?: string }): TaskRailState {
+function railState(input: { lifecycle?: string; obligation?: string; operation?: string; state?: string; stage?: string }): TaskRailState {
 	if (input.state === "blocked" || input.state === "failed" || input.state === "settlement_unknown") return "Blocked";
 	if (input.lifecycle === "done") return "Completed";
 	if (input.lifecycle === "stopped") return "Stopped";
 	if (input.state === "awaiting_user" || input.operation === "request_authorization") return "Approval required";
-	if (input.operation === "advance_assurance") return "Verifying";
+	if (input.operation === "advance_assurance" || input.operation === "qa" || input.stage === "verifying") return "Verifying";
 	if (input.operation === "submit_review" || input.obligation === "run_review") return "Reviewing";
 	if (input.lifecycle === "active") return "Working";
 	if (input.state === "running") return "Planning";

package/plugins/immune-brain/dist/BASELINE.md

@@ -59,7 +59,7 @@ Require exact host confirmation only for privileged effects:
   override; and
 - external writes whose target or impact cannot be safely reversed locally.
 
-Routine Managed enrollment uses one host confirmation bound to the TaskIntent content hash at the Planner's final `ctx.ui.custom` gate. Enrollment validates intent, Git ownership, scope, workspace claim, and final authority preconditions without executing acceptance descriptors; deterministic QA executes them after implementation. The routine task proceeds from that single confirmation through enrollment, execution, and QA without a second human stop. Do not request confirmation for local in-scope edits, local verification, ordinary Direct rework, scoped diff review, or completion reporting. Managed evidence, QA, Review, and completion authority remain governed by their Managed contracts; R2 does not weaken them.
+Routine Managed enrollment uses one current-Host native confirmation bound to the TaskIntent content hash after Planner validation. Explicit Plan-only requests stop with candidate artifacts and do not invoke Enrollment; execution-bearing requests open the native gate directly without chat pre-confirmation. Enrollment validates intent, Git ownership, scope, workspace claim, and final authority preconditions without executing acceptance descriptors; deterministic QA executes them after implementation. The routine task proceeds from that single confirmation through enrollment, execution, and QA without a second human stop. Do not request confirmation for local in-scope edits, local verification, ordinary Direct rework, scoped diff review, or completion reporting. Managed evidence, QA, Review, and completion authority remain governed by their Managed contracts; R2 does not weaken them. Managed native-authority failures fail closed with one stable reason and exactly one same-Host recovery action; never offer a Pi, Direct Path, cross-Host/worktree, unmanaged, or automatic-retry fallback.
 
 ## Parallel Read-Only Dispatch