immune-brain 3.4.0 → 3.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "immune-brain",
-  "version": "3.4.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.4.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/claude/mcp-server.mjs

@@ -42,7 +42,7 @@ function probeHost(env = process.env, platform = process.platform, hostVersion)
 }
 
 // plugins/immune-brain/runtime/plugin_version.ts
-var PLUGIN_VERSION = "3.4.0";
+var PLUGIN_VERSION = "3.5.0";
 
 // plugins/immune-brain/runtime/claude/interaction.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -1380,7 +1380,13 @@ class AssuranceCoordinator {
         ensureOperationLive();
         qaVerdict = await this.ports.runQa(assurance.snapshot, assurance.descriptors, runner, {
           signal: operationController.signal,
-          onProgress: (item) => progress("verifying", `QA ${item.index}/${item.total} ${item.acceptance_id} ${item.phase}`, { current: item.index, total: item.total, acceptance_id: item.acceptance_id })
+          onProgress: (item) => progress("verifying", `QA ${item.index}/${item.total} ${item.acceptance_id} ${item.phase}`, {
+            current: item.index,
+            total: item.total,
+            acceptance_id: item.acceptance_id,
+            acceptance_phase: item.phase,
+            elapsed_ms: item.elapsed_ms
+          })
         });
         ensureOperationLive();
         const invocation = this.openInvocation(taskId);

package/plugins/immune-brain/runtime/assurance/coordinator.ts

@@ -559,7 +559,13 @@ export class AssuranceCoordinator {
 				ensureOperationLive();
 				qaVerdict = await this.ports.runQa(assurance.snapshot, assurance.descriptors, runner, {
 					signal: operationController.signal,
-					onProgress: (item) => progress("verifying", `QA ${item.index}/${item.total} ${item.acceptance_id} ${item.phase}`, { current: item.index, total: item.total, acceptance_id: item.acceptance_id }),
+					onProgress: (item) => progress("verifying", `QA ${item.index}/${item.total} ${item.acceptance_id} ${item.phase}`, {
+						current: item.index,
+						total: item.total,
+						acceptance_id: item.acceptance_id,
+						acceptance_phase: item.phase,
+						elapsed_ms: item.elapsed_ms,
+					}),
 				});
 				ensureOperationLive();
 				const invocation = this.openInvocation(taskId);

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 = "3.4.0" as const;
+export const PLUGIN_VERSION = "3.5.0" as const;