immune-brain 3.6.7 → 3.6.9

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

@@ -55,6 +55,8 @@ export interface TaskRailView {
 	recovery?: string;
 	/** Latest per-descriptor QA fact; rendered only while present. */
 	acceptance_progress?: TaskRailAcceptanceProgress;
+	/** Optional pipeline milestone progress indicator. */
+	pipeline?: boolean;
 }
 
 export interface TaskOverviewEntry {
@@ -144,7 +146,7 @@ export async function requestAuthorityDialog<T extends string, R = T | undefined
 					finish = done;
 					if (settled || options.signal?.aborted) done(undefined);
 					let expanded = false;
-					const detailText = new Text(theme.fg("muted", "Details collapsed; press d to expand."), 1, 0);
+					const detailText = new Text(theme.fg("muted", "▸ Details collapsed; press d to expand."), 1, 0);
 					const selectList = new SelectList(
 						options.actions.map((action): SelectItem => ({ ...action })),
 						options.actions.length,
@@ -158,13 +160,27 @@ export async function requestAuthorityDialog<T extends string, R = T | undefined
 					);
 					selectList.onSelect = (item) => complete(item.value as T);
 					selectList.onCancel = () => complete(undefined);
+
+					const affirmativeAction = options.actions.find((a) =>
+						["confirm", "authorize", "yes", "accept"].includes(a.value.toLowerCase()),
+					);
+					const negativeAction = options.actions.find((a) =>
+						["cancel", "decline", "no", "reject"].includes(a.value.toLowerCase()),
+					);
+
+					const affKey = affirmativeAction ? "y/enter" : "enter";
+					const negKey = negativeAction ? "n/esc" : "esc";
+					const affLabel = affirmativeAction ? affirmativeAction.value : "choose";
+					const negLabel = negativeAction ? negativeAction.value : "cancel";
+					const hintLine = `d: details | ${affKey}: ${affLabel} | ${negKey}: ${negLabel}`;
+
 					const container = new Container();
 					container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
 					container.addChild(new Text(theme.fg("accent", theme.bold(options.title)), 1, 0));
-					container.addChild(new Text(options.summary, 1, 0));
+					container.addChild(new Text(formatDialogSummary(options.summary, theme), 1, 0));
 					container.addChild(detailText);
 					container.addChild(selectList);
-					container.addChild(new Text(theme.fg("dim", "d: toggle details | enter: choose | esc: cancel"), 1, 0));
+					container.addChild(new Text(theme.fg("dim", hintLine), 1, 0));
 					container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
 					return {
 						render: (width) => container.render(width),
@@ -172,10 +188,20 @@ export async function requestAuthorityDialog<T extends string, R = T | undefined
 						handleInput: (data) => {
 							if (data === "d" || data === "D") {
 								expanded = !expanded;
-								detailText.setText(expanded ? options.details : theme.fg("muted", "Details collapsed; press d to expand."));
+								detailText.setText(expanded
+									? `${theme.fg("muted", "▾ Details:")}\n${options.details}`
+									: theme.fg("muted", "▸ Details collapsed; press d to expand."));
 								tui.requestRender();
 								return;
 							}
+							if ((data === "y" || data === "Y") && affirmativeAction) {
+								complete(affirmativeAction.value as T);
+								return;
+							}
+							if ((data === "n" || data === "N") && negativeAction) {
+								complete(negativeAction.value as T);
+								return;
+							}
 							selectList.handleInput(data);
 							tui.requestRender();
 						},
@@ -372,6 +398,13 @@ export function renderStructuredResult(
 	];
 	const recovery = recoveryHint(details);
 	if (recovery) lines.push(`${theme.fg("muted", "Recovery:")} ${theme.fg("dim", recovery)}`);
+	const facts = record(details.facts) ?? record(details.execution_facts);
+	if (facts) {
+		const factParts = Object.entries(facts)
+			.map(([k, v]) => `${k}=${String(v)}`)
+			.join(" · ");
+		if (factParts) lines.push(`${theme.fg("muted", "Facts:")} ${theme.fg("dim", factParts)}`);
+	}
 	if (terminal && taskState) lines.push(...renderFinalLines(taskState, theme));
 	return new Text(lines.join("\n"), 0, 0);
 }
@@ -423,6 +456,9 @@ function renderTaskRail(view: TaskRailView, width = 120, theme?: Theme): string[
 	const lines = [
 		`Task ${boundedMiddle(view.task_id, taskIdWidth)} · ${stateFormatted}`,
 	];
+	if (view.pipeline) {
+		lines.push(`${label("Pipeline:")} ${renderPipelineMilestones(view.state, theme)}`);
+	}
 	if (view.phase) {
 		lines.push(`${label("Phase:")} ${body(bounded(view.phase, availableContentWidth))}`);
 	}
@@ -446,6 +482,69 @@ function renderTaskRail(view: TaskRailView, width = 120, theme?: Theme): string[
 	return lines;
 }
 
+export function renderPipelineMilestones(state: TaskRailState, theme?: Theme): string {
+	const milestones = [
+		{ name: "Plan", key: "plan" },
+		{ name: "Exec", key: "exec" },
+		{ name: "QA", key: "qa" },
+		{ name: "Review", key: "review" },
+	] as const;
+
+	type StepStatus = "done" | "active" | "pending" | "blocked" | "stopped";
+
+	let statuses: [StepStatus, StepStatus, StepStatus, StepStatus];
+	switch (state) {
+		case "Planning":
+			statuses = ["active", "pending", "pending", "pending"];
+			break;
+		case "Approval required":
+		case "Working":
+			statuses = ["done", "active", "pending", "pending"];
+			break;
+		case "Verifying":
+			statuses = ["done", "done", "active", "pending"];
+			break;
+		case "Reviewing":
+			statuses = ["done", "done", "done", "active"];
+			break;
+		case "Completed":
+			statuses = ["done", "done", "done", "done"];
+			break;
+		case "Blocked":
+			statuses = ["done", "blocked", "pending", "pending"];
+			break;
+		case "Stopped":
+			statuses = ["done", "stopped", "pending", "pending"];
+			break;
+		default:
+			statuses = ["pending", "pending", "pending", "pending"];
+	}
+
+	const renderStep = (name: string, status: StepStatus, index: number): string => {
+		const stepNum = index + 1;
+		if (!theme) {
+			const sym = status === "done" ? "✔" : status === "active" ? "●" : status === "blocked" ? "⚠" : status === "stopped" ? "■" : "○";
+			return `[${stepNum}.${name} ${sym}]`;
+		}
+		switch (status) {
+			case "done":
+				return `[${stepNum}.${name} ${theme.fg("success", "✔")}]`;
+			case "active":
+				return `[${stepNum}.${name} ${theme.fg("accent", "●")}]`;
+			case "blocked":
+				return `[${stepNum}.${name} ${theme.fg("warning", "⚠")}]`;
+			case "stopped":
+				return `[${stepNum}.${name} ${theme.fg("muted", "■")}]`;
+			case "pending":
+			default:
+				return `[${stepNum}.${name} ${theme.fg("dim", "○")}]`;
+		}
+	};
+
+	const sep = theme ? ` ${theme.fg("dim", "─")} ` : " ─ ";
+	return milestones.map((m, i) => renderStep(m.name, statuses[i], i)).join(sep);
+}
+
 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);
@@ -456,6 +555,7 @@ export function renderTaskOverview(view: TaskOverviewView, width = 120, theme?:
 	}
 	if (view.active) {
 		lines.push(`${label("Active:")} ${formatTaskRailState(view.active.state, theme)} ${bounded(view.active.task_id, 60)}`);
+		lines.push(`${label("  Pipeline:")} ${renderPipelineMilestones(view.active.state, theme)}`);
 		lines.push(`${label("  Result:")} ${bounded(view.active.result, 100)}`);
 		lines.push(`${label("  Next:")} ${bounded(view.active.next, 100)}`);
 	} else {
@@ -501,15 +601,60 @@ function renderFinalLines(taskState: Record<string, unknown>, theme: Theme): str
 		+ strings(taskState.unresolved_user_decision_ids).length
 		+ strings(taskState.replan_required_ids).length;
 	const diffHash = string(taskState.diff_hash);
+	const divider = theme.fg("dim", "────────────────────────────────────────");
 	return [
+		divider,
+		theme.fg("accent", theme.bold("Final Settlement Summary")),
 		`${theme.fg("muted", "Acceptance:")} ${theme.fg(missing === 0 ? "success" : "warning", `${fresh}/${fresh + missing} fresh`)}`,
 		`${theme.fg("muted", "QA / Review:")} ${theme.fg("dim", approvals.length > 0 ? approvals.join(", ") : "not recorded")}`,
 		`${theme.fg("muted", "Residual blockers:")} ${theme.fg(blockers === 0 ? "dim" : "warning", String(blockers))}`,
 		`${theme.fg("muted", "Repository health:")} ${theme.fg("dim", "not assessed")}`,
 		`${theme.fg("muted", "Git:")} ${theme.fg("dim", diffHash ? `task diff ${diffHash.slice(0, 15)}` : "not reported")}`,
+		divider,
 	];
 }
 
+function formatDialogSummary(summary: string, theme: Theme): string {
+	const lines = summary.split("\n");
+	return lines.map((line) => {
+		const colonIdx = line.indexOf(":");
+		if (colonIdx === -1) return theme.fg("dim", line);
+		const key = line.slice(0, colonIdx).trim();
+		const value = line.slice(colonIdx + 1).trim();
+		let formattedValue = theme.fg("dim", value);
+		const lowerKey = key.toLowerCase();
+		if (lowerKey === "risk") {
+			const isHigh = /high|material|critical/i.test(value);
+			formattedValue = isHigh ? theme.fg("warning", theme.bold(value)) : theme.fg("accent", value);
+		} else if (lowerKey === "goal") {
+			formattedValue = theme.fg("accent", value);
+		} else if (lowerKey === "acceptance") {
+			formattedValue = theme.fg("success", value);
+		}
+		return `${theme.fg("muted", `${key}:`)} ${formattedValue}`;
+	}).join("\n");
+}
+
+export function boundedPath(path: string, max: number): string {
+	const width = visibleWidth(path);
+	if (width <= max) return path;
+	if (!path.includes("/")) return bounded(path, max);
+	const parts = path.split("/");
+	const fileName = parts.pop() ?? "";
+	const fileWidth = visibleWidth(fileName);
+	if (fileWidth + 2 >= max) {
+		return bounded(fileName, max);
+	}
+	const remaining = max - fileWidth - 3; // "…/"
+	let prefix = "";
+	for (const part of parts) {
+		const next = prefix ? `${prefix}/${part}` : part;
+		if (visibleWidth(next) > remaining) break;
+		prefix = next;
+	}
+	return prefix ? `${prefix}/…/${fileName}` : `…/${fileName}`;
+}
+
 function record(value: unknown): Record<string, unknown> | undefined {
 	return typeof value === "object" && value !== null && !Array.isArray(value)
 		? value as Record<string, unknown>

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.6.7";
+var PLUGIN_VERSION = "3.6.9";
 
 // plugins/immune-brain/runtime/claude/interaction.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -7126,7 +7126,8 @@ function parseIssues(raw) {
       title: item.title,
       body: typeof item.body === "string" ? item.body : "",
       state: item.state,
-      state_reason: typeof item.state_reason === "string" ? item.state_reason.toLowerCase() : null
+      state_reason: typeof item.state_reason === "string" ? item.state_reason.toLowerCase() : null,
+      labels: Array.isArray(item.labels) ? item.labels.map((label) => typeof label === "string" ? label : label?.name).filter((name) => typeof name === "string") : []
     };
   });
 }

package/plugins/immune-brain/dist/imm-loop.md

@@ -90,6 +90,9 @@ with its `initiative_slug` parameter. That parameter is the opt-in: absent the c
 `imm-loop` behavior is byte-identical to per-task Enrollment, and no batch state,
 branch, or Batch Authorization exists. The Standalone Hosts expose the same tool
 name and the same single parameter; it is never a batch of tasks the Host chose.
+When an Initiative is referenced by its tracker Issue (e.g. `github #<number>`),
+extract `initiative_slug` from the Issue body `<!-- immune-brain:initiative-id=<slug> -->`
+marker or title prefix before invoking the tool.
 
 Invoking it authorizes only a user-confirmed batch of already-planned child
 TaskIntents. The Host projects the batch plan from the Initiative's published

package/plugins/immune-brain/dist/imm-planner.md

@@ -172,8 +172,13 @@ with `valid: true` and `enrollment_ready: true`. Resolve `../bin/imm-tracker` fr
 Initiative slug and goal, Parent projection, and every Child's `slice_id`,
 canonical TaskIntent path, bounded public `acceptance` summaries, and public
 projection. The Parent projection requires
-`problem`, `result`, and `design`, and may include `decisions`,
-`testing_strategy`, and `out_of_scope`. `design` records Initiative-level
+`short_name`, `title`, `problem`, `result`, and `design`, and may include
+`source_issue`, `decisions`,
+`testing_strategy`, and `out_of_scope`. `short_name` (1-32 characters) is the
+stable short Initiative name used in every Issue title; `title` (1-60
+characters) is the short Initiative display title; `source_issue` is the
+originating feature Issue number, rendered as a Provenance link. `design`
+records Initiative-level
 invariants, Slice boundaries and ordering, shared interfaces or state flow, and
 material compatibility decisions. Every Parent Slice must correspond to one
 published Child; future checklist-only Slices are not allowed in the batch.
@@ -181,15 +186,24 @@ published Child; future checklist-only Slices are not allowed in the batch.
 Each Child must provide public `acceptance` entries with `id` and a 1-500
 character `summary`. Their IDs must match every canonical TaskIntent acceptance
 ID exactly once. Canonical assertion prose is authority evidence and must never
-be copied into public GitHub projection. Each Child projection may contain
+be copied into public GitHub projection. Each Child projection requires
+`title` (1-60 characters), the short Slice display title, and may contain
 `result`, `current_behavior`,
 `desired_behavior`, `key_interfaces`, `verification`, `blocked_by` Task IDs,
-`out_of_scope`, and `agent_handoff`. The tracker rereads every canonical
+`out_of_scope`, and `agent_handoff`. The tracker composes Issue titles from
+these display names only — the Parent as `[<short_name>] <title>` and each
+Child as `[<short_name>] S<n> <title>` with `n` the declared Slice position —
+and fails the whole batch closed before any remote write when a display name
+is missing or the composed title exceeds 80 characters; it never falls back to
+goal prose and never truncates a title. The tracker rereads every canonical
 TaskIntent for identity, risk, and acceptance IDs; projection fields and public
 summaries never widen TaskIntent scope or authority. It validates the complete dependency graph before
 remote writes, creates the Parent once, creates all Children, attaches every
 Child as a native Sub-issue, creates native `blocked_by` relations, and rereads
-the complete topology. The Child Agent Brief includes a direct Parent Issue link.
+the complete topology. Every Child carries `ready-for-agent`, blocked Children
+additionally carry `blocked`, and the Parent carries neither; the tracker never
+creates labels, so a repository missing a required label fails the batch closed
+before any remote write. The Child Agent Brief includes a direct Parent Issue link.
 Internal role prompts, tool policies, review gates, model reservations, and
 prompt digests never belong in this external handoff. If
 `docs/initiatives/<slug>.md` exists, publication fails with a carrier conflict;

package/plugins/immune-brain/dist/imm-review-retro.md

@@ -0,0 +1,123 @@
+---
+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
+
+Rank models by how much code review their own edits triggered, and report
+basic project usage over a look-back window the user supplies in days. This
+is a standalone host-native analysis entry, not a Managed Path continuation
+and not an `imm-loop` internal-role dispatch. It reviews no diff — a diff
+review is `code-review`.
+
+## Boundary
+
+Allowed: read pi session JSONL under `~/.pi/agent/sessions` (or `--root`),
+run the bundled analyzer, and write a stdout report.
+
+Blocked: code, test, Spec, Plan, or `.imm/` edits; session-log writes;
+Kernel, TaskIntent, or TaskRecord mutation; Compounder or scheduled runs;
+`.imm/audit/` lifecycle statistics.
+
+An already active Managed task remains owned by `imm-loop`. This Skill does
+not create or resume Managed authority.
+
+## Invocation
+
+Requires explicit invocation: `imm-review-retro` or `/imm-review-retro`.
+Ordinary questions such as "which model is worse" stay host-native and do
+not enter this Skill.
+
+The look-back window in days is required input. If the user named one, use
+it. If not, ask before running, because the ranking moves with the window.
+
+Default scan is the user's full session-log tree. Pass `--project <substr>`
+when the user wants one repo or worktree. Do not invent a project filter.
+
+No daemon, no cron, no CI, no automatic commit.
+
+## Counting rules
+
+These rules keep numbers comparable across runs. Read the analyzer header
+aloud in the report so the 口径 stays visible.
+
+- `review` = an `Agent` tool call with `subagent_type` equal to `Review`.
+- Attribution = the model behind the most recent `edit`, `write`, or
+  `multiedit` in that session. If none, the row is `no-edit (review-only)`.
+- `uniq` counts distinct (session, description+prompt prefix) pairs. A wide
+  gap versus `reviews` is the same review re-run on the same code.
+- `rev/100ed` is `100 * reviews / devEdits`. Rank on both absolute `reviews`
+  and this intensity. A model can lead one axis and sit mid-pack on the
+  other.
+- `avgSc` / `pass%` parse `[SCORE: …]` and `[VERDICT: …]` tags from the
+  matching Review `toolResult`. Untagged reviews show `-`.
+- `registr` counts `imm_kernel_canary` `submit_review`. It is the
+  registration of the same review and is never added into `reviews`.
+- `rounds/task` is registrations per distinct `(cwd, task_id)`. High values
+  can be canary/QA harness re-registration, not human-visible rework.
+- Findings are `record_finding` calls, deduped per session. Summaries that
+  match `recorded cleanly`, `receipt recorded`, `round recorded`, or
+  `no finding(s)` are `bookkeep` / `noisy`, excluded from `block`/`advis`.
+
+Usage counters on the same pass: sessions with activity, assistant turns,
+edit counts, a tool-call name histogram, and the project × author table.
+
+## CLI
+
+Run the bundled analyzer. Prefer `bun`; `node` (≥23.6, type stripping) is
+an allowed equivalent. The script is erasable TypeScript with `node:` APIs
+only.
+
+```
+bun "<path-to-skill>/scripts/review_retro.ts" <days> [--root <sessions-dir>] [--project <substr>] [--top N]
+```
+
+- `<days>` must be `> 0`.
+- `--root` defaults to `~/.pi/agent/sessions`.
+- `--project` keeps sessions whose `cwd` contains the substring.
+- `--top` is the project-table row cap (default 15).
+- Malformed JSONL lines are skipped. `days <= 0` is a hard error.
+
+Do not scan live `.imm/` directories. Tests use committed fixtures under
+`tests/fixtures/review-retro/`.
+
+## Report
+
+Write-up order:
+
+1. Window and 口径 in one line (copy the analyzer header).
+2. Ranked model table, including scores.
+3. Usage section: sessions, turns, edits, tool mix.
+4. Quality and score findings.
+5. Three to five bullets of what the table means (volume versus intensity,
+   quality versus rework, where it concentrated).
+6. Caveats last.
+
+Rank on both axes, never one. Name the axis you are ranking by, and call
+out models that flip order between `reviews` and `rev/100ed`.
+
+Separate one-pass from rework: compare `uniq` to `reviews`, and read
+`rounds/task` on the kernel path.
+
+Evaluate quality: high intensity plus high score is frequent review of
+mostly minor issues; low intensity plus low score is rare review of severe
+defects. Call out REJECT or highRisk ratings.
+
+Ground each model in its projects. Cite the two or three worktrees where
+that model's reviews concentrated.
+
+## Caveats
+
+Anything the script splits out as `bookkeep` stays visible next to the
+column it contaminates. Flag any finding count you cannot trace to a real
+defect.
+
+High `rounds/task` can be canary/QA harness re-registration, not
+human-visible rework.
+
+This Skill does not persist snapshots or compute week-over-week diffs.
+Re-run with a new window when the user wants a later period.
+
+The personal python prototype under `~/.pi/agent/skills/review-retro/` is
+not this Skill and is not modified by it.

package/plugins/immune-brain/dist/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.