pi-magi-theme 0.2.2 → 0.2.4

package/README.md

@@ -2,7 +2,7 @@
 
 A three-mind council theme + extension for [pi](https://pi.dev): a MAGI SYSTEM header, the three MAGI as their control screen in a fixed side panel, live llama-swap telemetry, and `/magi`, a council of three models that votes on your engineering questions and reviews your pending changes.
 
-Fan-art theme inspired by Neon Genesis Evangelion: the MAGI and their screen belong to their creators, all rights reserved to khara, Inc. This project is not affiliated with them. The rest of the symbolism (the Tree of Life, the golem, the seven seals) is public domain.
+Fan-art theme inspired by Neon Genesis Evangelion: the MAGI and their screen belong to their creators, all rights reserved to khara, Inc. This project is not affiliated with them. The rest of the symbolism (the Tree of Life, the sephirot, the seven seals) is public domain.
 
 ![pi with the MAGI theme: MAGI SYSTEM header, MECHA SELECT model picker, side panel with the MAGI screen and llama-swap telemetry](https://raw.githubusercontent.com/b-iurea/pi-magi-theme/main/docs/screenshot.png)
 
@@ -59,9 +59,9 @@ Every symbol stands for something real the agent is doing.
 | red spreading through BALTHASAR, MELCHIOR, CASPAR | an angel hacking the MAGI | the model is **being loaded into VRAM**, at the pace of its last load; CASPAR's last corner blinks once everything else has fallen | panel |
 | blue taking the MAGI back from that corner | the attack repelled | the model is **loaded** | panel |
 | MECHA-I · II · III · LEGION | units waiting for a pilot | the **llama-swap models**: dormant, waking while loading, eyes lit in VRAM | MECHA SELECT |
-| the golem, EMET ("truth") | a clay servant that acts | a **tool is running**, with the file or command it works on | panel + footer |
-| the golem, MET ("death") | the aleph is erased | a **tool failed** | panel + footer |
-| SYNC | the golem's obedience | **tool success rate** | panel + footer |
+| the session's unit, in sync | the unit acts under its pilot | a **tool is running**, with the file or command it works on | panel + footer |
+| the unit going berserk | the leash breaks: red eyes, jaw wide open | a **tool failed** | panel + footer |
+| SYNC | the unit's sync ratio | **tool success rate** | panel + footer |
 | CHESED ✓ / GEBURAH ✗ | mercy / severity | **successful / failed tools** | panel + footer |
 | the seven seals | the end of an age | **context window usage**, one seal per seventh | panel |
 | the sixth seal blinking | the last warning | context **close to compaction**: compact now instead of mid-task | panel + footer |
@@ -72,6 +72,8 @@ The window title is `π - Magi - <working directory>`. After a run longer than 3
 
 In fullscreen mode the side panel always reaches the bottom of the terminal.
 
+In a terminal too narrow for it, the footer scrolls as one line instead of being cut off.
+
 ## The seventh seal: smart compaction
 
 The theme does not compact anything itself: it shows who does. For better compaction install [pi-smart-compact](https://www.npmjs.com/package/pi-smart-compact):
@@ -104,15 +106,27 @@ Each nature is a lens, not a specialty, so the council answers any question, not
 {
   "MELCHIOR": { "model": "llama-swap/Qwen3.8 27B Q4_K_M - Thinking", "thinking": "low" },
   "ui": { "compact": false, "kwhPrice": 0.30, "currency": "EUR" },
-  "loads": { "qwen3.8-27b": 41200 }
+  "loads": { "qwen3.8-27b": 41200 },
+  "totalWh": 1843.2
 }
 ```
 
 - per MAGI: `model` (unset = current session model) and optional `thinking` level;
 - `ui.compact`: start with the compact side panel;
-- `ui.kwhPrice` and `ui.currency` (`EUR` or `USD`): the COST row multiplies the GPU energy used in the session by this price;
+- `ui.kwhPrice` and `ui.currency` (`EUR` or `USD`): the COST row multiplies the GPU energy by this price, showing the running total of every session with the current one in brackets;
+- `totalWh`: written by the theme, GPU energy summed over every session (delete the key to reset the COST total);
 - `loads`: written by the theme, how long each llama-swap model took to load last time (paces the angel attack; 60s when unknown).
 
+## Release
+
+`.github/workflows/publish.yml` publishes to npm when a `v*` tag is pushed, and refuses if the tag does not match `package.json`:
+
+```
+npm version patch && git push --follow-tags
+```
+
+No token: npmjs is configured to trust this repository's `publish.yml` (npm trusted publishing, OIDC), which also signs the provenance.
+
 ## llama-swap
 
 When the session model uses the `llama-swap` provider, the side panel:

package/extensions/magi/index.ts

@@ -7,7 +7,7 @@
  *    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) 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;
+ *  - the session's MECHA unit acts while tools run, showing the file or command it works on, and goes berserk when one fails;
  *    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; the sixth warns before compaction, the seventh opens when it runs
@@ -32,7 +32,7 @@ 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";
 import type { Component, OverlayHandle, TUI } from "@earendil-works/pi-tui";
-import { HStack, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { HStack, matchesKey, sliceByColumn, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 
 /* ────────────────────────────────────────────────────────────── art ── */
 
@@ -97,42 +97,10 @@ function renderPath(th: Theme, lights: NodeLight[]): string {
 	return out;
 }
 
-/** The golem, 20×8 cells: at rest, striking (arms raised), and fallen (EMET → MET). */
-const GOLEM_REST = [
-	"      ▄██████▄      ",
-	"      █ EMET █      ",
-	"      ▀██████▀      ",
-	"   ▄████████████▄   ",
-	"   ██ ████████ ██   ",
-	"   ▀▀ ████████ ▀▀   ",
-	"      ███  ███      ",
-	"     ▀▀▀▀  ▀▀▀▀     ",
-];
-const GOLEM_STRIKE = [
-	" ▄▄   ▄██████▄   ▄▄ ",
-	" ██   █ EMET █   ██ ",
-	" ██   ▀██████▀   ██ ",
-	" ▀████████████████▀ ",
-	"      ████████      ",
-	"      ████████      ",
-	"      ███  ███      ",
-	"     ▀▀▀▀  ▀▀▀▀     ",
-];
-const GOLEM_FALLEN = [
-	"      ▄██████▄      ",
-	"      █  MET █      ",
-	"      ▀██████▀      ",
-	"   ▄████████████▄   ",
-	"   ██ ██░███░█ ██   ",
-	"   ▀▀ █░████░█ ▀▀   ",
-	"      ███  ███      ",
-	"     ▀▀▀▀  ▀▀▀▀     ",
-];
-
 /* ── MECHA units: the heads of the model picker, one unit per model llama-swap runs ── */
 
 type MechaUnit = "I" | "II" | "III" | "LEGION";
-type MechaState = "dormant" | "waking" | "active";
+type MechaState = "dormant" | "waking" | "active" | "berserk";
 type Rgb = readonly [number, number, number];
 
 /**
@@ -243,17 +211,31 @@ const MECHA: Record<MechaUnit, { name: string; armor: Rgb; accent: Rgb; eyes: Rg
 	},
 };
 
+/** Every head is drawn on the same 13×7 grid. */
+const MECHA_W = 13;
+
 const rgb = ([r, g, b]: Rgb, s: string) => `\x1b[38;2;${r};${g};${b}m${s}\x1b[39m`;
 const shade = (c: Rgb, k: number): Rgb => [Math.round(c[0] * k), Math.round(c[1] * k), Math.round(c[2] * k)];
 
-/** One MECHA head: dormant (dark, eyes off), waking (eyes flicker, the jaw lock breaks), active (armor lit, eyes pulse). */
+/** The berserk eyes: the unit off its leash sees in red, whatever colour its own eyes are. */
+const BERSERK_EYES: Rgb = [255, 40, 40];
+
+/**
+ * One MECHA head: dormant (dark, eyes off), waking (eyes flicker, the jaw lock breaks),
+ * active (armor lit, eyes pulse), berserk (jaw wide open, red eyes, a tool just failed).
+ */
 function renderMechaHead(unit: MechaUnit, state: MechaState, frame: number): string[] {
 	const u = MECHA[unit];
-	const jawOpen = state === "waking" && frame % 8 < 4;
-	const eyesOn = state === "active" || (state === "waking" && flicker(frame, 7));
+	const jawOpen = state === "berserk" || (state === "waking" && frame % 8 < 4);
+	const eyesOn = state === "active" || state === "berserk" || (state === "waking" && flicker(frame, 7));
 	const armor = state === "dormant" ? shade(u.armor, 0.3) : state === "waking" ? shade(u.armor, 0.7) : u.armor;
 	const accent = state === "dormant" ? shade(u.accent, 0.3) : u.accent;
-	const eyes = eyesOn ? shade(u.eyes, state === "active" ? 0.75 + 0.25 * Math.sin(frame / 3) : 1) : shade(u.eyes, 0.18);
+	const eyes =
+		state === "berserk"
+			? shade(BERSERK_EYES, 0.7 + 0.3 * Math.sin(frame / 1.5)) // the roar throbs faster than the sync pulse
+			: eyesOn
+				? shade(u.eyes, state === "active" ? 0.75 + 0.25 * Math.sin(frame / 3) : 1)
+				: shade(u.eyes, 0.18);
 	return u.art.map((row, r) => {
 		const jaw = jawOpen ? u.jaw.rows[r - u.jaw.at] : undefined;
 		const art = jaw ?? row;
@@ -323,6 +305,7 @@ const state = {
 	turns: 0,
 	toolOk: 0, // CHESED
 	toolFail: 0, // GEBURAH
+	unit: "I" as MechaUnit, // the session model's own unit: it is the one that acts while a tool runs
 	lastFailAt: 0,
 	lastFailTool: "",
 	lastFailTarget: "",
@@ -357,12 +340,17 @@ function setPhase(p: Phase): void {
 }
 
 const ANIM_STEP_MS = 220;
+/** How long one Sephirah stays lit in the footer: its name and meaning are text, they need time to be read. */
+const SEPHIRAH_STEP_MS = 1400;
 const FAIL_FLASH_MS = 2500;
 const REBIRTH_MS = 6000;
 const DONE_TITLE_AFTER_MS = 30_000;
 const SIXTH_SEAL_PERCENT = (6 / 7) * 100;
+/** Footer marquee: one cell every FOOTER_SCROLL_MS, with this gap between the loop's end and its start. */
+const FOOTER_SCROLL_MS = 260;
+const FOOTER_SCROLL_GAP = "   ·   ";
 
-/** Golem obedience: share of tool calls that succeeded (null before the first tool). */
+/** Sync ratio: share of tool calls that succeeded (null before the first tool). */
 function syncPercent(): number | null {
 	const done = state.toolOk + state.toolFail;
 	return done ? (state.toolOk / done) * 100 : null;
@@ -727,6 +715,8 @@ const swap = {
 	cacheTokens: 0,
 	inputTokens: 0,
 	energyWh: 0, // GPU energy since the session started
+	diskWh: 0, // GPU energy of all sessions, as last read from/written to magi.json
+	savedWh: 0, // the part of energyWh already added to diskWh
 	lastSampleAt: 0,
 	lastWatts: 0,
 };
@@ -777,6 +767,34 @@ function sampleEnergy(now = Date.now()): void {
 	}
 	swap.lastSampleAt = now;
 	swap.lastWatts = watts;
+	persistEnergy();
+}
+
+/** GPU energy of every session so far: what is on disk plus this session's not-yet-written part. */
+function totalWh(): number {
+	return swap.diskWh + swap.energyWh - swap.savedWh;
+}
+
+const ENERGY_SAVE_MS = 60_000;
+let lastPersistAt = 0;
+
+/**
+ * Adds this session's new energy to the running total in magi.json, so the COST row survives restarts.
+ * ponytail: writes at most once a minute, and adds a delta so parallel sessions do not overwrite each other.
+ */
+function persistEnergy(force = false): void {
+	const delta = swap.energyWh - swap.savedWh;
+	if (delta <= 0 || (!force && Date.now() - lastPersistAt < ENERGY_SAVE_MS)) return;
+	lastPersistAt = Date.now();
+	const cfg = loadMagiConfig();
+	cfg.totalWh = (cfg.totalWh ?? 0) + delta;
+	try {
+		saveMagiConfig(cfg);
+	} catch {
+		return; // disk unavailable: keep the delta and retry on the next sample
+	}
+	swap.savedWh = swap.energyWh;
+	swap.diskWh = cfg.totalWh;
 }
 
 async function refreshSwapMetrics(): Promise<void> {
@@ -1147,23 +1165,18 @@ class MagiPanel implements Component {
 		return this.frameLine(" " + l + this.theme.fg(tone, value), inner);
 	}
 
-	/* ── the golem: tools ── */
+	/* ── the unit at work: tools ── */
 
-	private golemArt(inner: number): string[] {
-		const th = this.theme;
-		const fallen = Date.now() - state.lastFailAt < FAIL_FLASH_MS;
-		const art = fallen ? GOLEM_FALLEN : this.frame % 4 < 2 ? GOLEM_STRIKE : GOLEM_REST;
-		const tone: ThemeColor = fallen ? "error" : "accent";
-		const left = " ".repeat(Math.max(0, Math.floor((inner - 20) / 2)));
-		return art.map((line) => {
-			const word = fallen ? "MET" : "EMET";
-			const at = line.indexOf(word);
-			if (at < 0) return left + th.fg(tone, line);
-			return left + th.fg(tone, line.slice(0, at)) + th.bold(th.fg(fallen ? "error" : "warning", word)) + th.fg(tone, line.slice(at + word.length));
-		});
+	/** The session's own unit while a tool runs; berserk (and shaking) for as long as the failure flashes. */
+	private mechaArt(inner: number): string[] {
+		const berserk = Date.now() - state.lastFailAt < FAIL_FLASH_MS;
+		const art = renderMechaHead(state.unit, berserk ? "berserk" : "active", this.frame);
+		const shake = berserk ? (this.frame % 2 ? 1 : -1) : 0;
+		const left = " ".repeat(Math.max(0, Math.floor((inner - MECHA_W) / 2) + shake));
+		return art.map((line) => left + line);
 	}
 
-	/* ── top of the panel: the MAGI (flickering while working) or the golem (tools) ── */
+	/* ── top of the panel: the MAGI (flickering while working) or the unit (tools) ── */
 
 	private councilSection(inner: number): string[] {
 		const th = this.theme;
@@ -1180,9 +1193,10 @@ class MagiPanel implements Component {
 		let status: string;
 
 		if (state.phase === "tool" || (idle && fallen)) {
-			title = fallen ? `GOLEM FELL · MET · ${state.lastFailTool}` : `GOLEM · ${state.toolName || "tool"} · ${secs(state.phaseSince)}`;
+			const name = MECHA[state.unit].name;
+			title = fallen ? `${name} BERSERK · ${state.lastFailTool}` : `${name} · ${state.toolName || "tool"} · ${secs(state.phaseSince)}`;
 			titleTone = fallen ? "error" : "warning";
-			body = this.golemArt(inner);
+			body = this.mechaArt(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 {
@@ -1275,7 +1289,7 @@ class MagiPanel implements Component {
 			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 ✗)
+		// SYNC: the unit's sync ratio = tool success rate (CHESED ✓ / GEBURAH ✗)
 		const sync = syncPercent();
 		out.push(
 			this.frameLine(
@@ -1332,11 +1346,14 @@ class MagiPanel implements Component {
 		return out;
 	}
 
-	/** COST: GPU energy used in the session × price per kWh set with /magi-ui config. */
+	/** COST: GPU energy × price per kWh set with /magi-ui config — all sessions, with this one in brackets. */
 	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");
+		const th = this.theme;
+		const price = (wh: number) => fmtMoney((wh / 1000) * ui.kwhPrice!);
+		const label = th.fg("dim", "COST".padEnd(9));
+		return this.frameLine(" " + label + th.fg("warning", price(totalWh())) + th.fg("dim", ` (ses ${price(swap.energyWh)})`), inner);
 	}
 
 	private swapRows(inner: number, compact: boolean): string[] {
@@ -1378,7 +1395,7 @@ class MagiPanel implements Component {
 			);
 		}
 		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"));
+		if (swap.gpus.length) out.push(this.field("ENERGY", `${(totalWh() / 1000).toFixed(3)} kWh`, inner, "muted"));
 		out.push(this.costRow(inner));
 		return out;
 	}
@@ -1487,6 +1504,7 @@ interface MagiUnitConfig {
 type MagiConfig = Partial<Record<MagiUnit, MagiUnitConfig>> & {
 	ui?: { compact?: boolean; kwhPrice?: number; currency?: Currency };
 	loads?: Record<string, number>; // real model id → ms its last load took
+	totalWh?: number; // GPU energy summed over every session, for the COST row
 };
 
 const MAGI_CONFIG_PATH = join(homedir(), ".pi", "agent", "magi.json");
@@ -1818,7 +1836,7 @@ 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 (with its file or command) / tool failed
+ *  - unit in sync / berserk               → 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
@@ -1828,6 +1846,7 @@ async function configureMagi(ctx: ExtensionContext): Promise<void> {
 function footerLeft(th: Theme, now = Date.now()): string {
 	const dim = (s: string) => th.fg("dim", s);
 	const step = Math.floor(now / ANIM_STEP_MS);
+	const slowStep = Math.floor(now / SEPHIRAH_STEP_MS);
 	const lights = (fn: (i: number) => NodeLight) => SEPHIROT.map((_, i) => fn(i));
 
 	if (state.compacting) {
@@ -1856,13 +1875,22 @@ function footerLeft(th: Theme, now = Date.now()): string {
 		const syncText = sync === null ? "" : dim(" · sync ") + th.fg(syncTone(sync), `${sync.toFixed(0)}%`);
 		if (now - state.lastFailAt < FAIL_FLASH_MS) {
 			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;
+			return (
+				th.fg("error", `✗ ${MECHA[state.unit].name} · `) +
+				th.bold(th.fg("error", "BERSERK")) +
+				dim(" · ") +
+				th.fg("error", `${state.lastFailTool} failed`) +
+				target +
+				dim(" ·") +
+				tally +
+				syncText
+			);
 		}
-		const hammer = ["▚", "▞"][step % 2]!;
+		const roar = ["▚", "▞"][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")) +
+			th.fg("accent", `${roar} ${MECHA[state.unit].name} · `) +
+			th.bold(th.fg("warning", "SYNC")) +
 			dim(" · ") +
 			th.fg("text", state.toolName || "tool") +
 			target +
@@ -1872,7 +1900,7 @@ function footerLeft(th: Theme, now = Date.now()): string {
 		);
 	}
 	if (state.phase === "thinking") {
-		const cur = Math.floor(step / 2) % 3; // Keter, Chokmah, Binah
+		const cur = slowStep % 3; // Keter, Chokmah, Binah
 		const s = SEPHIROT[cur]!;
 		return (
 			th.fg("accent", "◆ ") +
@@ -1882,7 +1910,7 @@ function footerLeft(th: Theme, now = Date.now()): string {
 		);
 	}
 	if (state.phase === "responding") {
-		const cur = 5 + (step % 5); // Tiferet → Malkuth
+		const cur = 5 + (slowStep % 5); // Tiferet → Malkuth
 		const s = SEPHIROT[cur]!;
 		const tps = liveTps();
 		return (
@@ -1920,9 +1948,21 @@ function footerLeft(th: Theme, now = Date.now()): string {
 
 /** Footer: the animation on the left, other extensions' statuses on the right. */
 function buildFooter(tui: TUI, theme: Theme, footerData: any) {
+	let scrolling = false;
+	let scrollOff = 0;
+	let scrollPeriod = 1;
+	let scrollLine = "";
 	const timer = setInterval(() => {
 		if (animating()) tui.requestRender();
 	}, ANIM_STEP_MS);
+	// The marquee keeps its own cadence: one cell per tick, never derived from the clock, so it
+	// does not stutter when the line is re-rendered at some other pace (animation, streamed tokens)
+	// nor jump when the left side changes length (sephirah name, tok/s) and with it the loop period.
+	const scrollTimer = setInterval(() => {
+		if (!scrolling) return;
+		scrollOff = (scrollOff + 1) % scrollPeriod;
+		tui.requestRender();
+	}, FOOTER_SCROLL_MS);
 
 	const unsub = footerData?.onBranchChange?.(() => tui.requestRender());
 
@@ -1931,14 +1971,30 @@ function buildFooter(tui: TUI, theme: Theme, footerData: any) {
 			const dim = (s: string) => theme.fg("dim", s);
 			const statuses = footerData?.getExtensionStatuses?.();
 			const right = statuses ? [...statuses.values()].filter(Boolean).join(dim(" │ ")) : "";
-			const room = Math.max(12, width - visibleWidth(right) - 2);
-			const l = truncateToWidth(footerLeft(theme), room);
-			const gap = Math.max(1, width - visibleWidth(l) - visibleWidth(right));
-			return [truncateToWidth(l + " ".repeat(gap) + right, width)];
+			const left = footerLeft(theme);
+			const gap = width - visibleWidth(left) - visibleWidth(right);
+			scrolling = gap < 1;
+			if (!scrolling) {
+				scrollLine = "";
+				scrollOff = 0;
+				return [left + " ".repeat(gap) + right];
+			}
+			// Too narrow to fit: scroll the whole line instead of cutting it off. The line is frozen
+			// while it scrolls — live text changes width (seconds, tok/s, sephirah names) and every
+			// change would shift it under the window. A fresh line is taken when it has the same
+			// width, so nothing moves, otherwise at the end of the loop.
+			const line = left + dim(FOOTER_SCROLL_GAP) + right + dim(FOOTER_SCROLL_GAP);
+			const period = Math.max(1, visibleWidth(line));
+			if (!scrollLine || scrollOff === 0 || period === scrollPeriod) {
+				scrollLine = line;
+				scrollPeriod = period;
+			}
+			return [sliceByColumn(scrollLine + scrollLine, scrollOff % scrollPeriod, width, true)];
 		},
 		invalidate() {},
 		dispose() {
 			clearInterval(timer);
+			clearInterval(scrollTimer);
 			unsub?.();
 		},
 	};
@@ -2073,7 +2129,7 @@ export default function (pi: ExtensionAPI) {
 	let lastPoll = 0;
 	let titleTimer: ReturnType<typeof setInterval> | undefined;
 	let liveTimer: ReturnType<typeof setInterval> | undefined;
-	/** Tools currently executing, by call id: the golem shows one of them, and leaves when none is left. */
+	/** Tools currently executing, by call id: the unit shows one of them, and leaves when none is left. */
 	const runningTools = new Map<string, { name: string; target: string }>();
 
 	/** The picker has the keyboard: keys pressed there must not wake the default model. */
@@ -2112,14 +2168,27 @@ export default function (pi: ExtensionAPI) {
 		}
 	};
 
+	/** Which unit acts in the panel: the one the picker gave this session's model. LEGION for anything not llama-swap. */
+	const refreshUnit = async (ctx: ExtensionContext, model: Model<any> | undefined = ctx.model) => {
+		if (!model) return;
+		try {
+			const aliases = await swapAliases();
+			state.unit = mechaUnitsOf(ctx, aliases).get(aliases.get(model.id) ?? model.id) ?? "LEGION";
+		} catch {
+			state.unit = "LEGION"; // llama-swap unreachable: no roster, so the unit is nameless
+		}
+	};
+
 	pi.on("session_start", async (event, ctx) => {
 		liveCtx = ctx;
+		void refreshUnit(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";
+		swap.diskWh = cfg.totalWh ?? 0;
 		if (ctx.mode !== "tui") return;
 		applyChrome(ctx);
 		// nothing is loaded at startup: a new session picks its MECHA unit, a resumed one shows whether its model is in VRAM
@@ -2168,10 +2237,12 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("model_select", async (event, ctx) => {
 		liveCtx = ctx;
+		void refreshUnit(ctx, event.model);
 		if (ctx.mode === "tui") void preloadModel(ctx, event.model);
 	});
 
 	pi.on("session_shutdown", async () => {
+		persistEnergy(true);
 		prewarm.abort?.abort();
 		clearInterval(metricsTimer);
 		metricsTimer = undefined;
@@ -2212,7 +2283,7 @@ export default function (pi: ExtensionAPI) {
 		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") {
-			// the model is writing a tool call: the golem shows which tool it prepares, not the previous one
+			// the model is writing a tool call: the unit shows which tool it prepares, not the previous one
 			setPhase("tool");
 			const call = e.partial?.content?.[e.contentIndex];
 			if (call?.type === "toolCall") {
@@ -2259,7 +2330,7 @@ export default function (pi: ExtensionAPI) {
 		repaint();
 	});
 
-	// CHESED (mercy) counts what worked, GEBURAH (severity) what failed; a failure erases the golem's aleph.
+	// CHESED (mercy) counts what worked, GEBURAH (severity) what failed; a failure throws the unit berserk.
 	pi.on("tool_execution_end", async (event) => {
 		const tool = runningTools.get(event.toolCallId);
 		runningTools.delete(event.toolCallId);
@@ -2273,7 +2344,7 @@ export default function (pi: ExtensionAPI) {
 		}
 		const next = [...runningTools.values()][0];
 		if (next) {
-			// parallel tools: the golem moves on to one still running
+			// parallel tools: the unit moves on to one still running
 			state.toolName = next.name;
 			state.toolTarget = next.target;
 		} else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-magi-theme",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "MAGI SYSTEM theme + extension for pi (Evangelion fan art): MAGI control screen panel, three-model /magi council, MECHA SELECT model picker, angel-attack loading, seven-seal context gauge, llama-swap telemetry",
   "keywords": [
     "pi-package",