immune-brain 3.6.8 → 4.0.0

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

@@ -3,11 +3,13 @@ import { createHash } from "node:crypto";
 import {
 	existsSync,
 	lstatSync,
+	mkdirSync,
 	readFileSync,
 	readlinkSync,
 	realpathSync,
+	writeFileSync,
 } from "node:fs";
-import { resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 
 export interface GitWorkspaceSnapshot {
 	kind: "git-workspace-v1";
@@ -34,6 +36,75 @@ function comparePaths(left: string, right: string): number {
 	return 0;
 }
 
+function isDeliveryAttachment(path: string): boolean {
+	return path === ".imm/audit" || path.startsWith(".imm/audit/");
+}
+
+function isNonDeliveryPath(path: string): boolean {
+	return isDeliveryAttachment(path) || isRuntimeAuthorityPath(path);
+}
+
+function isOwnPlanningSidecar(path: string, taskId?: string): boolean {
+	return Boolean(taskId) && (path === `docs/plans/${taskId}.intent.json` || path === `docs/plans/archive/${taskId}.intent.json`);
+}
+
+function isOtherTaskSidecar(path: string, taskId?: string): boolean {
+	return /^docs\/plans\/(?:archive\/)?[^/]+\.intent\.json$/.test(path) && !isOwnPlanningSidecar(path, taskId);
+}
+
+function isPlanningNoise(path: string, taskId?: string): boolean {
+	return path.startsWith("docs/plans/") && !isOtherTaskSidecar(path, taskId) && !isOwnPlanningSidecar(path, taskId);
+}
+
+function enrollmentBaselinePath(root: string): string {
+	return join(root, ".imm/state/enrollment-baseline.json");
+}
+
+export function writeEnrollmentBaseline(root: string): void {
+	const snapshot = captureGitWorkspaceSnapshot(root);
+	if (!snapshot) return;
+	const path = enrollmentBaselinePath(root);
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(snapshot)}\n`);
+}
+
+function readEnrollmentBaseline(root: string): GitWorkspaceSnapshot | null {
+	const baselinePath = enrollmentBaselinePath(root);
+	if (!existsSync(baselinePath)) return null;
+	try {
+		const baseline = JSON.parse(readFileSync(baselinePath, "utf8")) as GitWorkspaceSnapshot;
+		return isGitWorkspaceSnapshot(baseline) ? baseline : null;
+	} catch {
+		throw new Error("enrollment baseline is unreadable");
+	}
+}
+
+function assertNoEnvelopeEscape(
+	root: string,
+	stagedPaths: readonly string[],
+	scope: string[],
+	taskId?: string,
+): void {
+	const baseline = readEnrollmentBaseline(root);
+	const current = baseline ? captureGitWorkspaceSnapshot(root) : null;
+	if (baseline && !current) throw new Error("enrollment baseline cannot be compared because Git is unavailable");
+	const escaped = [...new Set(stagedPaths)]
+		.filter((path) => !isNonDeliveryPath(path) && !isOwnPlanningSidecar(path, taskId) && !isPlanningNoise(path, taskId) && !taskPathMatchesScope(path, scope))
+		.filter((path) => !baseline || baseline.dirty_files[path] !== current?.dirty_files[path])
+		.sort(comparePaths);
+	if (escaped.length > 0)
+		throw new Error(`task delivery contains paths outside the authorization envelope: ${escaped.join(", ")}`);
+	if (!baseline || !current) return;
+	const staged = new Set(stagedPaths);
+	const mixed = [...new Set([...Object.keys(baseline.dirty_files), ...Object.keys(current.dirty_files)])]
+		.filter((path) => !isNonDeliveryPath(path) && !isOwnPlanningSidecar(path, taskId) && !isPlanningNoise(path, taskId) && !taskPathMatchesScope(path, scope))
+		.filter((path) => !isOtherTaskSidecar(path, taskId) || staged.has(path))
+		.filter((path) => baseline.dirty_files[path] !== current.dirty_files[path])
+		.sort(comparePaths);
+	if (mixed.length > 0)
+		throw new Error(`task delivery contains paths outside the authorization envelope: ${mixed.join(", ")}`);
+}
+
 function isRuntimeAuthorityPath(path: string): boolean {
 	return (
 		// Kernel v2 task state, workspace coordination, and authority journals are
@@ -315,7 +386,7 @@ function taskPathMatchesScope(path: string, scope: string[]): boolean {
 	return scope.some((scopePath) => pathMatchesScope(path, scopePath));
 }
 
-function taskSnapshotOnce(root: string, scope: string[]): GitTaskSnapshot {
+function taskSnapshotOnce(root: string, scope: string[], taskId?: string): GitTaskSnapshot {
 	const repositoryRoot = git(root, ["rev-parse", "--show-toplevel"])?.trim();
 	const head = git(root, ["rev-parse", "--verify", "HEAD^{commit}"])?.trim();
 	if (!repositoryRoot || !head || !GIT_OBJECT_ID.test(head))
@@ -343,14 +414,18 @@ function taskSnapshotOnce(root: string, scope: string[]): GitTaskSnapshot {
 		"untracked task paths",
 	);
 	assertNoCaseFoldCollisions([...stagedPaths, ...unstagedPaths, ...untrackedPaths], "Git task paths");
+	assertNoEnvelopeEscape(root, stagedPaths, scope, taskId);
 	const uncommittedInScope = [...new Set([...unstagedPaths, ...untrackedPaths])]
 		.filter((path) => taskPathMatchesScope(path, scope))
 		.sort(comparePaths);
 	if (uncommittedInScope.length > 0)
 		throw new Error(`task scope contains unstaged or untracked changes: ${uncommittedInScope.join(", ")}`);
 
+	const baseline = readEnrollmentBaseline(root);
+	const current = baseline ? captureGitWorkspaceSnapshot(root) : null;
 	const taskPaths = [...new Set(stagedPaths)]
-		.filter((path) => taskPathMatchesScope(path, scope))
+		.filter((path) => !isNonDeliveryPath(path) && taskPathMatchesScope(path, scope))
+		.filter((path) => !(baseline && current && baseline.dirty_files[path] === current.dirty_files[path] && baseline.dirty_files[path] !== undefined))
 		.sort(comparePaths);
 	const stagedFiles: Record<string, GitTaskIndexEntry> = {};
 	for (const path of taskPaths) {
@@ -377,6 +452,7 @@ function taskSnapshotOnce(root: string, scope: string[]): GitTaskSnapshot {
 export function captureGitTaskSnapshot(
 	projectRoot: string,
 	scopeHint: unknown,
+	taskId?: string,
 ): GitTaskSnapshot {
 	const requestedRoot = resolve(projectRoot);
 	const requestedStat = lstatSync(requestedRoot);
@@ -384,9 +460,9 @@ export function captureGitTaskSnapshot(
 		throw new Error("task snapshot root must be a real directory");
 	const root = realpathSync(requestedRoot);
 	const scope = assertCanonicalTaskScope(scopeHint);
-	const before = taskSnapshotOnce(root, scope);
+	const before = taskSnapshotOnce(root, scope, taskId);
 	gitTaskSnapshotTestHook?.();
-	const after = taskSnapshotOnce(root, scope);
+	const after = taskSnapshotOnce(root, scope, taskId);
 	if (JSON.stringify(after) !== JSON.stringify(before))
 		throw new Error("Git task snapshot changed while being captured");
 	return before;
@@ -404,16 +480,17 @@ function hashTaskSnapshot(snapshot: object): string {
 export function taskDiffIdentity(
 	projectRoot: string,
 	scopeHint: unknown,
+	taskId?: string,
 ): GitTaskDiffIdentity {
-	const snapshot = captureGitTaskSnapshot(projectRoot, scopeHint);
+	const snapshot = captureGitTaskSnapshot(projectRoot, scopeHint, taskId);
 	return {
 		diff_hash: hashTaskSnapshot(snapshot),
 		changed_paths: Object.keys(snapshot.staged_files).sort(comparePaths),
 	};
 }
 
-export function taskDiffHash(projectRoot: string, scopeHint: unknown): string {
-	return taskDiffIdentity(projectRoot, scopeHint).diff_hash;
+export function taskDiffHash(projectRoot: string, scopeHint: unknown, taskId?: string): string {
+	return taskDiffIdentity(projectRoot, scopeHint, taskId).diff_hash;
 }
 
 function gitRequired(root: string, args: string[], failure: string): string {
@@ -441,6 +518,7 @@ function taskRevisionSnapshotOnce(
 	root: string,
 	scope: string[],
 	baseHead: string,
+	taskId?: string,
 ): GitTaskRevisionSnapshot {
 	const repositoryRoot = git(root, ["rev-parse", "--show-toplevel"])?.trim();
 	const head = git(root, ["rev-parse", "--verify", "HEAD^{commit}"])?.trim();
@@ -476,7 +554,11 @@ function taskRevisionSnapshotOnce(
 		gitBytes(root, ["ls-files", "--others", "--exclude-standard", "-z", "--"]),
 		"untracked task revision paths",
 	);
-	const scopedStagedPaths = stagedPaths.filter((path) => taskPathMatchesScope(path, scope));
+	assertNoEnvelopeEscape(root, stagedPaths, scope, taskId);
+	const baseline = readEnrollmentBaseline(root);
+	const current = baseline ? captureGitWorkspaceSnapshot(root) : null;
+	const scopedStagedPaths = stagedPaths.filter((path) => !isNonDeliveryPath(path) && taskPathMatchesScope(path, scope))
+		.filter((path) => !(baseline && current && baseline.dirty_files[path] === current.dirty_files[path] && baseline.dirty_files[path] !== undefined));
 	const scopedUnstagedPaths = unstagedPaths.filter((path) => taskPathMatchesScope(path, scope));
 	const scopedUntrackedPaths = untrackedPaths.filter((path) => taskPathMatchesScope(path, scope));
 	assertNoCaseFoldCollisions(
@@ -517,6 +599,7 @@ export function captureGitTaskRevisionSnapshot(
 	projectRoot: string,
 	scopeHint: unknown,
 	baseHead: unknown,
+	taskId?: string,
 ): GitTaskRevisionSnapshot {
 	const requestedRoot = resolve(projectRoot);
 	const requestedStat = lstatSync(requestedRoot);
@@ -527,9 +610,9 @@ export function captureGitTaskRevisionSnapshot(
 		throw new Error("task revision base must be a Git commit id");
 	const scope = assertCanonicalTaskScope(scopeHint);
 	const normalizedBase = baseHead.toLowerCase();
-	const before = taskRevisionSnapshotOnce(root, scope, normalizedBase);
+	const before = taskRevisionSnapshotOnce(root, scope, normalizedBase, taskId);
 	gitTaskSnapshotTestHook?.();
-	const after = taskRevisionSnapshotOnce(root, scope, normalizedBase);
+	const after = taskRevisionSnapshotOnce(root, scope, normalizedBase, taskId);
 	if (JSON.stringify(after) !== JSON.stringify(before))
 		throw new Error("Git task revision changed while being captured");
 	return before;
@@ -539,8 +622,9 @@ export function taskRevisionIdentity(
 	projectRoot: string,
 	scopeHint: unknown,
 	baseHead: string,
+	taskId?: string,
 ): GitTaskDiffIdentity {
-	const snapshot = captureGitTaskRevisionSnapshot(projectRoot, scopeHint, baseHead);
+	const snapshot = captureGitTaskRevisionSnapshot(projectRoot, scopeHint, baseHead, taskId);
 	return {
 		diff_hash: hashTaskSnapshot(snapshot),
 		changed_paths: Object.keys(snapshot.changed_paths).sort(comparePaths),
@@ -552,8 +636,9 @@ export function taskRevisionDiffHash(
 	projectRoot: string,
 	scopeHint: unknown,
 	baseHead: string,
+	taskId?: string,
 ): string {
-	return taskRevisionIdentity(projectRoot, scopeHint, baseHead).diff_hash;
+	return taskRevisionIdentity(projectRoot, scopeHint, baseHead, taskId).diff_hash;
 }
 
 function isGitWorkspaceSnapshot(value: unknown): value is GitWorkspaceSnapshot {

package/plugins/immune-brain/skills/imm-planner/SKILL.md

@@ -9,8 +9,8 @@ Use [`../../dist/imm-planner.md`](../../dist/imm-planner.md) as the canonical co
 index, not a whole-document read. Explicit entry only: ordinary host requests stay
 host-native.
 
-Mandatory constraints before any action: Planner writes candidate Specs and
-TaskIntents only; it never implements, overwrites an enrolled TaskIntent, or
+Mandatory constraints before any action: Planner writes a TaskIntent, and a Spec
+only for complex work; it never implements, overwrites an enrolled TaskIntent, or
 grants execution authority — only the native Enrollment gate can.
 
 Section routes - load a section's instructions only when its branch applies.
@@ -35,7 +35,7 @@ own routes instead of these stages.
 - retirement design: [Retirement Completion Contract](../../dist/imm-planner.md#retirement-completion-contract)
 - optional research dispatch: [Research Dispatch](../../dist/imm-planner.md#research-dispatch)
 
-Plan-only requests stop after candidate Spec/TaskIntent validation. Requests
+Plan-only requests stop after candidate TaskIntent validation, plus Spec validation when the work is complex. Requests
 that include execution invoke the current Host's native Enrollment gate
 directly, without chat pre-confirmation. Native-gate failure stays fail-closed
 in that Host: report its reason and one retry action only; never suggest

package/plugins/immune-brain/skills/imm-review-retro/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: imm-review-retro
+description: Use when the user explicitly requests Immune-Brain ranking of models by cross-model review load or a project usage retro.
+---
+
+# Immune-Brain: Review Retro
+
+Use [`../../dist/imm-review-retro.md`](../../dist/imm-review-retro.md) as the
+canonical contract index, not a whole-document read. This is a
+standalone host-native analysis entry, not a Managed Path continuation
+and not an `imm-loop` internal-role dispatch.
+
+Mandatory constraints: read-only on pi session logs. Do not edit code, tests,
+Specs, or workflow state. Do not write session logs or `.imm/` files.
+
+Section routes - load a section's instructions only when its branch applies.
+Read each linked heading body up to the next heading; nested sections and
+references load only under their own condition. Never read the whole contract
+or all references as an entry prerequisite.
+
+- common: [Boundary](../../dist/imm-review-retro.md#boundary), [Invocation](../../dist/imm-review-retro.md#invocation)
+- running the analyzer: [Counting rules](../../dist/imm-review-retro.md#counting-rules), [CLI](../../dist/imm-review-retro.md#cli)
+- interpreting the report: [Report](../../dist/imm-review-retro.md#report), [Caveats](../../dist/imm-review-retro.md#caveats)

package/plugins/immune-brain/skills/imm-review-retro/scripts/review_retro.ts

@@ -0,0 +1,355 @@
+#!/usr/bin/env bun
+/**
+ * Retro: how many code reviews did each model's own code trigger, across recent pi sessions.
+ *
+ * Usage: bun review_retro.ts <days> [--root <sessions-dir>] [--project <substr>] [--top N]
+ *
+ * Counting rules (the 口径 that keeps the numbers honest):
+ *   review executed      = Agent(subagent_type="Review") tool call
+ *   avgSc / pass%        = average score (0-10) and PASS rate from [SCORE: ...] tags in Review toolResult
+ *   kernel:submit_review = the *registration* of that same review, reported separately (never added)
+ *   attribution          = the model behind the most recent edit/write before the review (the code's author)
+ *   findings             = imm_kernel_canary record_finding, deduped per session, harness bookkeeping split out
+ */
+import { createReadStream, existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { pathToFileURL } from "node:url";
+
+const BOOKKEEPING = /recorded cleanly|receipt recorded|round recorded|no findings?\b/i;
+const EDIT_TOOLS = new Set(["edit", "write", "multiedit"]);
+const SCORE_RE = /\[SCORE:\s*([\d.]+)\s*(?:\/\s*10)?\]/i;
+const VERDICT_RE = /\[VERDICT:\s*(\w+)\]/i;
+const RISK_RE = /\[RISK:\s*(\w+)\]/i;
+const BLOCK_RE = /\[BLOCKING:\s*(\d+)\]/i;
+const ADVIS_RE = /\[ADVISORY:\s*(\d+)\]/i;
+
+type ReviewTag = {
+	score: number;
+	verdict: string;
+	risk: string;
+	blocking: number;
+	advisory: number;
+};
+
+function parseReviewTag(text: string): ReviewTag | null {
+	if (!text.includes("[SCORE:")) return null;
+	const sc = SCORE_RE.exec(text);
+	if (!sc) return null;
+	const score = Number(sc[1]);
+	if (!Number.isFinite(score)) return null;
+	return {
+		score,
+		verdict: (VERDICT_RE.exec(text)?.[1] ?? "UNKNOWN").toUpperCase(),
+		risk: (RISK_RE.exec(text)?.[1] ?? "UNKNOWN").toUpperCase(),
+		blocking: Number(BLOCK_RE.exec(text)?.[1] ?? 0),
+		advisory: Number(ADVIS_RE.exec(text)?.[1] ?? 0),
+	};
+}
+
+function extractText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) {
+		return content
+			.map((item) => {
+				if (typeof item === "string") return item;
+				if (item && typeof item === "object") {
+					const rec = item as Record<string, unknown>;
+					if ("text" in rec) return String(rec.text);
+					if ("result" in rec) return String(rec.result);
+				}
+				return "";
+			})
+			.join("\n");
+	}
+	return "";
+}
+
+function norm(a: unknown): Record<string, unknown> {
+	if (typeof a === "string") {
+		try {
+			return JSON.parse(a) as Record<string, unknown>;
+		} catch {
+			return {};
+		}
+	}
+	return a && typeof a === "object" ? (a as Record<string, unknown>) : {};
+}
+
+function bump(map: Map<string, number>, key: string, n = 1): void {
+	map.set(key, (map.get(key) ?? 0) + n);
+}
+
+type Args = { days: number; root: string; project: string; top: number };
+
+function parseArgs(argv: string[]): Args {
+	const out: Args = {
+		days: NaN,
+		root: join(homedir(), ".pi/agent/sessions"),
+		project: "",
+		top: 15,
+	};
+	const rest: string[] = [];
+	for (let i = 0; i < argv.length; i++) {
+		const a = argv[i]!;
+		if (a === "--root") out.root = argv[++i] ?? "";
+		else if (a === "--project") out.project = argv[++i] ?? "";
+		else if (a === "--top") out.top = Number(argv[++i]);
+		else if (a.startsWith("-")) throw new Error(`unknown flag: ${a}`);
+		else rest.push(a);
+	}
+	out.days = Number(rest[0]);
+	if (!(out.days > 0) || rest[1] !== undefined) {
+		throw new Error("usage: review_retro.ts <days> [--root <dir>] [--project <substr>] [--top N]");
+	}
+	if (!Number.isFinite(out.top) || out.top <= 0) throw new Error("--top must be > 0");
+	return out;
+}
+
+function listJsonl(root: string): string[] {
+	if (!existsSync(root)) return [];
+	const paths: string[] = [];
+	for (const dir of readdirSync(root, { withFileTypes: true })) {
+		if (!dir.isDirectory()) continue;
+		const folder = join(root, dir.name);
+		for (const name of readdirSync(folder)) {
+			if (name.endsWith(".jsonl")) paths.push(join(folder, name));
+		}
+	}
+	return paths;
+}
+
+export async function run(argv: string[]): Promise<string> {
+	const args = parseArgs(argv);
+	const cut = new Date(Date.now() - args.days * 86400000).toISOString().slice(0, 19);
+	const home = homedir();
+	const dev = new Map<string, number>();
+	const turns = new Map<string, number>();
+	const rev = new Map<string, number>();
+	const sub = new Map<string, number>();
+	const tools = new Map<string, number>();
+	const proj = new Map<string, number>();
+	const episode = new Map<string, Set<string>>();
+	const tasks = new Map<string, Set<string>>();
+	const findUniq = new Map<string, Set<string>>();
+	const findingsRaw = new Map<string, number>();
+	const scores = new Map<string, number[]>();
+	const verdicts = new Map<string, number>();
+	const risks = new Map<string, number>();
+	let files = 0;
+
+	for (const path of listJsonl(args.root)) {
+		let editor: string | null = null;
+		let cwd = "";
+		let used = false;
+		const pending = new Map<string, string>();
+		const rl = createInterface({ input: createReadStream(path, { encoding: "utf8" }) });
+		for await (const raw of rl) {
+			const line = raw.trim();
+			if (!line) continue;
+			let o: Record<string, unknown>;
+			try {
+				o = JSON.parse(line) as Record<string, unknown>;
+			} catch {
+				continue;
+			}
+			if (o.type === "session") {
+				cwd = String(o.cwd ?? "");
+				continue;
+			}
+			const m = (o.message && typeof o.message === "object" ? o.message : {}) as Record<string, unknown>;
+			const role = m.role;
+			if (String(o.timestamp ?? "") < cut) continue;
+			if (args.project && !cwd.includes(args.project)) continue;
+
+			if (role === "assistant") {
+				used = true;
+				const mo = `${m.provider ?? "?"}/${m.model ?? "?"}`;
+				bump(turns, mo);
+				const content = Array.isArray(m.content) ? m.content : [];
+				for (const c of content) {
+					if (!c || typeof c !== "object") continue;
+					const call = c as Record<string, unknown>;
+					if (call.type !== "toolCall") continue;
+					const name = String(call.name ?? "");
+					const a = norm(call.arguments);
+					const cid = typeof call.id === "string" ? call.id : "";
+					bump(tools, name || "?");
+					if (EDIT_TOOLS.has(name)) {
+						bump(dev, mo);
+						editor = mo;
+					} else if (name === "Agent" && a.subagent_type === "Review") {
+						const owner = editor ?? "no-edit (review-only)";
+						bump(rev, owner);
+						const ep = episode.get(owner) ?? new Set();
+						ep.add(`${path}\0${String(a.description ?? "")}${String(a.prompt ?? "").slice(0, 240)}`);
+						episode.set(owner, ep);
+						const projKey = `${cwd.replace(home, "~")}\0${owner}`;
+						bump(proj, projKey);
+						if (cid) pending.set(cid, owner);
+					} else if (name === "imm_kernel_canary") {
+						const act = norm(a.action);
+						const op = act.op;
+						const owner = editor ?? "no-edit (review-only)";
+						if (op === "submit_review") {
+							bump(sub, owner);
+							const t = tasks.get(owner) ?? new Set();
+							t.add(`${cwd}\0${String(a.task_id ?? "")}`);
+							tasks.set(owner, t);
+						} else if (op === "record_finding") {
+							const f = norm(act.finding);
+							const summ = String(f.summary ?? "");
+							const kind = BOOKKEEPING.test(summ) ? "bookkeeping" : String(f.kind ?? "");
+							const rawKey = `${owner}\0${kind}`;
+							bump(findingsRaw, rawKey);
+							const uniq = findUniq.get(rawKey) ?? new Set();
+							uniq.add(`${path}\0${summ.slice(0, 160)}`);
+							findUniq.set(rawKey, uniq);
+						}
+					}
+				}
+			} else if (role === "toolResult") {
+				const tcid = String(m.toolCallId ?? "");
+				const owner = pending.get(tcid);
+				if (!owner) continue;
+				pending.delete(tcid);
+				const tag = parseReviewTag(extractText(m.content));
+				if (!tag) continue;
+				const sl = scores.get(owner) ?? [];
+				sl.push(tag.score);
+				scores.set(owner, sl);
+				bump(verdicts, `${owner}\0${tag.verdict}`);
+				bump(risks, `${owner}\0${tag.risk}`);
+			}
+		}
+		if (used) files += 1;
+	}
+
+	const lines: string[] = [];
+	const emit = (s = "") => lines.push(s);
+	emit(`window: last ${args.days}d (UTC >= ${cut}Z) | sessions with activity: ${files} | root: ${args.root}`);
+	emit("review = Agent(Review) executed; attributed to the model that last edited the code under review");
+	emit("avgSc/pass% = parsed from Review [SCORE: .../10] [VERDICT: ...] tags (shows '-' if untagged)");
+	emit("");
+	const hdr =
+		`${"model".padEnd(42)}${"devEdits".padStart(9)}${"turns".padStart(6)}${"reviews".padStart(8)}${"uniq".padStart(5)}${"rev/100ed".padStart(10)}${"avgSc".padStart(6)}${"pass%".padStart(6)}${"registr".padStart(8)}${"block".padStart(6)}${"advis".padStart(6)}${"noisy".padStart(6)}`;
+	emit(hdr);
+	emit("-".repeat(hdr.length));
+
+	const models = [...new Set([...rev.keys(), ...dev.keys()])].sort(
+		(a, b) => (rev.get(b) ?? 0) - (rev.get(a) ?? 0),
+	);
+	const shown: string[] = [];
+	for (const mo of models) {
+		if (!rev.get(mo) && (dev.get(mo) ?? 0) < 30) continue;
+		shown.push(mo);
+		const uq = episode.get(mo)?.size ?? 0;
+		const d = dev.get(mo) ?? 0;
+		const r = rev.get(mo) ?? 0;
+		const rate = d ? ((100 * r) / d).toFixed(1) : "-";
+		const sl = scores.get(mo) ?? [];
+		const avgSc = sl.length ? (sl.reduce((x, y) => x + y, 0) / sl.length).toFixed(1) : "-";
+		const passCnt = verdicts.get(`${mo}\0PASS`) ?? 0;
+		const passPct = sl.length ? `${Math.round((100 * passCnt) / sl.length)}%` : "-";
+		const block = findUniq.get(`${mo}\0blocking`)?.size ?? 0;
+		const advis = findUniq.get(`${mo}\0advisory`)?.size ?? 0;
+		const noisy = findUniq.get(`${mo}\0bookkeeping`)?.size ?? 0;
+		emit(
+			`${mo.padEnd(42)}${String(d).padStart(9)}${String(turns.get(mo) ?? 0).padStart(6)}${String(r).padStart(8)}${String(uq).padStart(5)}${rate.padStart(10)}${avgSc.padStart(6)}${passPct.padStart(6)}${String(sub.get(mo) ?? 0).padStart(8)}${String(block).padStart(6)}${String(advis).padStart(6)}${String(noisy).padStart(6)}`,
+		);
+	}
+	emit("-".repeat(hdr.length));
+	const totalScores = [...scores.values()].flat();
+	const totAvg = totalScores.length
+		? (totalScores.reduce((x, y) => x + y, 0) / totalScores.length).toFixed(1)
+		: "-";
+	const totPass = shown.reduce((n, mo) => n + (verdicts.get(`${mo}\0PASS`) ?? 0), 0);
+	const totPassPct = totalScores.length ? `${Math.round((100 * totPass) / totalScores.length)}%` : "-";
+	const totBlock = [...findUniq.entries()].reduce((n, [k, v]) => n + (k.endsWith("\0blocking") ? v.size : 0), 0);
+	const totAdvis = [...findUniq.entries()].reduce((n, [k, v]) => n + (k.endsWith("\0advisory") ? v.size : 0), 0);
+	const totNoisy = [...findUniq.entries()].reduce((n, [k, v]) => n + (k.endsWith("\0bookkeeping") ? v.size : 0), 0);
+	const totDev = [...dev.values()].reduce((a, b) => a + b, 0);
+	const totTurns = [...turns.values()].reduce((a, b) => a + b, 0);
+	const totRev = [...rev.values()].reduce((a, b) => a + b, 0);
+	const totUniq = [...episode.values()].reduce((n, s) => n + s.size, 0);
+	const totSub = [...sub.values()].reduce((a, b) => a + b, 0);
+	emit(
+		`${"TOTAL".padEnd(42)}${String(totDev).padStart(9)}${String(totTurns).padStart(6)}${String(totRev).padStart(8)}${String(totUniq).padStart(5)}${"".padStart(10)}${totAvg.padStart(6)}${totPassPct.padStart(6)}${String(totSub).padStart(8)}${String(totBlock).padStart(6)}${String(totAdvis).padStart(6)}${String(totNoisy).padStart(6)}`,
+	);
+
+	emit("");
+	emit("=== usage (sessions / turns / edits / tools) ===");
+	emit(`sessions: ${files} | turns: ${totTurns} | edits: ${totDev}`);
+	const toolRows = [...tools.entries()].sort((a, b) => b[1] - a[1]);
+	if (toolRows.length === 0) emit("(no tool calls in this window)");
+	else for (const [name, n] of toolRows) emit(`${String(n).padStart(5)}  ${name}`);
+
+	emit("");
+	emit("=== review quality & scores (new rubric) ===");
+	const scoredModels = [...scores.keys()]
+		.filter((m) => (scores.get(m) ?? []).length > 0)
+		.sort((a, b) => (scores.get(b)?.length ?? 0) - (scores.get(a)?.length ?? 0));
+	if (scoredModels.length) {
+		const qHdr = `${"model".padEnd(42)}${"scored".padStart(7)}${"avgScore".padStart(9)}${"PASS".padStart(6)}${"REVISE".padStart(7)}${"REJECT".padStart(7)}${"highRisk".padStart(9)}`;
+		emit(qHdr);
+		emit("-".repeat(qHdr.length));
+		for (const mo of scoredModels) {
+			const sl = scores.get(mo) ?? [];
+			const avgS = (sl.reduce((x, y) => x + y, 0) / sl.length).toFixed(2);
+			const pC = verdicts.get(`${mo}\0PASS`) ?? 0;
+			const revC = verdicts.get(`${mo}\0REVISE`) ?? 0;
+			const rejC = verdicts.get(`${mo}\0REJECT`) ?? 0;
+			const highR = (risks.get(`${mo}\0HIGH`) ?? 0) + (risks.get(`${mo}\0CRITICAL`) ?? 0);
+			emit(
+				`${mo.padEnd(42)}${String(sl.length).padStart(7)}${avgS.padStart(9)}${String(pC).padStart(6)}${String(revC).padStart(7)}${String(rejC).padStart(7)}${String(highR).padStart(9)}`,
+			);
+		}
+	} else {
+		emit("(no scored reviews found in this window yet; reviews with [SCORE: .../10] will appear here)");
+	}
+
+	emit("");
+	emit("=== where the reviews landed (project x author) ===");
+	const projRows = [...proj.entries()].sort((a, b) => b[1] - a[1]).slice(0, args.top);
+	for (const [key, v] of projRows) {
+		const [p, mo] = key.split("\0");
+		emit(`${String(v).padStart(5)}  ${String(p).padEnd(58)} ${mo}`);
+	}
+
+	emit("");
+	emit("=== review rounds per kernel task (rework signal) ===");
+	const taskModels = [...tasks.keys()].sort((a, b) => (sub.get(b) ?? 0) - (sub.get(a) ?? 0));
+	for (const mo of taskModels) {
+		const nt = tasks.get(mo)?.size ?? 0;
+		if (!nt) continue;
+		const s = sub.get(mo) ?? 0;
+		emit(
+			`${(s / nt).toFixed(1).padStart(6)} rounds/task   ${String(s).padStart(4)} registrations / ${String(nt).padStart(3)} tasks   ${mo}`,
+		);
+	}
+
+	const rawSum = [...findingsRaw.values()].reduce((a, b) => a + b, 0);
+	const uniqSum = [...findUniq.values()].reduce((n, s) => n + s.size, 0);
+	if (rawSum && rawSum !== uniqSum) {
+		emit("");
+		emit(
+			`(findings: ${rawSum} raw calls deduped to ${uniqSum} distinct — re-submits of the same finding are counted once)`,
+		);
+	}
+	emit("caveats: 'bookkeep' = kernel self-entries mislabelled as findings, excluded from blocking/advisory;");
+	emit("         high rounds/task can be canary/QA harness re-registration, not human-visible rework.");
+	return `${lines.join("\n")}\n`;
+}
+
+const isMain = Boolean(process.argv[1]) && pathToFileURL(process.argv[1]!).href === import.meta.url;
+if (isMain) {
+	run(process.argv.slice(2))
+		.then((text) => {
+			process.stdout.write(text);
+		})
+		.catch((err: unknown) => {
+			console.error(err);
+			process.exit(1);
+		});
+}

package/plugins/immune-brain/skills/registry.yaml

@@ -56,3 +56,12 @@ skills:
     output_artifacts: [maintain_report]
     next_actions: []
     boundary: Minimize tracked agent-instruction context after explicit manifest approval; no Managed authority mutation, contract installation, or reference-document creation.
+  - name: imm-review-retro
+    path: skills/imm-review-retro/SKILL.md
+    role: execute
+    title: Review Retro
+    role_class: discovery
+    canonical: true
+    output_artifacts: [retro_report]
+    next_actions: []
+    boundary: Rank models by review load and report project usage from pi session logs. Read-only. No Managed Path mutation.

package/plugins/immune-brain/bin/imm-retire-stale-wrapper

@@ -1,4 +0,0 @@
-#!/bin/sh
-set -eu
-PLUGIN_ROOT=$(cd "$(dirname "$0")/.." && pwd -P)
-exec bun "$PLUGIN_ROOT/runtime/v4_runtime.ts" cli imm-retire-stale-wrapper "$@"

package/plugins/immune-brain/bin/imm-retired

@@ -1,4 +0,0 @@
-#!/bin/sh
-set -eu
-PLUGIN_ROOT=$(cd "$(dirname "$0")/.." && pwd -P)
-exec bun "$PLUGIN_ROOT/runtime/v4_runtime.ts" cli imm-work "$@"