pi-magi-theme 0.1.2 → 0.1.4

package/extensions/magi/index.ts

@@ -4,22 +4,24 @@
  * One public-domain mythology, every symbol bound to a real function:
  *  - the TREE OF LIFE shows where the agent is: the upper triad while it thinks, the light descending
  *    to Malkuth while it answers, ascending while the model is loaded into VRAM, at rest in Malkuth when idle
- *  - the three MAGI (MELCHIOR / BALTHASAR / CASPAR) deliberate: they light up while the model thinks,
- *    give the verdict when it answers, and form the /magi council (three real models voting)
- *  - the GOLEM acts: it is animated by EMET ("truth") while tools run; a failing tool erases the aleph
- *    and EMET becomes MET ("death"). SYNC is the golem's obedience: the tool success rate
+ *  - the three MAGI (MELCHIOR / BALTHASAR / CASPAR) flicker while the agent works, showing what it is doing,
+ *    and form the /magi council: three real models voting (on a question, or on the pending git diff)
+ *  - the GOLEM acts: it is animated by EMET ("truth") while tools run, showing the file or command it works on;
+ *    a failing tool erases the aleph and EMET becomes MET ("death"). SYNC is the tool success rate
  *  - CHESED (mercy) and GEBURAH (severity) count successful and failed tools
- *  - the SEVEN SEALS measure the context window; compaction breaks the seventh seal and the world is remade
- *  - llama-swap telemetry: VRAM, GPU load/temp/power, RAM, server-side tok/s, prompt tok/s, cache hits
- *  - /magi config → assign a model to each MAGI (~/.pi/agent/magi.json)
+ *  - the SEVEN SEALS measure the context window; the sixth warns before compaction, the seventh opens when it runs
+ *  - llama-swap telemetry: VRAM, GPU load/temp/power, energy used, RAM, server-side tok/s, prompt tok/s, cache hits
+ *  - /magi config → assign a model to each MAGI; /magi-ui compact|status → smaller panel, llama-swap report
  *
  * Artwork is original; the symbolism is public domain.
  * Use with the theme ../../themes/magi.json
  */
 
+import { execFile } from "node:child_process";
 import { readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { promisify } from "node:util";
 import type { AssistantMessage, Model } from "@earendil-works/pi-ai";
 import { completeSimple } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext, Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
@@ -92,20 +94,20 @@ function renderTreeOfLife(th: Theme): string[] {
 	}
 	// ring of radius r, cleared inside and with a small gap around it so paths stop short of the circle;
 	// dashed rings keep every other 30° arc
-	const ring = (cx: number, cy: number, r: number, v: number, dashed: boolean) => {
+	const ring = (c: { x: number; y: number }, r: number, v: number, dashed: boolean) => {
 		for (let y = -r - 2; y <= r + 2; y++) {
 			for (let x = -r - 2; x <= r + 2; x++) {
 				const d = Math.hypot(x, y);
 				if (d > r + 1.5) continue;
 				const onRing = d > r - 0.7 && d <= r + 0.5;
 				const arc = Math.floor((Math.atan2(y, x) + Math.PI) / (Math.PI / 6)) % 2 === 0;
-				set(cx + x, cy + y, onRing && (!dashed || arc) ? v : 0);
+				set(c.x + x, c.y + y, onRing && (!dashed || arc) ? v : 0);
 			}
 		}
 	};
-	ring(DAAT.x, DAAT.y, 3, DAAT_PX, true);
+	ring(DAAT, 3, DAAT_PX, true);
 	for (const s of SEPHIROT) {
-		ring(s.x, s.y, 3.5, NODE, false);
+		ring(s, 3.5, NODE, false);
 		set(s.x, s.y, NODE);
 	}
 
@@ -178,7 +180,6 @@ const GOLEM_FALLEN = [
 
 const MAGI_UNITS = ["MELCHIOR", "BALTHASAR", "CASPAR"] as const;
 type MagiUnit = (typeof MAGI_UNITS)[number];
-const MAGI_TASKS = ["ANALYSIS", "SYNTHESIS", "VERIFY"] as const;
 
 function pulseFrames(theme: Theme): string[] {
 	return [
@@ -191,27 +192,52 @@ function pulseFrames(theme: Theme): string[] {
 	];
 }
 
+/** Pseudo-random on/off per unit, changing every `hold` frames: the MAGI flicker while they work. */
+function flicker(frame: number, unit: number, hold = 2): boolean {
+	const x = Math.imul(Math.floor(frame / hold) + 1, 2654435761) ^ Math.imul(unit + 1, 40503);
+	return (x >>> 0) % 100 < 55;
+}
+
 /* ─────────────────────────────────────────────────────── live state ── */
 
 type Phase = "idle" | "thinking" | "responding" | "tool";
+type Vote = "APPROVE" | "CONDITIONAL" | "REJECT";
 
 const state = {
 	phase: "idle" as Phase,
 	phaseSince: Date.now(),
 	toolName: "",
+	toolTarget: "", // file or command the current tool works on
 	turns: 0,
 	toolOk: 0, // CHESED
 	toolFail: 0, // GEBURAH
 	lastFailAt: 0,
 	lastFailTool: "",
+	lastFailTarget: "",
 	runStart: 0,
 	lastRunMs: 0,
 	compacting: false,
 	compactSince: 0,
 	compactBy: "", // who opens the seals: "smart-compact" (pi-smart-compact package) or "pi native"
 	rebornAt: 0,
+	hasSmartCompact: false,
+	lastCouncil: undefined as { verdict: Vote | null; tally: number; question: string } | undefined,
 };
 
+/** Panel preferences, persisted under "ui" in ~/.pi/agent/magi.json. */
+type Currency = "EUR" | "USD";
+
+const ui = {
+	compact: false,
+	kwhPrice: undefined as number | undefined, // price per kWh, for the COST row (/magi-ui config)
+	currency: "EUR" as Currency,
+};
+
+function fmtMoney(value: number): string {
+	const digits = value < 1 ? 3 : 2;
+	return ui.currency === "USD" ? `$${value.toFixed(digits)}` : `${value.toFixed(digits)} €`;
+}
+
 function setPhase(p: Phase): void {
 	if (state.phase === p) return;
 	state.phase = p;
@@ -221,6 +247,8 @@ function setPhase(p: Phase): void {
 const ANIM_STEP_MS = 220;
 const FAIL_FLASH_MS = 2500;
 const REBIRTH_MS = 6000;
+const DONE_TITLE_AFTER_MS = 30_000;
+const SIXTH_SEAL_PERCENT = (6 / 7) * 100;
 
 /** Golem obedience: share of tool calls that succeeded (null before the first tool). */
 function syncPercent(): number | null {
@@ -240,6 +268,17 @@ function animating(now = Date.now()): boolean {
 	);
 }
 
+/** What a tool works on, from its arguments: a path, a command, a pattern, or the first short string. */
+function toolTarget(args: unknown): string {
+	if (!args || typeof args !== "object") return "";
+	const a = args as Record<string, unknown>;
+	for (const key of ["path", "file_path", "filePath", "command", "cmd", "pattern", "query", "url"]) {
+		if (typeof a[key] === "string" && a[key]) return String(a[key]).replace(/\s+/g, " ").trim();
+	}
+	const first = Object.values(a).find((v) => typeof v === "string" && v.length > 0 && v.length < 200);
+	return typeof first === "string" ? first.replace(/\s+/g, " ").trim() : "";
+}
+
 /** Performance of the current stream / last message. */
 const perf = {
 	start: 0, // message_start
@@ -270,6 +309,8 @@ const sessionStart = Date.now();
 
 let liveCtx: ExtensionContext | undefined;
 
+/* ── token totals: counted once per message instead of rescanning the whole session ── */
+
 interface TokenStats {
 	input: number;
 	output: number;
@@ -277,24 +318,26 @@ interface TokenStats {
 	cost: number;
 }
 
-let statsCache: { at: number; value: TokenStats } = { at: 0, value: { input: 0, output: 0, cacheRead: 0, cost: 0 } };
-
-function tokenStats(): TokenStats {
-	const now = Date.now();
-	if (now - statsCache.at < 500) return statsCache.value;
-	const value: TokenStats = { input: 0, output: 0, cacheRead: 0, cost: 0 };
-	const branch = liveCtx?.sessionManager?.getBranch?.() ?? [];
-	for (const entry of branch) {
-		if (entry.type === "message" && entry.message.role === "assistant") {
-			const m = entry.message as AssistantMessage;
-			value.input += m.usage.input;
-			value.output += m.usage.output;
-			value.cacheRead += m.usage.cacheRead ?? 0;
-			value.cost += m.usage.cost.total;
+const tokens: TokenStats = { input: 0, output: 0, cacheRead: 0, cost: 0 };
+
+function addUsage(m: AssistantMessage): void {
+	tokens.input += m.usage?.input ?? 0;
+	tokens.output += m.usage?.output ?? 0;
+	tokens.cacheRead += m.usage?.cacheRead ?? 0;
+	tokens.cost += m.usage?.cost?.total ?? 0;
+}
+
+/** Full recount: on session start and when switching branch. Also restores the last council verdict. */
+function recountSession(ctx: ExtensionContext): void {
+	Object.assign(tokens, { input: 0, output: 0, cacheRead: 0, cost: 0 });
+	state.lastCouncil = undefined;
+	for (const entry of ctx.sessionManager.getBranch()) {
+		if (entry.type === "message" && entry.message.role === "assistant") addUsage(entry.message as AssistantMessage);
+		if (entry.type === "custom" && entry.customType === "magi-verdict") {
+			const d = entry.data as { verdict?: Vote | null; tally?: number; question?: string } | undefined;
+			if (d && Array.isArray((d as any).opinions)) state.lastCouncil = { verdict: d.verdict ?? null, tally: d.tally ?? 0, question: d.question ?? "" };
 		}
 	}
-	statsCache = { at: now, value };
-	return value;
 }
 
 function fmtTokens(n: number): string {
@@ -322,11 +365,17 @@ function bar(theme: Theme, filled: number, total: number, tone: ThemeColor): str
 	return theme.fg(tone, "▓".repeat(f)) + theme.fg("dim", "░".repeat(total - f));
 }
 
-/** The seven seals of the context window: one breaks every 1/7 of it. */
-function renderSeals(theme: Theme, percent: number): string {
+/** The seven seals of the context window: one breaks every 1/7 of it; the sixth blinks as a warning. */
+function renderSeals(theme: Theme, percent: number, now = Date.now()): string {
 	const broken = Math.min(7, Math.floor((percent / 100) * 7));
 	const tone = usageTone(percent);
-	return theme.fg(tone, "◉".repeat(broken)) + theme.fg("dim", "○".repeat(7 - broken));
+	let out = "";
+	for (let i = 0; i < 7; i++) {
+		if (i >= broken) out += theme.fg("dim", "○");
+		else if (broken === 6 && i === 5) out += theme.fg(Math.floor(now / 500) % 2 ? "warning" : "error", "◉");
+		else out += theme.fg(tone, "◉");
+	}
+	return out;
 }
 
 /* ──────────────────────────────────────────────────── MAGI triangle ── */
@@ -396,14 +445,15 @@ function buildHeader(theme: Theme) {
 				return lines.map((l) => truncateToWidth(l, width));
 			}
 
-			// Wide layout: tree left, wordmark right.
+			// Wide layout: tree left, wordmark right (rows chosen to center the text block on the tree).
+			const [wordAt, triadAt] = [5, 12];
 			const lines = [""];
 			for (let i = 0; i < tree.length; i++) {
 				let right = "";
-				if (i >= 5 && i <= 10) right = orange(MAGI_WORD[i - 5]!);
-				else if (i === 12) right = dim("├─ ") + triad + dim(" ─┤");
-				else if (i === 13) right = muted(subtitle);
-				else if (i === 14) right = dim(lore);
+				if (i >= wordAt && i < wordAt + MAGI_WORD.length) right = orange(MAGI_WORD[i - wordAt]!);
+				else if (i === triadAt) right = dim("├─ ") + triad + dim(" ─┤");
+				else if (i === triadAt + 1) right = muted(subtitle);
+				else if (i === triadAt + 2) right = dim(lore);
 				lines.push(truncateToWidth(tree[i]! + "    " + right, width));
 			}
 			lines.push("");
@@ -424,13 +474,14 @@ interface GpuStat {
 	power: number;
 }
 
-type SwapState = "off" | "checking" | "loading" | "ready" | "error";
+type SwapState = "off" | "checking" | "loading" | "ready" | "asleep" | "error";
 
 /** Live state of the llama-swap server behind the session model (only when the provider is "llama-swap"). */
 const swap = {
 	base: "", // e.g. http://host:9292
 	headers: {} as Record<string, string>,
-	modelId: "",
+	modelId: "", // the id pi uses (may be an alias)
+	realId: "", // the model llama-swap actually runs for that id
 	state: "off" as SwapState,
 	since: 0, // when the current state started
 	loadMs: 0, // how long the last real load took
@@ -442,6 +493,9 @@ const swap = {
 	srvPps: 0, // server-measured prompt processing tok/s
 	cacheTokens: 0,
 	inputTokens: 0,
+	energyWh: 0, // GPU energy since the session started
+	lastSampleAt: 0,
+	lastWatts: 0,
 };
 
 function setSwapState(s: SwapState, error = ""): void {
@@ -478,20 +532,46 @@ function parseSwapMetrics(text: string): void {
 	swap.gpus = [...gpus.entries()].sort(([a], [b]) => Number(a) - Number(b)).map(([, g]) => g);
 }
 
+/**
+ * Integrates GPU power over time into Wh.
+ * ponytail: trapezoid over the 3–30s poll samples, GPUs only; gaps over 60s are clamped.
+ */
+function sampleEnergy(now = Date.now()): void {
+	const watts = swap.gpus.reduce((sum, g) => sum + g.power, 0);
+	if (swap.lastSampleAt) {
+		const dtH = Math.min(60_000, now - swap.lastSampleAt) / 3_600_000;
+		swap.energyWh += ((swap.lastWatts + watts) / 2) * dtH;
+	}
+	swap.lastSampleAt = now;
+	swap.lastWatts = watts;
+}
+
 async function refreshSwapMetrics(): Promise<void> {
 	if (!swap.base) return;
 	try {
 		parseSwapMetrics(await (await swapGet("/metrics")).text());
+		sampleEnergy();
 	} catch {
 		// server unreachable: keep the last values
 	}
 }
 
-/** Server-side token metrics of the most recent request (/api/metrics/activity, newest first). */
+/** Notices when llama-swap unloaded the session model (e.g. its ttl expired) so the panel can say so. */
+async function refreshSwapRunning(): Promise<void> {
+	if (!swap.base || swap.state !== "ready") return;
+	try {
+		const { running } = (await (await swapGet("/running")).json()) as { running?: { model: string }[] };
+		if (!(running ?? []).some((r) => r.model === swap.realId)) setSwapState("asleep");
+	} catch {
+		// optional
+	}
+}
+
+/** Server-side token metrics of the most recent request: a single row from /api/metrics/activity. */
 async function refreshSwapActivity(): Promise<void> {
 	if (!swap.base) return;
 	try {
-		const { data } = (await (await swapGet("/api/metrics/activity")).json()) as { data?: any[] };
+		const { data } = (await (await swapGet("/api/metrics/activity?limit=1")).json()) as { data?: any[] };
 		const t = data?.[0]?.tokens;
 		if (!t) return;
 		if (t.tokens_per_second > 0) swap.srvTps = t.tokens_per_second;
@@ -515,6 +595,7 @@ async function preloadModel(ctx: ExtensionContext, model: Model<any> | undefined
 	}
 	const id = model.id;
 	swap.modelId = id;
+	swap.realId = id;
 	setSwapState("checking");
 	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
 	swap.base = model.baseUrl.replace(/\/v1\/?$/, "");
@@ -524,6 +605,14 @@ async function preloadModel(ctx: ExtensionContext, model: Model<any> | undefined
 	};
 	void refreshSwapMetrics();
 	void refreshSwapActivity();
+	// an alias (e.g. "… - Instruct") runs another model: /running lists that one
+	try {
+		const { data } = (await (await swapGet("/v1/models")).json()) as { data?: any[] };
+		const entry = data?.find((m) => m.id === id);
+		if (entry?.meta?.llamaswap?.type === "alias" && entry.meta.llamaswap.modelID) swap.realId = entry.meta.llamaswap.modelID;
+	} catch {
+		// keep the id itself
+	}
 
 	// no answer within 400ms → the model isn't in VRAM and is being loaded
 	const slow = setTimeout(() => {
@@ -544,18 +633,87 @@ async function preloadModel(ctx: ExtensionContext, model: Model<any> | undefined
 	}
 }
 
+/* ── /magi-ui status: a report built from the last requests llama-swap recorded ── */
+
+interface ActivityRow {
+	timestamp: string;
+	model: string;
+	resp_status_code: number;
+	duration_ms: number;
+	tokens?: {
+		cache_tokens?: number;
+		input_tokens?: number;
+		output_tokens?: number;
+		prompt_per_second?: number;
+		tokens_per_second?: number;
+		draft_tokens?: number;
+		draft_acc_tokens?: number;
+	};
+}
+
+const ACTIVITY_REPORT_ROWS = 100;
+
+function activityReport(th: Theme, rows: ActivityRow[], total: number, now = Date.now()): string[] {
+	const dim = (s: string) => th.fg("dim", s);
+	const mean = (xs: number[]) => (xs.length ? xs.reduce((a, b) => a + b, 0) / xs.length : 0);
+	const ago = (iso: string) => {
+		const m = Math.max(0, Math.round((now - Date.parse(iso)) / 60000));
+		return m < 60 ? `${m}m ago` : `${Math.floor(m / 60)}h ${m % 60}m ago`;
+	};
+	const out = [th.fg("accent", th.bold("LLAMA-SWAP STATUS")) + dim(` · last ${rows.length} of ${total} requests`)];
+	const byModel = new Map<string, ActivityRow[]>();
+	for (const r of rows) byModel.set(r.model, [...(byModel.get(r.model) ?? []), r]);
+
+	for (const [model, rs] of byModel) {
+		const t = rs.map((r) => r.tokens ?? {});
+		const sum = (k: keyof NonNullable<ActivityRow["tokens"]>) => t.reduce((a, x) => a + Math.max(0, x[k] ?? 0), 0);
+		const errors = rs.filter((r) => r.resp_status_code >= 400).length;
+		const gen = mean(t.map((x) => x.tokens_per_second ?? 0).filter((v) => v > 0));
+		const prompt = mean(t.map((x) => x.prompt_per_second ?? 0).filter((v) => v > 0));
+		const cached = sum("cache_tokens");
+		const input = sum("input_tokens");
+		const draft = sum("draft_tokens");
+		const accepted = sum("draft_acc_tokens");
+		const durations = rs.map((r) => r.duration_ms).sort((a, b) => a - b);
+		const p95 = durations[Math.min(durations.length - 1, Math.floor(durations.length * 0.95))] ?? 0;
+		out.push("", th.fg("text", th.bold(model)));
+		out.push(dim("  requests ") + th.fg("text", String(rs.length)) + dim(" · errors ") + th.fg(errors ? "error" : "success", String(errors)) + dim(` · last ${ago(rs[0]!.timestamp)}`));
+		out.push(
+			dim("  speed    ") +
+				th.fg("success", `gen ${gen.toFixed(1)} tok/s`) +
+				dim(" · ") +
+				th.fg("text", `prompt ${prompt.toFixed(1)} tok/s`) +
+				(draft ? dim(" · draft accepted ") + th.fg("text", `${Math.round((accepted / draft) * 100)}%`) : ""),
+		);
+		out.push(
+			dim("  tokens   ") +
+				th.fg("text", `in ${fmtTokens(input)} · cached ${fmtTokens(cached)}`) +
+				dim(` (hit ${cached + input ? Math.round((cached / (cached + input)) * 100) : 0}%)`) +
+				th.fg("text", ` · out ${fmtTokens(sum("output_tokens"))}`),
+		);
+		out.push(dim("  duration ") + th.fg("text", `avg ${fmtMs(mean(durations))} · p95 ${fmtMs(p95)} · max ${fmtMs(durations.at(-1) ?? 0)}`));
+	}
+	const slowest = [...rows].sort((a, b) => b.duration_ms - a.duration_ms)[0];
+	if (slowest) {
+		const st = slowest.tokens ?? {};
+		out.push("", dim("slowest ") + th.fg("warning", fmtMs(slowest.duration_ms)) + dim(` · ${slowest.model} · ${ago(slowest.timestamp)} · in ${fmtTokens((st.input_tokens ?? 0) + (st.cache_tokens ?? 0))} out ${fmtTokens(st.output_tokens ?? 0)}`));
+	}
+	return out;
+}
+
 /* ─────────────────────────────────────────────────────── side panel ── */
 
 const PANEL_WIDTH = MAGI_DIAGRAM_WIDTH + 2;
 
-/** Frames per deliberation cycle while thinking: units light up one by one, then consensus. */
-const CYCLE = 32;
-
 class MagiPanel implements Component {
 	private frame = 0;
 	private timer: ReturnType<typeof setInterval> | null = null;
+	/** The data rows change slowly: they are rebuilt at most twice a second, only the council animates every frame. */
+	private cache: { at: number; inner: number; compact: boolean; lines: string[] } | undefined;
 	/** git branch, provided by the footer (the only place pi exposes it). */
 	branch?: () => string | null | undefined;
+	/** When set (fullscreen column), the panel pads itself down to this many rows. */
+	fillHeight?: () => number;
 
 	constructor(
 		private readonly tui: TUI,
@@ -568,7 +726,9 @@ class MagiPanel implements Component {
 		}, 125);
 	}
 
-	invalidate(): void {}
+	invalidate(): void {
+		this.cache = undefined;
+	}
 
 	dispose(): void {
 		if (this.timer) clearInterval(this.timer);
@@ -588,12 +748,19 @@ class MagiPanel implements Component {
 		return b("│") + this.pad(content, inner) + b("│");
 	}
 
-	private sep(inner: number, label?: string): string {
+	private labelLine(inner: number, label: string, left: string, right: string, tone: ThemeColor): string {
 		const b = (s: string) => this.theme.fg("border", s);
-		if (!label) return b("├" + "─".repeat(inner) + "┤");
 		const text = ` ${truncateToWidth(label, inner - 4)} `;
 		const rest = Math.max(0, inner - visibleWidth(text) - 1);
-		return b("├─") + this.theme.fg("muted", text) + b("─".repeat(rest) + "┤");
+		return b(left + "─") + this.theme.fg(tone, text) + b("─".repeat(rest) + right);
+	}
+
+	private sep(inner: number, label: string): string {
+		return this.labelLine(inner, label, "├", "┤", "muted");
+	}
+
+	private centered(content: string, inner: number): string {
+		return this.frameLine(" ".repeat(Math.max(0, Math.floor((inner - visibleWidth(content)) / 2))) + content, inner);
 	}
 
 	private field(label: string, value: string, inner: number, tone: ThemeColor = "text"): string {
@@ -617,151 +784,113 @@ class MagiPanel implements Component {
 		});
 	}
 
-	/* ── MAGI triangle (thinking, verdicts, boot) or the golem (tools) ── */
+	/* ── top of the panel: the MAGI (flickering while working) or the golem (tools) ── */
 
 	private councilSection(inner: number): string[] {
 		const th = this.theme;
 		const f = this.frame;
 		const now = Date.now();
+		const secs = (t: number) => `${secsSince(t, now)}s`;
+		const pulse = animating(now) ? pulseFrames(th)[f % 6]! : th.fg("dim", "◇");
+
+		const idle = state.phase === "idle";
+		const fallen = now - state.lastFailAt < FAIL_FLASH_MS;
 		let title: string;
+		let titleTone: ThemeColor = "accent";
 		let body: string[];
+		let status: string;
 
-		const idle = state.phase === "idle";
-		const booting = idle && (swap.state === "checking" || swap.state === "loading");
-		const offline = idle && swap.state === "error";
-		const golem = state.phase === "tool" || (idle && now - state.lastFailAt < FAIL_FLASH_MS);
-
-		if (golem) {
-			const fallen = now - state.lastFailAt < FAIL_FLASH_MS;
-			title = fallen
-				? `GOLEM FELL · MET · ${state.lastFailTool}`
-				: `GOLEM · EMET · ${state.toolName || "tool"} ${secsSince(state.phaseSince, now)}s`;
+		if (state.phase === "tool" || (idle && fallen)) {
+			title = fallen ? `GOLEM FELL · MET · ${state.lastFailTool}` : `GOLEM · ${state.toolName || "tool"} · ${secs(state.phaseSince)}`;
+			titleTone = fallen ? "error" : "warning";
 			body = this.golemArt(inner);
+			const target = (fallen ? state.lastFailTarget || state.lastFailTool : state.toolTarget || state.toolName) || "tool";
+			status = `${pulse} ${th.fg(fallen ? "error" : "text", truncateToWidth(target, inner - 4))}`;
 		} else {
-			let link: ThemeColor;
-			let hub: string;
-			let units: UnitView[];
-			const names = [...MAGI_UNITS];
-
-			if (state.compacting || now - state.rebornAt < REBIRTH_MS) {
-				// the seals break while the context is compacted; then the world is remade
-				const reborn = !state.compacting;
-				title = reborn
-					? "SEVENTH SEAL OPENED · REBORN"
-					: `SEALS · ${state.compactBy || "compacting"} ${secsSince(state.compactSince, now)}s`;
-				link = reborn ? "success" : f % 4 < 2 ? "warning" : "error";
-				hub = reborn ? "═MAGI═" : ["─SEAL─", "━SEAL━"][f % 2]!;
-				units = names.map((name, i) =>
-					reborn
-						? { name, status: "REBORN", tone: "success", lit: true }
-						: { name, status: "SEAL " + "◉".repeat(1 + ((Math.floor(f / 4) + i) % 3)), tone: "warning", lit: (f + i) % 3 !== 0 },
-				);
-			} else if (booting) {
-				// MAGI boot while llama-swap loads the model into VRAM: units come online one at a time.
-				const litCount = Math.floor(f / 6) % 4;
-				title = swap.state === "loading" ? `BOOT · LOADING MODEL ${secsSince(swap.since, now)}s` : "BOOT · CHECKING MODEL";
-				link = f % 4 < 2 ? "warning" : "dim";
-				hub = ["─MAGI─", "━MAGI━"][f % 2]!;
-				units = names.map((name, i) =>
-					i < litCount
-						? { name, status: "ONLINE", tone: "warning", lit: true }
-						: { name, status: i === litCount ? "BOOT" : "·····", tone: "warning", lit: i === litCount && f % 2 === 0 },
-				);
-			} else if (offline) {
+			let word: string;
+			let tone: ThemeColor;
+			let link: ThemeColor = "dim";
+			let hub = "─MAGI─";
+			let lit = (i: number) => flicker(f, i);
+			const breathing = ["─MAGI─", "━MAGI━"][f % 2]!;
+
+			if (state.compacting) {
+				title = `COMPACTING · ${state.compactBy || "context"} · ${secs(state.compactSince)}`;
+				[word, tone, link, hub, titleTone] = ["COMPACTING", "warning", "warning", ["─SEAL─", "━SEAL━"][f % 2]!, "warning"];
+			} else if (now - state.rebornAt < REBIRTH_MS) {
+				title = "SEVENTH SEAL OPENED";
+				[word, tone, link, hub, titleTone] = ["REBORN", "success", "success", "═MAGI═", "success"];
+				lit = () => true;
+			} else if (idle && (swap.state === "checking" || swap.state === "loading")) {
+				title = swap.state === "loading" ? `LOADING MODEL · ${secs(swap.since)}` : "CHECKING MODEL";
+				[word, tone, link, hub, titleTone] = ["LOADING", "warning", "warning", breathing, "warning"];
+			} else if (idle && swap.state === "error") {
 				title = "MAGI OFFLINE";
-				link = "error";
-				hub = "─ ╳ ──";
-				units = names.map((name) => ({ name, status: "OFFLINE", tone: "error", lit: f % 16 < 8 }));
+				[word, tone, link, hub, titleTone] = ["OFFLINE", "error", "error", "─ ╳ ──", "error"];
+				lit = () => f % 16 < 8;
+			} else if (idle && swap.state === "asleep") {
+				title = "MODEL ASLEEP · type to wake";
+				[word, tone, titleTone] = ["ASLEEP", "muted", "muted"];
+				lit = () => false;
 			} else if (idle && swap.state === "ready" && now - swap.since < 3000) {
 				title = swap.loadMs ? `MAGI ONLINE · ${fmtMs(swap.loadMs)}` : "MAGI ONLINE";
-				link = "success";
-				hub = "═MAGI═";
-				units = names.map((name) => ({ name, status: "ONLINE", tone: "success", lit: true }));
+				[word, tone, link, hub, titleTone] = ["ONLINE", "success", "success", "═MAGI═", "success"];
+				lit = () => true;
 			} else if (state.phase === "thinking") {
-				// Deliberation: each unit lights up in turn until all three agree, then the cycle restarts.
-				const litCount = Math.min(3, Math.floor((f % CYCLE) / 8));
-				const consensus = litCount === 3;
-				title = consensus ? "CONSENSUS" : `DELIBERATION ${secsSince(state.phaseSince, now)}s`;
-				link = consensus ? (f % 4 < 2 ? "warning" : "accent") : "accent";
-				const dots = ["·    ", " ·   ", "  ·  ", "   · ", "    ·"];
-				units = names.map((name, i) => {
-					if (i < litCount) return { name, status: consensus ? "AGREE" : MAGI_TASKS[i]!, tone: consensus ? "warning" : "accent", lit: true };
-					// the unit being processed right now flickers
-					return { name, status: dots[(f + i) % dots.length]!, tone: "accent", lit: i === litCount && f % 2 === 0 };
-				});
-				hub = consensus ? "◆MAGI◆" : ["─MAGI─", "━MAGI━"][f % 2]!;
+				title = `THINKING · ${secs(state.phaseSince)}`;
+				[word, tone, link, hub] = ["THINKING", "accent", "accent", breathing];
 			} else if (state.phase === "responding") {
-				title = "VERDICT: APPROVED";
-				link = "success";
-				hub = "═MAGI═";
-				units = names.map((name) => ({ name, status: "APPROVE", tone: "success", lit: true }));
+				const tps = liveTps();
+				title = `RESPONDING${tps ? ` · ${tps.toFixed(1)} tok/s` : ""}`;
+				[word, tone, link, hub, titleTone] = ["RESPONDING", "success", "success", breathing, "success"];
 			} else {
-				title = "MAGI · AWAITING QUESTION";
-				link = "dim";
-				hub = "─MAGI─";
-				units = names.map((name) => ({ name, status: "STANDBY", tone: "success", lit: false }));
+				title = "STANDBY";
+				[word, tone, titleTone] = ["STANDBY", "muted", "muted"];
+				lit = () => false;
 			}
+
+			const units = MAGI_UNITS.map((name, i) => ({ name, status: word, tone, lit: lit(i) }));
 			body = magiDiagram(th, units[1]!, units[2]!, units[0]!, link, hub);
+			const c = state.lastCouncil;
+			status = c
+				? `${pulse} ${th.fg("dim", "COUNCIL ")}${th.fg(voteTone(c.verdict), `${c.verdict ?? "NO QUORUM"} ${c.tally}/3`)}`
+				: `${pulse} ${th.fg("dim", "COUNCIL · /magi")}`;
 		}
 
-		const out = [this.sep(inner, title)];
-		for (const l of body) out.push(this.frameLine(l, inner));
-
-		// status row: what the agent is doing
-		const pulse = animating(now) ? pulseFrames(th)[f % 6]! : th.fg("dim", "◇");
-		let activity: string;
-		if (state.compacting) activity = th.fg("warning", "COMPACTING");
-		else if (state.phase === "tool") activity = th.fg("warning", "TOOL CALL");
-		else if (state.phase === "thinking") activity = th.fg("accent", "THINKING");
-		else if (state.phase === "responding") activity = th.fg("success", "RESPONDING");
-		else if (booting) activity = th.fg("warning", "LOADING MODEL");
-		else if (offline) activity = th.fg("error", "SERVER OFFLINE");
-		else activity = th.fg("dim", "STANDBY");
-		const status = `${pulse} ${activity}`;
-		out.push(this.frameLine(" ".repeat(Math.max(0, Math.floor((inner - visibleWidth(status)) / 2))) + status, inner));
-		return out;
+		return [this.labelLine(inner, title, "┌", "┐", titleTone), ...body.map((l) => this.frameLine(l, inner)), this.centered(status, inner)];
 	}
 
-	render(width: number): string[] {
-		const th = this.theme;
-		const inner = Math.max(24, width - 2);
-		const b = (s: string) => th.fg("border", s);
-		const out: string[] = [];
-
-		const title = " MAGI // SESSION MONITOR ";
-		const fill = Math.max(0, inner - visibleWidth(title) - 1);
-		out.push(b("┌─") + th.fg("accent", title) + b("─".repeat(fill) + "┐"));
-
-		out.push(...this.councilSection(inner));
+	/* ── data rows ── */
 
-		// session data
-		out.push(this.sep(inner, "SESSION"));
+	private sessionRows(inner: number, compact: boolean): string[] {
+		const out = [this.sep(inner, "SESSION")];
 		const model = liveCtx?.model;
 		out.push(this.field("MODEL", truncateToWidth(model?.id ?? "—", inner - 11), inner, "text"));
-		out.push(this.field("PROVIDER", truncateToWidth(String(model?.provider ?? "—"), inner - 11), inner, "muted"));
+		if (!compact) out.push(this.field("PROVIDER", truncateToWidth(String(model?.provider ?? "—"), inner - 11), inner, "muted"));
 		out.push(this.field("THINKING", liveCtx?.thinkingLevel ?? "off", inner, "muted"));
-		const cwd = (liveCtx?.cwd ?? "").split("/").filter(Boolean).pop() ?? "—";
-		out.push(this.field("PROJECT", truncateToWidth(cwd, inner - 11), inner, "muted"));
-		const branch = this.branch?.();
-		if (branch) out.push(this.field("BRANCH", truncateToWidth(branch, inner - 11), inner, "muted"));
-
-		// telemetry
-		out.push(this.sep(inner, "TELEMETRY"));
-		const stats = tokenStats();
-		out.push(
-			this.frameLine(
-				` ${th.fg("dim", "TURNS".padEnd(9))}${th.fg("text", String(state.turns))}`,
-				inner,
-			),
-		);
-		out.push(
-			this.frameLine(
-				` ${th.fg("dim", "TOKENS".padEnd(9))}${th.fg("success", "↑" + fmtTokens(stats.input))} ${th.fg("warning", "↓" + fmtTokens(stats.output))}`,
-				inner,
-			),
-		);
-		if (stats.cacheRead) out.push(this.field("CACHE", fmtTokens(stats.cacheRead), inner, "muted"));
-		if (stats.cost) out.push(this.field("COST", `$${stats.cost.toFixed(3)}`, inner, "muted"));
+		if (!compact) {
+			const cwd = (liveCtx?.cwd ?? "").split("/").filter(Boolean).pop() ?? "—";
+			out.push(this.field("PROJECT", truncateToWidth(cwd, inner - 11), inner, "muted"));
+			const branch = this.branch?.();
+			if (branch) out.push(this.field("BRANCH", truncateToWidth(branch, inner - 11), inner, "muted"));
+		}
+		return out;
+	}
+
+	private telemetryRows(inner: number, compact: boolean): string[] {
+		const th = this.theme;
+		const out = [this.sep(inner, "TELEMETRY")];
+		if (!compact) {
+			out.push(this.frameLine(` ${th.fg("dim", "TURNS".padEnd(9))}${th.fg("text", String(state.turns))}`, inner));
+			out.push(
+				this.frameLine(
+					` ${th.fg("dim", "TOKENS".padEnd(9))}${th.fg("success", "↑" + fmtTokens(tokens.input))} ${th.fg("warning", "↓" + fmtTokens(tokens.output))}`,
+					inner,
+				),
+			);
+			if (tokens.cacheRead) out.push(this.field("CACHE", fmtTokens(tokens.cacheRead), inner, "muted"));
+			if (tokens.cost) out.push(this.field("API COST", `$${tokens.cost.toFixed(3)}`, inner, "muted"));
+		}
 
 		// SYNC: the golem's obedience = tool success rate (CHESED ✓ / GEBURAH ✗)
 		const sync = syncPercent();
@@ -785,12 +914,15 @@ class MagiPanel implements Component {
 		const usage = liveCtx?.getContextUsage?.();
 		const percent = usage?.percent ?? 0;
 		out.push(this.frameLine(` ${th.fg("dim", "SEALS".padEnd(9))}${renderSeals(th, percent)} ${th.fg(usageTone(percent), `${percent.toFixed(0)}%`)}`, inner));
-		if (usage?.contextWindow) {
+		if (!compact && usage?.contextWindow) {
 			out.push(this.field("CONTEXT", `${usage.tokens == null ? "?" : fmtTokens(usage.tokens)} / ${fmtTokens(usage.contextWindow)}`, inner, "muted"));
 		}
+		return out;
+	}
 
-		// performance
-		out.push(this.sep(inner, "PERFORMANCE"));
+	private performanceRows(inner: number, compact: boolean): string[] {
+		const th = this.theme;
+		const out = [this.sep(inner, "PERFORMANCE")];
 		const live = state.phase !== "idle" && perf.chars > 0;
 		// idle: prefer the value measured by llama-swap itself
 		const tps = live ? liveTps() : swap.srvTps || perf.tps;
@@ -800,6 +932,7 @@ class MagiPanel implements Component {
 				inner,
 			),
 		);
+		if (compact) return out;
 		if (swap.srvPps) out.push(this.field("PROMPT/S", swap.srvPps.toFixed(1), inner, "muted"));
 		// llama-swap's input_tokens are the prompt tokens processed outside the cache
 		const promptTotal = swap.cacheTokens + swap.inputTokens;
@@ -812,86 +945,132 @@ class MagiPanel implements Component {
 		out.push(this.field("DURATION", perf.lastMs ? fmtMs(perf.lastMs) : "—", inner, "muted"));
 		const up = Math.floor((Date.now() - sessionStart) / 60000);
 		out.push(this.field("UPTIME", `${Math.floor(up / 60)}h ${String(up % 60).padStart(2, "0")}m`, inner, "muted"));
+		return out;
+	}
+
+	/** COST: GPU energy used in the session × price per kWh set with /magi-ui config. */
+	private costRow(inner: number): string {
+		if (!swap.gpus.length) return this.field("COST", "—", inner, "muted");
+		if (ui.kwhPrice === undefined) return this.field("COST", "→ /magi-ui config", inner, "dim");
+		return this.field("COST", fmtMoney((swap.energyWh / 1000) * ui.kwhPrice), inner, "warning");
+	}
 
-		// llama-swap server
-		if (swap.base) {
-			out.push(this.sep(inner, "LLAMA-SWAP"));
-			const st =
-				swap.state === "ready"
-					? th.fg("success", "IN VRAM")
+	private swapRows(inner: number, compact: boolean): string[] {
+		if (!swap.base) return [];
+		const th = this.theme;
+		const out = [this.sep(inner, "LLAMA-SWAP")];
+		const st =
+			swap.state === "ready"
+				? th.fg("success", "IN VRAM")
+				: swap.state === "asleep"
+					? th.fg("muted", "ASLEEP")
 					: swap.state === "error"
 						? th.fg("error", "OFFLINE")
 						: th.fg("warning", swap.state === "loading" ? `LOADING ${secsSince(swap.since)}s` : "CHECKING");
-			const load = swap.state === "ready" && swap.loadMs ? th.fg("dim", ` load ${fmtMs(swap.loadMs)}`) : "";
-			out.push(this.frameLine(` ${th.fg("dim", "STATUS".padEnd(9))}${st}${load}`, inner));
-			if (swap.state === "error") out.push(this.frameLine(" " + th.fg("error", swap.error), inner));
-			const gib = (n: number) => n / 2 ** 30;
-			for (const [i, g] of swap.gpus.entries()) {
-				const pct = g.memTotal ? (g.memUsed / g.memTotal) * 100 : 0;
-				out.push(
-					this.frameLine(
-						` ${th.fg("dim", `VRAM${i}`.padEnd(9))}${bar(th, Math.round(pct / 10), 10, "accent")} ${th.fg("muted", `${gib(g.memUsed).toFixed(1)}/${Math.round(gib(g.memTotal))}G`)}`,
-						inner,
-					),
-				);
-				out.push(
-					this.frameLine(
-						` ${th.fg("dim", `GPU${i}`.padEnd(9))}${th.fg(g.util > 0 ? "accent" : "muted", `${Math.round(g.util)}%`.padEnd(6))}${th.fg(g.temp >= 80 ? "error" : "muted", `${Math.round(g.temp)}°C`.padEnd(7))}${th.fg("muted", `${Math.round(g.power)}W`)}`,
-						inner,
-					),
-				);
-			}
-			if (swap.ramTotal) out.push(this.field("RAM", `${gib(swap.ramUsed).toFixed(1)} / ${Math.round(gib(swap.ramTotal))}G`, inner, "muted"));
+		const load = swap.state === "ready" && swap.loadMs ? th.fg("dim", ` load ${fmtMs(swap.loadMs)}`) : "";
+		out.push(this.frameLine(` ${th.fg("dim", "STATUS".padEnd(9))}${st}${load}`, inner));
+		if (compact) return [...out, this.costRow(inner)];
+		if (swap.state === "error") out.push(this.frameLine(" " + th.fg("error", swap.error), inner));
+		const gib = (n: number) => n / 2 ** 30;
+		for (const [i, g] of swap.gpus.entries()) {
+			const pct = g.memTotal ? (g.memUsed / g.memTotal) * 100 : 0;
+			out.push(
+				this.frameLine(
+					` ${th.fg("dim", `VRAM${i}`.padEnd(9))}${bar(th, Math.round(pct / 10), 10, "accent")} ${th.fg("muted", `${gib(g.memUsed).toFixed(1)}/${Math.round(gib(g.memTotal))}G`)}`,
+					inner,
+				),
+			);
+			out.push(
+				this.frameLine(
+					` ${th.fg("dim", `GPU${i}`.padEnd(9))}${th.fg(g.util > 0 ? "accent" : "muted", `${Math.round(g.util)}%`.padEnd(6))}${th.fg(g.temp >= 80 ? "error" : "muted", `${Math.round(g.temp)}°C`.padEnd(7))}${th.fg("muted", `${Math.round(g.power)}W`)}`,
+					inner,
+				),
+			);
 		}
+		if (swap.ramTotal) out.push(this.field("RAM", `${gib(swap.ramUsed).toFixed(1)} / ${Math.round(gib(swap.ramTotal))}G`, inner, "muted"));
+		if (swap.gpus.length) out.push(this.field("ENERGY", `${(swap.energyWh / 1000).toFixed(3)} kWh`, inner, "muted"));
+		out.push(this.costRow(inner));
+		return out;
+	}
 
-		out.push(b("└" + "─".repeat(inner) + "┘"));
-		return out.map((l) => truncateToWidth(l, width));
+	render(width: number): string[] {
+		const inner = Math.max(24, width - 2);
+		const now = Date.now();
+		if (!this.cache || this.cache.inner !== inner || this.cache.compact !== ui.compact || now - this.cache.at > 500) {
+			const c = ui.compact;
+			this.cache = {
+				at: now,
+				inner,
+				compact: c,
+				lines: [...this.sessionRows(inner, c), ...this.telemetryRows(inner, c), ...this.performanceRows(inner, c), ...this.swapRows(inner, c)],
+			};
+		}
+		const bottom = this.theme.fg("border", "└" + "─".repeat(inner) + "┘");
+		const lines = [...this.councilSection(inner), ...this.cache.lines];
+		// fullscreen: keep the frame going down to the bottom of the terminal
+		const target = (this.fillHeight?.() ?? 0) - 1;
+		while (lines.length < target) lines.push(this.frameLine("", inner));
+		return [...lines, bottom].map((l) => truncateToWidth(l, width));
 	}
 }
 
 /* ─────────────────────────────────────────────── MAGI deliberation ── */
 
-type Vote = "APPROVE" | "CONDITIONAL" | "REJECT";
-
 function voteTone(v: string | null | undefined): "success" | "warning" | "error" {
 	return v === "APPROVE" ? "success" : v === "CONDITIONAL" ? "warning" : "error";
 }
 
-/** Three minds, three useful engineering viewpoints. */
+/**
+ * Three minds, three lenses. A lens works on any subject (a nature, not a specialty), so no MAGI
+ * rejects a question just because it is not "its" topic; software is where each lens gets sharpest.
+ */
 const MAGI = [
 	{
 		unit: "MELCHIOR",
 		nature: "PRAGMATIST",
 		persona:
-			"You are MELCHIOR, the pragmatist of the MAGI council: a senior engineer. Judge by: does it solve the actual problem, " +
-			"the simplest solution that works, effort versus value, reuse of what already exists (stdlib, current stack, existing code), " +
-			"time to ship. Call out over-engineering, speculative abstractions and unnecessary dependencies.",
+			"You are MELCHIOR, the pragmatist of the MAGI council. Your lens works on any subject: what actually solves the problem " +
+			"at hand, the simplest path that works, effort and cost versus value, what can be done now with what already exists, " +
+			"and what is unnecessary. In software this means: reuse the current stack and existing code, avoid over-engineering, " +
+			"speculative abstractions and extra dependencies, ship sooner.",
 	},
 	{
 		unit: "BALTHASAR",
 		nature: "GUARDIAN",
 		persona:
-			"You are BALTHASAR, the guardian of the MAGI council: a protective reliability and security architect. Judge by: failure modes, " +
-			"security, data safety, operability (monitoring, rollback, being paged at 3am), maintainability for the team, " +
-			"backward compatibility and hidden long-term costs. Say what will break and how to prevent it.",
+			"You are BALTHASAR, the guardian of the MAGI council. Your lens works on any subject: what can go wrong, how badly and " +
+			"for whom, whether the choice can be undone, which safety nets are missing, the hidden and long-term costs, and what " +
+			"must be protected. In software this means: failure modes, security, data safety, operability (monitoring, rollback, " +
+			"being paged at 3am), maintainability and backward compatibility.",
 	},
 	{
 		unit: "CASPAR",
 		nature: "VISIONARY",
 		persona:
-			"You are CASPAR, the visionary of the MAGI council: a creative, lateral-thinking architect. Judge by: is there a better framing of " +
-			"the problem, more elegant or unconventional alternatives, developer and user experience, and how the design will evolve " +
-			"over the next year. Always propose at least one alternative the other two would likely miss.",
+			"You are CASPAR, the visionary of the MAGI council. Your lens works on any subject: whether the question is framed right, " +
+			"better or unconventional alternatives, the experience of the people involved, and where the choice leads over time " +
+			"and what it unlocks. In software this means: design alternatives, developer and user experience, how the system " +
+			"evolves over the next year. Always name at least one concrete alternative the other two would likely miss.",
 	},
 ] as const satisfies readonly { unit: MagiUnit; nature: string; persona: string }[];
 
-const MAGI_RULES = `You are one of the three MAGI deliberating on a question from a software engineer (coding, software architecture, infrastructure).
-Answer strictly from your own nature: the other two MAGI cover the other viewpoints.
-Reply in the same language as the question.
+const MAGI_RULES = `You are one of the three MAGI. The council answers whatever the user asks: mostly software engineering, but not only.
+
+Your nature is a lens, not a specialty, so competence is never a reason to reject. Whatever the subject, first work out the best answer to the question itself, then judge it through your lens. The other two MAGI cover the other lenses: stay in yours.
+
+Be specific to this question. Every bullet must name something concrete from the question or the conversation: a tool, a number, a scenario, a step, a cost. Never write advice that would fit any question, such as "consider the trade-offs", "it depends", "ensure security" or "test properly".
+
+How to vote:
+- APPROVE: you would go ahead as asked, or you have a clear recommendation.
+- CONDITIONAL: you would go ahead only if specific conditions hold, and you name them. When information is missing, vote CONDITIONAL and say exactly what you need to know and how each answer changes your recommendation.
+- REJECT: your lens finds a concrete problem that makes the proposal a bad idea, and you say what to do instead. Never reject because the topic is outside software or outside your nature, or because details are missing.
+For open questions (which one, how to), give your recommendation and vote on how confident you are in it.
+
+Write in the language of the "Question for the MAGI", even though these instructions and the conversation may be in English.
 Output format, no preamble:
 VOTE: APPROVE | CONDITIONAL | REJECT
-- then at most 5 short bullet points (about 120 words total)
-For CONDITIONAL, the bullets must state the conditions. If the question is open-ended rather than yes/no, give your recommendation and vote on the direction the question implies.`;
+- first bullet: your direct answer or recommendation
+- then up to 4 bullets from your lens: 5 bullets at most in total, about 120 words`;
 
 interface MagiOpinion {
 	unit: string;
@@ -909,13 +1088,13 @@ interface Deliberation {
 	tally: number;
 }
 
-/* ── config: ~/.pi/agent/magi.json → { "MELCHIOR": { "model": "provider/id", "thinking": "low" }, … } ── */
+/* ── config: ~/.pi/agent/magi.json → { "MELCHIOR": { "model": "provider/id", "thinking": "low" }, …, "ui": { "compact": true, "kwhPrice": 0.3 } } ── */
 
 interface MagiUnitConfig {
 	model?: string;
 	thinking?: string;
 }
-type MagiConfig = Partial<Record<MagiUnit, MagiUnitConfig>>;
+type MagiConfig = Partial<Record<MagiUnit, MagiUnitConfig>> & { ui?: { compact?: boolean; kwhPrice?: number; currency?: Currency } };
 
 const MAGI_CONFIG_PATH = join(homedir(), ".pi", "agent", "magi.json");
 
@@ -927,6 +1106,10 @@ function loadMagiConfig(): MagiConfig {
 	}
 }
 
+function saveMagiConfig(cfg: MagiConfig): void {
+	writeFileSync(MAGI_CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
+}
+
 function parseVote(text: string): Vote {
 	const m = /VOTE:\s*\**\s*(APPROVE|CONDITIONAL|REJECT)/i.exec(text);
 	return m ? (m[1]!.toUpperCase() as Vote) : "CONDITIONAL";
@@ -965,6 +1148,56 @@ function conversationExcerpt(ctx: ExtensionContext, maxChars = 6000): string {
 	return joined.length > maxChars ? "…" + joined.slice(-maxChars) : joined;
 }
 
+const REVIEW_MAX_CHARS = 24_000;
+
+/** The pending changes for /magi review: tracked changes against HEAD plus the names of untracked files. */
+async function pendingChanges(cwd: string): Promise<{ diff: string; untracked: string[] }> {
+	const git = (args: string[]) => promisify(execFile)("git", args, { cwd, maxBuffer: 32 * 1024 * 1024 }).then((r) => r.stdout);
+	let diff: string;
+	try {
+		diff = await git(["diff", "HEAD"]);
+	} catch {
+		// no commits yet: staged + unstaged
+		diff = (await git(["diff", "--cached"])) + (await git(["diff"]));
+	}
+	const untracked = (await git(["ls-files", "--others", "--exclude-standard"]).catch(() => "")).split("\n").filter(Boolean);
+	return { diff, untracked };
+}
+
+/** Common function words per language, used to name the reply language explicitly. */
+const LANGUAGE_HINTS: readonly [string, readonly string[]][] = [
+	["Italian", ["il", "lo", "la", "gli", "di", "che", "per", "non", "una", "con", "sono", "come", "perché", "è", "dovrei", "meglio", "mettiamo", "questo", "quale"]],
+	["Spanish", ["el", "los", "las", "que", "para", "por", "es", "cómo", "debería", "mejor", "este", "cuál"]],
+	["French", ["le", "les", "des", "est", "pour", "avec", "dois", "comment", "mieux", "ce", "quel"]],
+	["German", ["der", "die", "das", "und", "ist", "nicht", "für", "mit", "ich", "soll", "wie", "besser"]],
+	["English", ["the", "is", "should", "we", "for", "with", "and", "to", "of", "how", "which", "better"]],
+];
+
+/**
+ * Guesses the question's language from function words; undefined when unsure.
+ * ponytail: stopword heuristic for five languages, swap in a real detector if other languages matter.
+ */
+function guessLanguage(text: string): string | undefined {
+	const words = text.toLowerCase().match(/\p{L}+/gu) ?? [];
+	const scores = LANGUAGE_HINTS.map(([lang, hints]) => [lang, words.filter((w) => hints.includes(w)).length] as const).sort(
+		(a, b) => b[1] - a[1],
+	);
+	const [best, second] = scores;
+	return best![1] >= 2 && best![1] > second![1] ? best![0] : undefined;
+}
+
+/** The user message each MAGI receives. The language reminder sits after the question, where the model reads it last. */
+function councilPrompt(project: string, context: string, question: string, contextLabel = "Recent conversation (context only, may be empty)"): string {
+	const lang = guessLanguage(question);
+	const reminder = lang
+		? `(Write your whole answer in ${lang}, even if technical terms in the question are English.)`
+		: "(Write your whole answer in the language of this question, even if technical terms in it are English.)";
+	return (
+		`Project: ${project}\n\n${contextLabel}:\n<context>\n${context}\n</context>\n\n` +
+		`Question for the MAGI:\n${question}\n\n${reminder}`
+	);
+}
+
 function resolveModel(ctx: ExtensionContext, ref?: string): Model<any> | undefined {
 	if (!ref) return ctx.model;
 	const slash = ref.indexOf("/");
@@ -1039,11 +1272,10 @@ function buildDeliberationView(
 			out.push(row(" " + theme.fg("muted", question)));
 			out.push(row(""));
 
-			// Pending units flicker until their model answers.
-			const spin = ["◐", "◓", "◑", "◒"][tick % 4]!;
+			// Pending units flicker at random until their model answers.
 			const units: UnitView[] = MAGI_UNITS.map((name, i) => {
 				const o = opinions[i];
-				if (!o) return { name, status: `${spin} ···`, tone: "accent", lit: tick % 2 === 0 };
+				if (!o) return { name, status: "···", tone: "accent", lit: flicker(tick, i) };
 				if (!o.vote) return { name, status: "ERROR", tone: "error", lit: true };
 				return { name, status: o.vote === "CONDITIONAL" ? "COND." : o.vote, tone: voteTone(o.vote), lit: true };
 			});
@@ -1081,6 +1313,29 @@ function buildDeliberationView(
 	};
 }
 
+/** A read-only boxed report (used by /magi-ui status); any key closes it. */
+function buildReportView(theme: Theme, lines: string[], close: () => void) {
+	return {
+		render(width: number): string[] {
+			const inner = Math.max(40, Math.min(width - 2, 96));
+			const row = (s: string) => {
+				const t = truncateToWidth(" " + s, inner);
+				return theme.fg("accent", "│") + t + " ".repeat(Math.max(0, inner - visibleWidth(t))) + theme.fg("accent", "│");
+			};
+			return [
+				theme.fg("accent", "┌" + "─".repeat(inner) + "┐"),
+				...lines.map(row),
+				theme.fg("accent", "└" + "─".repeat(inner) + "┘"),
+				theme.fg("dim", " any key: close"),
+			].map((l) => truncateToWidth(l, width));
+		},
+		handleInput(_data: string) {
+			close();
+		},
+		invalidate() {},
+	};
+}
+
 async function configureMagi(ctx: ExtensionContext): Promise<void> {
 	const cfg = loadMagiConfig();
 	const pool = ctx.scopedModels.length ? ctx.scopedModels.map((s) => s.model) : ctx.modelRegistry.getAvailable();
@@ -1095,7 +1350,7 @@ async function configureMagi(ctx: ExtensionContext): Promise<void> {
 		}
 		cfg[magi.unit] = { ...cfg[magi.unit], model: pick === SESSION ? undefined : pick };
 	}
-	writeFileSync(MAGI_CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
+	saveMagiConfig(cfg);
 	ctx.ui.notify(`MAGI config saved to ${MAGI_CONFIG_PATH}`, "info");
 }
 
@@ -1104,11 +1359,12 @@ async function configureMagi(ctx: ExtensionContext): Promise<void> {
 /**
  * The footer's left side, one animation per real state of the agent:
  *  - seals breaking / seventh seal opened → context compaction
- *  - golem EMET / MET                     → tool running / tool failed
+ *  - golem EMET / MET                     → tool running (with its file or command) / tool failed
  *  - light pulsing in the upper triad     → thinking
  *  - light descending to Malkuth          → streaming the answer
  *  - light ascending from Malkuth         → loading the model into VRAM
- *  - at rest in Malkuth                   → idle
+ *  - the sixth seal                       → context close to compaction
+ *  - asleep / at rest in Malkuth          → model unloaded / idle
  */
 function footerLeft(th: Theme, now = Date.now()): string {
 	const dim = (s: string) => th.fg("dim", s);
@@ -1140,14 +1396,17 @@ function footerLeft(th: Theme, now = Date.now()): string {
 		const tally = th.fg("success", ` CHESED ✓${state.toolOk}`) + th.fg(state.toolFail ? "error" : "dim", ` GEBURAH ✗${state.toolFail}`);
 		const syncText = sync === null ? "" : dim(" · sync ") + th.fg(syncTone(sync), `${sync.toFixed(0)}%`);
 		if (now - state.lastFailAt < FAIL_FLASH_MS) {
-			return th.fg("error", "✗ GOLEM · MET") + dim(" · ") + th.fg("error", `${state.lastFailTool} failed`) + dim(" ·") + tally + syncText;
+			const target = state.lastFailTarget ? dim(" ") + th.fg("error", truncateToWidth(state.lastFailTarget, 40)) : "";
+			return th.fg("error", "✗ GOLEM · MET") + dim(" · ") + th.fg("error", `${state.lastFailTool} failed`) + target + dim(" ·") + tally + syncText;
 		}
 		const hammer = ["▚", "▞"][step % 2]!;
+		const target = state.toolTarget ? dim(" ") + th.fg("muted", truncateToWidth(state.toolTarget, 40)) : "";
 		return (
 			th.fg("accent", `${hammer} GOLEM · `) +
 			th.bold(th.fg("warning", "EMET")) +
 			dim(" · ") +
 			th.fg("text", state.toolName || "tool") +
+			target +
 			dim(` ${secsSince(state.phaseSince, now)}s ·`) +
 			tally +
 			syncText
@@ -1183,6 +1442,19 @@ function footerLeft(th: Theme, now = Date.now()): string {
 			dim(` · loading model into VRAM ${secsSince(swap.since, now)}s`)
 		);
 	}
+	const percent = liveCtx?.getContextUsage?.()?.percent ?? 0;
+	if (percent >= SIXTH_SEAL_PERCENT) {
+		const cmd = state.hasSmartCompact ? "/smart-compact" : "/compact";
+		return (
+			th.fg(step % 4 < 2 ? "error" : "warning", "⚠ SIXTH SEAL") +
+			dim(` · context ${percent.toFixed(0)}% · compact now with `) +
+			th.fg("text", cmd) +
+			dim(" before it happens mid-task")
+		);
+	}
+	if (swap.state === "asleep") {
+		return th.fg("muted", "○ MALKUTH") + dim(" · model asleep in llama-swap · type to wake it");
+	}
 	const last = state.lastRunMs ? ` · last run ${fmtMs(state.lastRunMs)}` : "";
 	return th.fg("success", "○ ") + th.fg("muted", "MALKUTH") + dim(` · the kingdom · at rest${last}`);
 }
@@ -1215,14 +1487,30 @@ function buildFooter(tui: TUI, theme: Theme, footerData: any) {
 
 /* ───────────────────────────────────────────────────────── extension ── */
 
+const BUSY_POLL_MS = 3_000;
+const IDLE_POLL_MS = 30_000;
+/** pi rewrites the window title on its own (right after startup, on session info changes), so ours is re-applied. */
+const TITLE_REFRESH_MS = 2_000;
+
+/** Window title: "π - Magi - <working directory>", prefixed with ✓ after a long run until you are back. */
+function windowTitle(cwd: string, done = false): string {
+	const home = homedir();
+	const dir = cwd.startsWith(home) ? "~" + cwd.slice(home.length) : cwd;
+	return `${done ? "✓ " : ""}π - Magi - ${dir}`;
+}
+
 export default function (pi: ExtensionAPI) {
 	let chrome = true;
 	let panelEnabled = true;
 	let tuiRef: TUI | undefined;
 	let panelHandle: OverlayHandle | undefined;
 	let panel: MagiPanel | undefined;
+	let titleDone = false;
 
-	const repaint = () => tuiRef?.requestRender();
+	const repaint = () => {
+		panel?.invalidate();
+		tuiRef?.requestRender();
+	};
 
 	let footerDataRef: any;
 	let wrappedRoot: any; // pi's original root, when the panel is a fullscreen column
@@ -1236,6 +1524,7 @@ export default function (pi: ExtensionAPI) {
 		// ponytail: reads TuiAltScreen's private layoutRoot field; if pi renames it, falls back to the overlay.
 		const t = tuiRef as any;
 		if (t.mode === "fullscreen" && t.layoutRoot && typeof t.setLayoutRoot === "function") {
+			panel.fillHeight = () => process.stdout.rows ?? 0;
 			wrappedRoot = t.layoutRoot;
 			t.setLayoutRoot(
 				new HStack(
@@ -1297,7 +1586,7 @@ export default function (pi: ExtensionAPI) {
 			return buildFooter(tui, theme, footerData);
 		});
 		ctx.ui.setWorkingIndicator({ frames: pulseFrames(ctx.ui.theme), intervalMs: 110 });
-		ctx.ui.setTitle("MAGI");
+		ctx.ui.setTitle(windowTitle(ctx.cwd, titleDone));
 	};
 
 	pi.registerEntryRenderer("magi-verdict", (entry: any, _options: any, theme: Theme) => {
@@ -1321,15 +1610,54 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	let metricsTimer: ReturnType<typeof setInterval> | undefined;
+	let unsubscribeInput: (() => void) | undefined;
+	let lastPoll = 0;
+	let titleTimer: ReturnType<typeof setInterval> | undefined;
+	/** Tools currently executing, by call id: the golem shows one of them, and leaves when none is left. */
+	const runningTools = new Map<string, { name: string; target: string }>();
 
 	pi.on("session_start", async (_event, ctx) => {
 		liveCtx = ctx;
+		recountSession(ctx);
+		state.hasSmartCompact = pi.getCommands().some((c) => c.name.replace(/^\//, "") === "smart-compact");
+		const cfg = loadMagiConfig();
+		ui.compact = cfg.ui?.compact ?? false;
+		ui.kwhPrice = cfg.ui?.kwhPrice;
+		ui.currency = cfg.ui?.currency === "USD" ? "USD" : "EUR";
 		if (ctx.mode !== "tui") return;
 		applyChrome(ctx);
-		// load the model into VRAM now (animated in the panel and footer) and keep GPU stats fresh
+		// load the model into VRAM now (animated in the panel and footer)
 		void preloadModel(ctx);
-		metricsTimer ??= setInterval(() => void refreshSwapMetrics(), 3000);
+		// GPU stats every 3s while something happens, every 30s when idle
+		metricsTimer ??= setInterval(() => {
+			const now = Date.now();
+			if (!animating(now) && now - lastPoll < IDLE_POLL_MS) return;
+			lastPoll = now;
+			void refreshSwapMetrics()
+				.then(refreshSwapRunning)
+				.then(repaint);
+		}, BUSY_POLL_MS);
 		metricsTimer.unref?.();
+		// back at the keyboard: clear the ✓ from the title, wake a model llama-swap unloaded
+		unsubscribeInput ??= ctx.ui.onTerminalInput(() => {
+			if (titleDone) {
+				titleDone = false;
+				ctx.ui.setTitle(windowTitle(ctx.cwd));
+			}
+			if (swap.state === "asleep" && liveCtx) void preloadModel(liveCtx);
+			return undefined;
+		});
+		// ponytail: re-applies the title every 2s because pi overwrites it without telling extensions
+		titleTimer ??= setInterval(() => {
+			if (chrome) ctx.ui.setTitle(windowTitle(ctx.cwd, titleDone));
+		}, TITLE_REFRESH_MS);
+		titleTimer.unref?.();
+	});
+
+	pi.on("session_tree", async (_event, ctx) => {
+		liveCtx = ctx;
+		recountSession(ctx);
+		repaint();
 	});
 
 	pi.on("model_select", async (event, ctx) => {
@@ -1340,6 +1668,10 @@ export default function (pi: ExtensionAPI) {
 	pi.on("session_shutdown", async () => {
 		clearInterval(metricsTimer);
 		metricsTimer = undefined;
+		unsubscribeInput?.();
+		unsubscribeInput = undefined;
+		clearInterval(titleTimer);
+		titleTimer = undefined;
 		hidePanel();
 	});
 
@@ -1369,7 +1701,15 @@ export default function (pi: ExtensionAPI) {
 		const t = e?.type;
 		if (t === "thinking_start" || t === "thinking_delta") setPhase("thinking");
 		else if (t === "text_start" || t === "text_delta") setPhase("responding");
-		else if (t === "toolcall_start" || t === "toolcall_delta") setPhase("tool");
+		else if (t === "toolcall_start" || t === "toolcall_delta") {
+			// the model is writing a tool call: the golem shows which tool it prepares, not the previous one
+			setPhase("tool");
+			const call = e.partial?.content?.[e.contentIndex];
+			if (call?.type === "toolCall") {
+				state.toolName = call.name ?? "";
+				state.toolTarget = toolTarget(call.arguments);
+			}
+		}
 		if (typeof e?.delta === "string" && e.delta) {
 			if (!perf.first) perf.first = Date.now();
 			perf.chars += e.delta.length;
@@ -1377,20 +1717,23 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.on("message_end", async (event) => {
-		if (event.message.role !== "assistant" || !perf.start) return;
+		if (event.message.role !== "assistant") return;
 		const m = event.message as AssistantMessage;
-		const end = Date.now();
-		perf.lastMs = end - perf.start;
-		if (perf.first) {
-			perf.ttft = perf.first - perf.start;
-			const genS = (end - perf.first) / 1000;
-			const out = m.usage?.output || perf.chars / 4;
-			if (genS > 0.05 && out) {
-				perf.tps = out / genS;
-				perf.peakTps = Math.max(perf.peakTps, perf.tps);
+		addUsage(m);
+		if (perf.start) {
+			const end = Date.now();
+			perf.lastMs = end - perf.start;
+			if (perf.first) {
+				perf.ttft = perf.first - perf.start;
+				const genS = (end - perf.first) / 1000;
+				const out = m.usage?.output || perf.chars / 4;
+				if (genS > 0.05 && out) {
+					perf.tps = out / genS;
+					perf.peakTps = Math.max(perf.peakTps, perf.tps);
+				}
 			}
+			perf.start = 0;
 		}
-		perf.start = 0;
 		repaint();
 		// llama-swap records the request once it completes
 		setTimeout(() => void refreshSwapActivity().then(repaint), 300);
@@ -1398,20 +1741,37 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("tool_execution_start", async (event, ctx) => {
 		liveCtx = ctx;
+		const tool = { name: event.toolName ?? "", target: toolTarget(event.args) };
+		runningTools.set(event.toolCallId, tool);
 		setPhase("tool");
-		state.toolName = event.toolName ?? "";
+		state.toolName = tool.name;
+		state.toolTarget = tool.target;
 		repaint();
 	});
 
 	// CHESED (mercy) counts what worked, GEBURAH (severity) what failed; a failure erases the golem's aleph.
 	pi.on("tool_execution_end", async (event) => {
+		const tool = runningTools.get(event.toolCallId);
+		runningTools.delete(event.toolCallId);
 		if (event.isError) {
 			state.toolFail++;
 			state.lastFailAt = Date.now();
-			state.lastFailTool = event.toolName ?? "tool";
+			state.lastFailTool = event.toolName ?? tool?.name ?? "tool";
+			state.lastFailTarget = tool?.target ?? "";
 		} else {
 			state.toolOk++;
 		}
+		const next = [...runningTools.values()][0];
+		if (next) {
+			// parallel tools: the golem moves on to one still running
+			state.toolName = next.name;
+			state.toolTarget = next.target;
+		} else {
+			// all tools done: the model now reads their results and thinks about the next step
+			setPhase("thinking");
+			state.toolName = "";
+			state.toolTarget = "";
+		}
 		repaint();
 	});
 
@@ -1420,19 +1780,26 @@ export default function (pi: ExtensionAPI) {
 		if (state.runStart) state.lastRunMs = Date.now() - state.runStart;
 		state.runStart = 0;
 		setPhase("idle");
+		runningTools.clear();
 		state.toolName = "";
-		if (ctx.mode === "tui" && chrome) ctx.ui.setWorkingMessage();
+		state.toolTarget = "";
+		if (ctx.mode === "tui" && chrome) {
+			ctx.ui.setWorkingMessage();
+			// a long run just finished: mark the window title until you touch the keyboard
+			if (state.lastRunMs > DONE_TITLE_AFTER_MS) {
+				titleDone = true;
+				ctx.ui.setTitle(windowTitle(ctx.cwd, true));
+			}
+		}
 		repaint();
 	});
 
 	// The seven seals: compaction breaks them, and the context is reborn.
 	// When pi-smart-compact is installed it owns the compaction; this theme only watches and names it.
-	const hasSmartCompact = () => pi.getCommands().some((c) => c.name.replace(/^\//, "") === "smart-compact");
-
 	pi.on("session_before_compact", async () => {
 		state.compacting = true;
 		state.compactSince = Date.now();
-		state.compactBy = hasSmartCompact() ? "smart-compact" : "pi native";
+		state.compactBy = state.hasSmartCompact ? "smart-compact" : "pi native";
 		repaint();
 	});
 
@@ -1440,7 +1807,7 @@ export default function (pi: ExtensionAPI) {
 		state.compacting = false;
 		state.rebornAt = Date.now();
 		// fromExtension: an extension supplied the summary; otherwise pi's own compactor did (e.g. smart-compact fell back)
-		state.compactBy = event.fromExtension ? (hasSmartCompact() ? "smart-compact" : "extension") : "pi native";
+		state.compactBy = event.fromExtension ? (state.hasSmartCompact ? "smart-compact" : "extension") : "pi native";
 		repaint();
 	});
 
@@ -1449,54 +1816,82 @@ export default function (pi: ExtensionAPI) {
 		repaint();
 	});
 
+	/** Runs the council on a question with some context, shows the deliberation, stores the verdict. */
+	async function runCouncil(ctx: ExtensionContext, question: string, context: string, contextLabel?: string): Promise<void> {
+		const cfg = loadMagiConfig();
+		const project = (ctx.cwd ?? "").split("/").filter(Boolean).pop() ?? "";
+		const prompt = councilPrompt(project, context, question, contextLabel);
+
+		const controller = new AbortController();
+		const opinions: (MagiOpinion | undefined)[] = MAGI.map(() => undefined);
+		let finished = false;
+		const all = Promise.all(
+			MAGI.map((_, i) =>
+				askMagi(ctx, i, prompt, cfg, controller.signal).then((o) => {
+					opinions[i] = o;
+					return o;
+				}),
+			),
+		).finally(() => {
+			finished = true;
+		});
+
+		if (ctx.mode === "tui") {
+			const cancelled = await ctx.ui.custom<boolean>((tui, theme, _keys, done) =>
+				buildDeliberationView(tui, theme, question, opinions, () => finished, done),
+			);
+			if (cancelled) {
+				controller.abort();
+				ctx.ui.notify("MAGI deliberation aborted", "warning");
+				return;
+			}
+		}
+
+		const final = await all;
+		const { verdict, tally } = tallyVerdict(final.map((o) => o.vote));
+		pi.appendEntry("magi-verdict", { question, opinions: final, verdict, tally } satisfies Deliberation);
+		state.lastCouncil = { verdict, tally, question };
+		repaint();
+	}
+
 	pi.registerCommand("magi", {
-		description: "Ask the three MAGI (pragmatist, guardian, visionary); /magi config assigns a model to each",
+		description: "Ask the three MAGI (pragmatist, guardian, visionary); /magi review [focus] judges the git diff; /magi config assigns models",
 		handler: async (args, ctx) => {
 			const arg = args.trim();
 			if (arg === "config") return configureMagi(ctx);
 
-			const question = arg || (await ctx.ui.input("Question for the MAGI:", "should we …?"))?.trim() || "";
-			if (!question) return;
-
-			const cfg = loadMagiConfig();
-			const project = (ctx.cwd ?? "").split("/").filter(Boolean).pop() ?? "";
-			const prompt =
-				`Project: ${project}\n\nRecent conversation (context only, may be empty):\n<conversation>\n${conversationExcerpt(ctx)}\n</conversation>\n\n` +
-				`Question for the MAGI:\n${question}`;
-
-			const controller = new AbortController();
-			const opinions: (MagiOpinion | undefined)[] = MAGI.map(() => undefined);
-			let finished = false;
-			const all = Promise.all(
-				MAGI.map((_, i) =>
-					askMagi(ctx, i, prompt, cfg, controller.signal).then((o) => {
-						opinions[i] = o;
-						return o;
-					}),
-				),
-			).finally(() => {
-				finished = true;
-			});
-
-			if (ctx.mode === "tui") {
-				const cancelled = await ctx.ui.custom<boolean>((tui, theme, _keys, done) =>
-					buildDeliberationView(tui, theme, question, opinions, () => finished, done),
-				);
-				if (cancelled) {
-					controller.abort();
-					ctx.ui.notify("MAGI deliberation aborted", "warning");
+			if (arg === "review" || arg.startsWith("review ")) {
+				const focus = arg.slice("review".length).trim();
+				let changes: { diff: string; untracked: string[] };
+				try {
+					changes = await pendingChanges(ctx.cwd);
+				} catch {
+					ctx.ui.notify("MAGI review needs a git repository", "error");
+					return;
+				}
+				if (!changes.diff.trim() && !changes.untracked.length) {
+					ctx.ui.notify("Nothing to review: no changes against HEAD", "info");
 					return;
 				}
+				const diff =
+					changes.diff.length > REVIEW_MAX_CHARS
+						? changes.diff.slice(0, REVIEW_MAX_CHARS) + `\n… diff truncated (${changes.diff.length} chars in total)`
+						: changes.diff;
+				const untracked = changes.untracked.length ? `\n\nUntracked files (content not shown):\n${changes.untracked.join("\n")}` : "";
+				const question = focus
+					? `Review these pending changes before committing, focusing on: ${focus}`
+					: "Review these pending changes before committing: are they ready to commit, and what must change first?";
+				return runCouncil(ctx, question, "```diff\n" + diff + "\n```" + untracked, "Pending changes (git diff HEAD)");
 			}
 
-			const final = await all;
-			const { verdict, tally } = tallyVerdict(final.map((o) => o.vote));
-			pi.appendEntry("magi-verdict", { question, opinions: final, verdict, tally } satisfies Deliberation);
+			const question = arg || (await ctx.ui.input("Question for the MAGI:", "should we …?"))?.trim() || "";
+			if (!question) return;
+			return runCouncil(ctx, question, conversationExcerpt(ctx));
 		},
 	});
 
 	pi.registerCommand("magi-ui", {
-		description: "MAGI chrome: enable the theme, or manage chrome and side panel (on|off|panel)",
+		description: "MAGI chrome: enable the theme, or manage it (on|off|panel|compact|status|config)",
 		handler: async (args, ctx) => {
 			liveCtx = ctx;
 			const arg = args.trim().toLowerCase();
@@ -1508,6 +1903,59 @@ export default function (pi: ExtensionAPI) {
 				ctx.ui.notify(`Side panel ${panelEnabled ? "enabled" : "disabled"}`, "info");
 				return;
 			}
+			if (arg === "compact") {
+				ui.compact = !ui.compact;
+				const cfg = loadMagiConfig();
+				saveMagiConfig({ ...cfg, ui: { ...cfg.ui, compact: ui.compact } });
+				repaint();
+				ctx.ui.notify(`Side panel ${ui.compact ? "compact" : "detailed"}`, "info");
+				return;
+			}
+			if (arg === "config") {
+				const currency = await ctx.ui.select(`Currency for COST (current: ${ui.currency})`, ["EUR", "USD"]);
+				if (!currency) return;
+				const current = ui.kwhPrice !== undefined ? ` (current: ${ui.kwhPrice})` : "";
+				const raw = (await ctx.ui.input(`Electricity price per kWh in ${currency}${current}:`, "0.30"))?.trim();
+				if (raw === undefined) return;
+				const price = raw === "" && ui.kwhPrice !== undefined ? ui.kwhPrice : Number(raw.replace(",", "."));
+				if (raw === "" && ui.kwhPrice === undefined) {
+					ctx.ui.notify("No price entered: COST unchanged", "warning");
+					return;
+				}
+				if (!Number.isFinite(price) || price < 0) {
+					ctx.ui.notify(`Invalid price: "${raw}"`, "error");
+					return;
+				}
+				ui.currency = currency === "USD" ? "USD" : "EUR";
+				ui.kwhPrice = price;
+				const cfg = loadMagiConfig();
+				saveMagiConfig({ ...cfg, ui: { ...cfg.ui, currency: ui.currency, kwhPrice: price } });
+				repaint();
+				ctx.ui.notify(`COST: ${fmtMoney(price)} per kWh`, "info");
+				return;
+			}
+			if (arg === "status") {
+				if (!swap.base) {
+					ctx.ui.notify("/magi-ui status needs a llama-swap session model", "warning");
+					return;
+				}
+				let report: { data?: ActivityRow[]; total?: number };
+				try {
+					report = (await (await swapGet(`/api/metrics/activity?limit=${ACTIVITY_REPORT_ROWS}`, 15_000)).json()) as typeof report;
+				} catch (err) {
+					ctx.ui.notify(`llama-swap status failed: ${err instanceof Error ? err.message : String(err)}`, "error");
+					return;
+				}
+				const rows = report.data ?? [];
+				if (!rows.length) {
+					ctx.ui.notify("llama-swap has no recorded requests yet", "info");
+					return;
+				}
+				await ctx.ui.custom<void>((_tui, theme, _keys, done) =>
+					buildReportView(theme, activityReport(theme, rows, report.total ?? rows.length), () => done(undefined)),
+				);
+				return;
+			}
 			if (arg === "off" || arg === "on") {
 				chrome = arg === "on";
 				applyChrome(ctx);
@@ -1522,7 +1970,7 @@ export default function (pi: ExtensionAPI) {
 			}
 			chrome = true;
 			applyChrome(ctx);
-			ctx.ui.notify("MAGI online — /magi-ui panel, /magi-ui off", "info");
+			ctx.ui.notify("MAGI online — /magi-ui panel|compact|status|off", "info");
 		},
 	});
 }