pi-minimal 0.2.1 → 0.2.3

package/CHANGELOG.md

@@ -10,6 +10,45 @@ Releases are cut automatically: when the `version` in `package.json` changes on
 
 ## [Unreleased]
 
+## [0.2.3] - 2026-10-24
+
+### Added
+- Versioned, session-scoped footer activity contribution API. Companion extensions
+  can publish bounded activity rows after existing hints and tracker summaries
+  without replacing the footer. No visible change without a contributor.
+- Icon-first activity rows with pi-minimal's spinner/check/failure colors,
+  plain/static modes, overflow handling, optional elapsed time/token metrics,
+  and optional task links with independent task-state badges.
+- Snapshot validation, immutable metadata, exclusive slot ownership, stale-update
+  protection, and integration documentation.
+- Independent plan-summary contribution slot with violet slanted progress segments
+  and exact accepted/total counts, rendered below the input. One blank row
+  separates nonempty footer groups; activity rows stay compact. The summary is
+  display-only and does not add task storage or infer acceptance from agent runs.
+- Release checks for matching manifest/lockfile versions and a dated changelog entry.
+
+### Fixed
+- Dispose activity subscriptions and animation timers across footer replacement
+  and shutdown; prevent delayed settle callbacks from reinstalling stale chrome.
+- Synchronize the previously stale lockfile package version with the manifest.
+
+## [0.2.2] - 2026-10-22
+
+### Added
+- Fenced code renders as a closed box (`╭─ lang ─╮` / `│ code │` / `╰───╯`)
+  instead of literal ``` lines, keeping syntax highlighting; long lines wrap
+  inside the box. pi-tui exposes no hook for this, so pi-minimal post-processes
+  the code token's rendered lines.
+
+### Changed
+- Chrome margin (status line, footer, turn rule, tool rows) follows pi's
+  `outputPad` setting so it lines up with transcript text. Set
+  `editorPaddingX` to the same value for a flush left edge.
+- Chrome modules tolerate a stale `chrome` module after `/reload`, which
+  previously could crash the renderer when the package was updated in place.
+- `mdCodeBlockBorder` in `minimal-dark` is a faint grey again (it frames the
+  box now) instead of background-coloured.
+
 ## [0.2.1] - 2026-10-22
 
 ### Added
@@ -57,7 +96,9 @@ Releases are cut automatically: when the `version` in `package.json` changes on
 - Initial release: header/footer chrome, compact tool activity rows, working
   status line, Herdr sibling status, Gauntlet widget hiding.
 
-[Unreleased]: https://github.com/raviy06/pi-minimal/compare/v0.2.1...HEAD
+[Unreleased]: https://github.com/raviy06/pi-minimal/compare/v0.2.3...HEAD
+[0.2.3]: https://github.com/raviy06/pi-minimal/compare/v0.2.2...v0.2.3
+[0.2.2]: https://github.com/raviy06/pi-minimal/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/raviy06/pi-minimal/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/raviy06/pi-minimal/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/raviy06/pi-minimal/releases/tag/v0.1.0

package/README.md

@@ -35,7 +35,9 @@ Do not load this package beside the live `grok-chrome` extension. Disable or rem
 - **Thinking gutter** – thinking paragraphs are prefixed with `┊` so they read as secondary.
 - **Status line** – one line above the editor: model · thinking level · context meter (amber at 70 %, red at 90 %) · cwd · `⎇ branch ±dirty` · Herdr siblings.
 - **Footer** – key hints appear only when the agent is idle and the editor is empty; `/compact` is suggested under context pressure.
-- **Theme** – ships `minimal-dark`: neutral tool backgrounds, visible user-message tint, dimmer thinking text, violet headings (yellow is reserved for warnings), and code-fence lines coloured like the background so fenced code reads as a padded block. Select it in `/settings` → Theme, or set `"theme": "minimal-dark"`.
+- **Code blocks** – fenced code renders as a closed box with the language as its title, keeping syntax highlighting, instead of literal ``` lines; long lines wrap inside the box.
+- **Alignment** – chrome follows pi's `outputPad` setting. Pi's editor uses the separate `editorPaddingX` setting (default `0`); set `"editorPaddingX": 1` for a flush left edge with the transcript.
+- **Theme** – ships `minimal-dark`: neutral tool backgrounds, visible user-message tint, dimmer thinking text, violet headings (yellow is reserved for warnings), and faint code-block frames. Select it in `/settings` → Theme, or set `"theme": "minimal-dark"`.
 
 ## Configuration
 
@@ -53,8 +55,30 @@ The only supported key is `hideGauntletWidgets`. It defaults to `true`.
 { "hideGauntletWidgets": true }
 ```
 
+## Optional footer activity API
+
+Companion extensions can publish session-scoped activity rows through the versioned
+in-process footer contribution API. Pi-minimal keeps ownership of the footer and
+renders activity **after** existing hints and tracker summaries. An independent
+`summary` slot supplies a violet segmented plan bar below the input. Nonempty
+groups are separated by one blank row; agent rows remain compact. The API adds no
+visible content without a contributor and changes no other extension's settings.
+
+Rows use pi-minimal's yellow running spinner, green completion check, and red
+failure glyph. Plain-text and static modes are supported. See
+[Footer activity contributions](doc/footer-contributions.md) for the protocol,
+validation limits, lifecycle, and integration example.
+
+This is a display integration seam, not a subagent runtime or task tracker.
+
 ## Releasing
 
+Every new extension PR must include a version bump before it is opened, so merging
+it can trigger publication and users can update. Keep `package.json`, both root
+version fields in `package-lock.json`, the package test expectation, and the dated
+changelog entry synchronized. Before merging concurrent PRs, verify that the
+selected version is still newer than `main` and has not already been published.
+
 Releases are automatic. To ship a version:
 
 1. Add a `## [x.y.z] - YYYY-MM-DD` section to `CHANGELOG.md`.

package/dist/chrome.js

@@ -1 +1,16 @@
+/**
+ * Horizontal margin for pi-minimal's chrome (status line, footer, turn rule, tool rows).
+ * Follows pi's `outputPad` setting so chrome lines up with transcript text. Pi's editor uses
+ * the separate `editorPaddingX` setting (default 0); set it to the same value for a flush
+ * left edge.
+ */
+const KEY = Symbol.for("pi-minimal.chrome-margin");
+const store = globalThis;
+/** Kept for modules linked against an older copy of this file across a hot reload. */
 export const CHROME_MARGIN = 1;
+export function chromeMargin() {
+    return store[KEY] ?? CHROME_MARGIN;
+}
+export function setChromeMargin(value) {
+    store[KEY] = value === 0 ? 0 : 1;
+}

package/dist/code-box.js

@@ -0,0 +1,69 @@
+import { Markdown, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+const PATCHED = Symbol.for("pi-minimal.code-box");
+/** Current framing implementation. Lives on globalThis so a /reload swaps the behaviour of the
+ *  wrapper that an earlier load already installed on pi-tui's shared Markdown prototype. */
+const FRAME_SLOT = Symbol.for("pi-minimal.code-box.frame");
+const slots = globalThis;
+export function frameCodeLines(lines, lang, width, theme) {
+    if (lines.length < 2)
+        return lines;
+    // Trailing spacer ("" after the closing fence) is preserved as-is.
+    let end = lines.length;
+    while (end > 0 && lines[end - 1] === "")
+        end -= 1;
+    if (end < 2)
+        return lines;
+    const trailer = lines.slice(end);
+    const body = lines.slice(1, end - 1);
+    const indent = theme.codeBlockIndent ?? "  ";
+    const outer = Math.max(6, width);
+    // "│ " + content + " │"
+    const innerWidth = outer - 4;
+    const label = lang ? ` ${lang} ` : "";
+    const topRule = "─".repeat(Math.max(1, outer - 3 - visibleWidth(label)));
+    const top = theme.codeBlockBorder(`╭─${label}${topRule}╮`);
+    const bottom = theme.codeBlockBorder(`╰${"─".repeat(outer - 2)}╯`);
+    const edge = theme.codeBlockBorder("│");
+    const framed = [];
+    for (const line of body) {
+        const content = line.startsWith(indent) ? line.slice(indent.length) : line;
+        for (const piece of wrapTextWithAnsi(content, innerWidth)) {
+            const pad = Math.max(0, innerWidth - visibleWidth(piece));
+            framed.push(`${edge} ${piece}${" ".repeat(pad)} ${edge}`);
+        }
+    }
+    if (framed.length === 0)
+        framed.push(`${edge} ${" ".repeat(innerWidth)} ${edge}`);
+    return [top, ...framed, bottom, ...trailer];
+}
+/**
+ * Patch pi-tui's Markdown renderer. The prototype wrapper is installed once per process; every
+ * call (including after /reload) points it at this module's `frameCodeLines`.
+ * Returns false when the renderer is not patchable.
+ */
+export function installCodeBox() {
+    slots[FRAME_SLOT] = frameCodeLines;
+    const proto = Markdown.prototype;
+    if (proto[PATCHED])
+        return true;
+    const original = proto.renderToken;
+    if (typeof original !== "function")
+        return false;
+    const originalRender = original;
+    proto.renderToken = function (token, width, next, style) {
+        const lines = originalRender.call(this, token, width, next, style);
+        if (token?.type !== "code" || !this.theme?.codeBlockBorder)
+            return lines;
+        const frame = slots[FRAME_SLOT];
+        if (!frame)
+            return lines;
+        try {
+            return frame(lines, token.lang, width, this.theme);
+        }
+        catch {
+            return lines;
+        }
+    };
+    proto[PATCHED] = true;
+    return true;
+}

package/dist/cwd.js

@@ -1,7 +1,9 @@
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import path from "node:path";
-import { CHROME_MARGIN } from "./chrome.js";
+import * as chrome from "./chrome.js";
 import { formatGitState } from "./git-state.js";
+/** Tolerates a stale chrome module after /reload, where only CHROME_MARGIN may exist. */
+const margin = () => (typeof chrome.chromeMargin === "function" ? chrome.chromeMargin() : (chrome.CHROME_MARGIN ?? 1));
 export function formatCwd(cwd) {
     const home = process.env.HOME || process.env.USERPROFILE || "";
     if (!home)
@@ -95,7 +97,7 @@ export function installCwd(ctx, sources) {
             dispose: unsub,
             invalidate() { },
             render(width) {
-                const inner = Math.max(8, width - CHROME_MARGIN * 2);
+                const inner = Math.max(8, width - margin() * 2);
                 const id = ctx.model?.id || "no-model";
                 const icon = theme.fg("accent", modelIcon(id));
                 const name = theme.fg("text", shortModel(id));
@@ -136,7 +138,7 @@ export function installCwd(ctx, sources) {
                         .join(theme.fg("dim", " · ")));
                 }
                 const row = splitRow(left, right, inner);
-                return [`${" ".repeat(CHROME_MARGIN)}${row}`];
+                return [`${" ".repeat(margin())}${row}`];
             },
         };
     }, { placement: "aboveEditor" });

package/dist/footer-activity-details.js

@@ -0,0 +1,45 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+export function taskPrefix(task, plain, theme) {
+    if (!task)
+        return "";
+    if (plain)
+        return `[${task.status}] ${task.id} / `;
+    const badges = {
+        blocked: ["!", "warning"], in_review: ["◇", "accent"], done: ["✓", "success"], cancelled: ["⊘", "muted"],
+    };
+    const badge = badges[task.status];
+    return `${badge ? theme.fg(badge[1], badge[0]) + " " : ""}${task.id} · `;
+}
+function elapsed(ms, missing) {
+    if (ms === undefined)
+        return missing;
+    const seconds = Math.floor(ms / 1000);
+    if (seconds >= 3600)
+        return `${Math.floor(seconds / 3600)}h ${String(Math.floor(seconds / 60) % 60).padStart(2, "0")}m`;
+    if (seconds >= 60)
+        return `${Math.floor(seconds / 60)}m ${String(seconds % 60).padStart(2, "0")}s`;
+    return `${seconds}s`;
+}
+function tokens(value, missing) {
+    if (value === undefined)
+        return missing;
+    if (value >= 999950)
+        return `${(value / 1000000).toFixed(1)}m`;
+    if (value >= 1000)
+        return `${(value / 1000).toFixed(1)}k`;
+    return String(value);
+}
+/** Metrics never displace activity text: first drop tokens, then elapsed time. */
+export function alignActivityMetrics(left, metrics, width, plain, theme) {
+    if (metrics) {
+        const missing = plain ? "-" : "—";
+        const time = elapsed(metrics.elapsedMs, missing);
+        const full = `${time}${plain ? " / " : " · "}${tokens(metrics.tokens, missing)} tok`;
+        for (const right of [full, time]) {
+            const gap = width - visibleWidth(left) - visibleWidth(right);
+            if (gap >= 2)
+                return left + " ".repeat(gap) + theme.fg("muted", right);
+        }
+    }
+    return truncateToWidth(left, width);
+}

package/dist/footer-activity.js

@@ -0,0 +1,36 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { cleanActivityText } from "./footer-contributions.js";
+import { rowGlyph } from "./tool-rows.js";
+import { alignActivityMetrics, taskPrefix } from "./footer-activity-details.js";
+const MAX_ROWS = 4;
+const indicators = {
+    queued: ["○", "muted"], running: ["◐", "warning"], waiting: ["!", "warning"], paused: ["Ⅱ", "muted"],
+    stopping: ["!", "warning"], completed: ["✓", "success"], failed: ["✗", "error"], stopped: ["⊘", "muted"], unknown: ["?", "muted"],
+};
+export function activityNeedsAnimation(snapshot) {
+    return snapshot?.motion === "spinner" && snapshot.format === "icons" && snapshot.rows.slice(0, MAX_ROWS).some(row => row.state === "running");
+}
+export function renderFooterActivity(snapshot, width, theme, frame = 0) {
+    if (!snapshot || width <= 0)
+        return [];
+    const parents = new Map(snapshot.rows.map(row => [row.key, row.parentKey]));
+    const lines = snapshot.rows.slice(0, MAX_ROWS).map(row => {
+        const [fallback, tone] = indicators[row.state];
+        const glyph = row.state === "running" ? rowGlyph("running", snapshot.motion === "spinner" ? frame : 0)
+            : row.state === "completed" ? rowGlyph("ok", 0) : row.state === "failed" ? rowGlyph("error", 0) : fallback;
+        const marker = snapshot.format === "plain" ? `[${row.state}]` : glyph;
+        let depth = 0, parent = row.parentKey;
+        while (parent && depth < 2) {
+            depth++;
+            parent = parents.get(parent);
+        }
+        const reason = row.state === "stopping" && snapshot.format === "icons" ? "Stopping: " : "";
+        const task = taskPrefix(row.task, snapshot.format === "plain", theme);
+        const text = `${"  ".repeat(depth)}${theme.fg(tone, marker)} ${cleanActivityText(row.agent)}  ${task}${reason}${cleanActivityText(row.text)}`.trimEnd();
+        return alignActivityMetrics(text, row.metrics, width, snapshot.format === "plain", theme);
+    });
+    const omitted = Math.min(Number.MAX_SAFE_INTEGER, snapshot.omitted + Math.max(0, snapshot.rows.length - MAX_ROWS));
+    if (omitted > 0)
+        lines.push(truncateToWidth(theme.fg("muted", `+ ${omitted} more`), width));
+    return lines;
+}

package/dist/footer-contribution-events.js

@@ -0,0 +1,35 @@
+export const FOOTER_EVENTS = {
+    register: "pi-minimal:footer:v1:register",
+    ready: "pi-minimal:footer:v1:ready",
+    unavailable: "pi-minimal:footer:v1:unavailable",
+};
+/** Bind once per session, not once per footer mount. Trusted in-process protocol. */
+export function bindFooterContributionEvents(events, registry, sessionId, mode) {
+    registry.reset(mode === "tui" ? sessionId : null);
+    const unsubscribe = events.on(FOOTER_EVENTS.register, (value) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            return;
+        const request = value;
+        // A different host may have answered first. Never overwrite its result.
+        if (request.result !== undefined)
+            return;
+        if (request.version !== 1 || (request.slot !== "activity" && request.slot !== "summary"))
+            request.result = { ok: false, code: "invalid" };
+        else if (mode !== "tui")
+            request.result = { ok: false, code: "not-tui" };
+        else
+            request.result = request.slot === "summary" ? registry.registerPlan(request) : registry.register(request);
+    });
+    if (mode === "tui")
+        events.emit(FOOTER_EVENTS.ready, { version: 1, sessionId, slots: ["activity", "summary"] });
+    let disposed = false;
+    return () => {
+        if (disposed)
+            return;
+        disposed = true;
+        unsubscribe();
+        registry.reset(null);
+        if (mode === "tui")
+            events.emit(FOOTER_EVENTS.unavailable, { version: 1, sessionId });
+    };
+}

package/dist/footer-contributions.js

@@ -0,0 +1,130 @@
+import { stripVTControlCharacters } from "node:util";
+import { normalizePlanSnapshot } from "./footer-plan.js";
+export const ACTIVITY_STATES = ["queued", "running", "waiting", "paused", "stopping", "completed", "failed", "stopped", "unknown"];
+export const TASK_STATUSES = ["todo", "in_progress", "blocked", "in_review", "done", "cancelled"];
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function identity(value) {
+    return typeof value === "string" && /^[a-zA-Z0-9._:@+-]{1,128}$/.test(value);
+}
+export function cleanActivityText(value) {
+    return stripVTControlCharacters(value)
+        // Also remove bare C0/C1 and bidi controls; no terminal commands from labels.
+        // eslint-disable-next-line no-control-regex
+        .replace(/[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/g, " ")
+        .replace(/\s+/gu, " ").trim();
+}
+function validMetrics(value) {
+    return record(value) && [value.elapsedMs, value.tokens].every(n => n === undefined || (Number.isSafeInteger(n) && n >= 0));
+}
+function validTask(value) {
+    return record(value) && identity(value.planId) && identity(value.id) && TASK_STATUSES.includes(value.status);
+}
+function normalizeSnapshot(input) {
+    if (!record(input) || !Number.isSafeInteger(input.revision) || input.revision < 0 ||
+        !Number.isSafeInteger(input.omitted) || input.omitted < 0 ||
+        !["spinner", "static"].includes(input.motion) || !["icons", "plain"].includes(input.format) ||
+        !Array.isArray(input.rows) || input.rows.length > 64)
+        return;
+    const rows = [];
+    const parents = new Map();
+    for (const item of input.rows) {
+        if (!record(item) || !identity(item.key) || parents.has(item.key) ||
+            typeof item.agent !== "string" || item.agent.length > 96 || !cleanActivityText(item.agent) ||
+            typeof item.text !== "string" || item.text.length > 256 ||
+            !ACTIVITY_STATES.includes(item.state) ||
+            (item.parentKey !== undefined && !identity(item.parentKey)) ||
+            (item.metrics !== undefined && !validMetrics(item.metrics)) ||
+            (item.task !== undefined && !validTask(item.task)))
+            return;
+        parents.set(item.key, item.parentKey);
+        rows.push(Object.freeze({ key: item.key, agent: cleanActivityText(item.agent), state: item.state,
+            text: cleanActivityText(item.text), ...(item.parentKey === undefined ? {} : { parentKey: item.parentKey }),
+            ...(item.metrics === undefined ? {} : { metrics: Object.freeze({ elapsedMs: item.metrics.elapsedMs, tokens: item.metrics.tokens }) }),
+            ...(item.task === undefined ? {} : { task: Object.freeze({ planId: item.task.planId, id: item.task.id, status: item.task.status }) }),
+        }));
+    }
+    for (const row of rows) {
+        const seen = new Set([row.key]);
+        let parent = row.parentKey;
+        while (parent !== undefined) {
+            if (!parents.has(parent) || seen.has(parent))
+                return;
+            seen.add(parent);
+            parent = parents.get(parent);
+        }
+    }
+    return Object.freeze({ revision: input.revision, rows: Object.freeze(rows), omitted: input.omitted,
+        motion: input.motion, format: input.format });
+}
+function createFooterSlot(normalize, initialSessionId) {
+    let sessionId = initialSessionId;
+    let owner;
+    let snapshot;
+    const observers = new Set();
+    const notify = () => {
+        for (const observer of [...observers]) {
+            try {
+                observer();
+            }
+            catch { /* A disposed UI must not invalidate a successful publish. */ }
+        }
+    };
+    return {
+        read: () => snapshot,
+        subscribe(observer) { observers.add(observer); return () => { observers.delete(observer); }; },
+        reset(nextSessionId) {
+            sessionId = nextSessionId;
+            owner = undefined;
+            snapshot = undefined;
+            notify();
+        },
+        register(input) {
+            if (!record(input) || !identity(input.owner) || typeof input.sessionId !== "string" || !input.sessionId)
+                return { ok: false, code: "invalid" };
+            if (sessionId === null || input.sessionId !== sessionId)
+                return { ok: false, code: "wrong-session" };
+            if (owner)
+                return { ok: false, code: "occupied" };
+            const token = Symbol(input.owner);
+            owner = token;
+            return { ok: true, registration: {
+                    publish(input) {
+                        if (owner !== token)
+                            return { ok: false, code: "disposed" };
+                        const next = normalize(input);
+                        if (!next)
+                            return { ok: false, code: "invalid" };
+                        if (snapshot && next.revision <= snapshot.revision)
+                            return { ok: false, code: "stale" };
+                        snapshot = next;
+                        notify();
+                        return { ok: true };
+                    },
+                    dispose() {
+                        if (owner !== token)
+                            return;
+                        owner = undefined;
+                        snapshot = undefined;
+                        notify();
+                    },
+                } };
+        },
+    };
+}
+export function createFooterContributions(initialSessionId = null) {
+    const activity = createFooterSlot(normalizeSnapshot, initialSessionId);
+    const summary = createFooterSlot(normalizePlanSnapshot, initialSessionId);
+    return {
+        read: activity.read,
+        readPlan: summary.read,
+        register: activity.register,
+        registerPlan: summary.register,
+        subscribe(observer) {
+            const offActivity = activity.subscribe(observer), offSummary = summary.subscribe(observer);
+            return () => { offActivity(); offSummary(); };
+        },
+        reset(sessionId) { activity.reset(sessionId); summary.reset(sessionId); },
+    };
+}

package/dist/footer-plan.js

@@ -0,0 +1,41 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const count = (value) => Number.isSafeInteger(value) && value >= 0;
+export function normalizePlanSnapshot(value) {
+    if (!record(value) || !count(value.revision) || (value.format !== "icons" && value.format !== "plain"))
+        return;
+    if (value.plan === undefined)
+        return Object.freeze({ revision: value.revision, format: value.format });
+    const plan = value.plan;
+    if (!record(plan) || typeof plan.id !== "string" || !/^[a-zA-Z0-9._:@+-]{1,128}$/.test(plan.id) ||
+        !count(plan.accepted) || !count(plan.total) || !count(plan.inReview) || !count(plan.blocked) ||
+        plan.accepted > plan.total || plan.inReview > plan.total - plan.accepted || plan.blocked > plan.total - plan.accepted)
+        return;
+    return Object.freeze({ revision: value.revision, format: value.format,
+        plan: Object.freeze({ id: plan.id, accepted: plan.accepted, total: plan.total, inReview: plan.inReview, blocked: plan.blocked }) });
+}
+/** Display-only accepted-task counts, never inferred from agent execution. */
+export function renderFooterPlan(snapshot, width, theme) {
+    if (!snapshot?.plan || width <= 0)
+        return [];
+    const { id, accepted, total, inReview, blocked } = snapshot.plan;
+    const plain = snapshot.format === "plain", separator = plain ? " / " : " · ";
+    const label = theme.fg("accent", `Plan ${id}`);
+    if (!total)
+        return [truncateToWidth(`${label}${separator}No tasks yet`, width)];
+    const slots = total <= 12 ? total : 10;
+    const filled = total <= 12 ? accepted : Math.floor(accepted / total * slots);
+    const bar = theme.fg("accent", (plain ? "#" : "▰").repeat(filled)) + theme.fg("muted", (plain ? "." : "▱").repeat(slots - filled));
+    const counts = `${accepted}/${total}`;
+    const attention = [inReview ? `${plain ? "" : "◇ "}${inReview} review` : "", blocked ? `! ${blocked} blocked` : ""].filter(Boolean);
+    const suffix = attention.length ? separator + attention.join(separator) : "";
+    for (const text of [`${label}${separator}${bar} ${counts}${suffix}`, `${label}${separator}${counts}${suffix}`, `${label}${separator}${counts}`]) {
+        if (visibleWidth(text) <= width)
+            return [text];
+    }
+    // Exact counts outrank a long plan label on extremely narrow terminals.
+    const room = width - visibleWidth(counts) - 1;
+    return [room > 0 ? `${truncateToWidth(label, room)} ${counts}` : truncateToWidth(counts, width)];
+}

package/dist/footer.js

@@ -1,7 +1,12 @@
 import { keyHint } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
-import { CHROME_MARGIN } from "./chrome.js";
+import * as chrome from "./chrome.js";
 import { formatTrackerLines } from "./tracker.js";
+import { activityNeedsAnimation, renderFooterActivity } from "./footer-activity.js";
+import { createLiveWatch } from "./live-watch.js";
+import { renderFooterPlan } from "./footer-plan.js";
+/** Tolerates a stale chrome module after /reload, where only CHROME_MARGIN may exist. */
+const margin = () => (typeof chrome.chromeMargin === "function" ? chrome.chromeMargin() : (chrome.CHROME_MARGIN ?? 1));
 /**
  * Key hints are shown only when nothing else needs the line: idle agent, empty editor. Otherwise
  * the footer collapses to zero lines (tracker lines excepted).
@@ -17,14 +22,43 @@ export function footerHints(sources, hints) {
         out.push("/compact");
     return out;
 }
-export function installFooter(ctx, sources) {
+export function installFooter(ctx, sources, contributions) {
+    let stopMount = () => { };
+    let stopped = false;
     ctx.ui.setFooter((tui, theme, footerData) => {
-        const unsub = footerData.onBranchChange(() => tui.requestRender());
+        stopMount();
+        if (stopped)
+            return { render: () => [], invalidate() { } };
+        const live = createLiveWatch(400);
+        let disposed = false;
+        let activityHasSpace = true;
+        const redraw = () => { if (!disposed)
+            tui.requestRender(); };
+        const syncAnimation = () => {
+            if (disposed)
+                return;
+            if (activityHasSpace && activityNeedsAnimation(contributions?.read()))
+                live.watch("footer", redraw);
+            else
+                live.unwatch("footer");
+        };
+        const update = () => { syncAnimation(); redraw(); };
+        const unsub = footerData.onBranchChange(redraw);
+        const unsubscribeActivity = contributions?.subscribe(update);
+        stopMount = () => {
+            if (disposed)
+                return;
+            disposed = true;
+            unsub();
+            unsubscribeActivity?.();
+            live.stop();
+        };
+        update();
         return {
-            dispose: unsub,
+            dispose: stopMount,
             invalidate() { },
             render(width) {
-                const inner = Math.max(8, width - CHROME_MARGIN * 2);
+                const inner = Math.max(8, width - margin() * 2);
                 const out = [];
                 const hints = footerHints(sources, [
                     keyHint("tui.input.submit", "send"),
@@ -33,13 +67,23 @@ export function installFooter(ctx, sources) {
                 ].filter(Boolean));
                 if (hints.length > 0) {
                     const line = theme.fg("dim", hints.join("  ·  "));
-                    out.push(`${" ".repeat(CHROME_MARGIN)}${truncateToWidth(line, inner, "")}`);
-                }
-                for (const extra of formatTrackerLines(ctx, theme)) {
-                    out.push(`${" ".repeat(CHROME_MARGIN)}${truncateToWidth(extra, inner, "")}`);
+                    out.push(`${" ".repeat(margin())}${truncateToWidth(line, inner, "")}`);
                 }
-                return out;
+                const activityWidth = Math.max(0, width - margin() * 2);
+                const plan = renderFooterPlan(contributions?.readPlan(), activityWidth, theme);
+                const summary = (plan.length ? plan : formatTrackerLines(ctx, theme))
+                    .map(line => `${" ".repeat(margin())}${truncateToWidth(line, plan.length ? activityWidth : inner, "")}`);
+                activityHasSpace = activityWidth > 0;
+                syncAnimation();
+                const activity = renderFooterActivity(contributions?.read(), activityWidth, theme, live.frame)
+                    .map(line => `${" ".repeat(margin())}${line}`);
+                // Preserve legacy-only layout; contributions opt into the spaced layout.
+                if (!plan.length && !activity.length)
+                    return [...out, ...summary];
+                const groups = [out, summary, activity].filter(group => group.length > 0);
+                return ["", ...groups.flatMap((group, index) => index === 0 ? group : ["", ...group])];
             },
         };
     });
+    return () => { stopped = true; stopMount(); };
 }