pi-minimal 0.2.1 → 0.2.3

package/dist/index.js

@@ -2,6 +2,8 @@ import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { loadPiMinimalConfig } from "./config.js";
 import { installHeader } from "./header.js";
 import { installFooter } from "./footer.js";
+import { createFooterContributions } from "./footer-contributions.js";
+import { bindFooterContributionEvents } from "./footer-contribution-events.js";
 import { installCwd } from "./cwd.js";
 import { listSiblings, parseAgentList, parseTabList } from "./herdr.js";
 import { hideGauntletWidgets } from "./tracker.js";
@@ -11,11 +13,19 @@ import { installWorkingStatus } from "./working-status.js";
 import { installTurnRule } from "./turn-rule.js";
 import { installTranscript } from "./transcript.js";
 import { createGitState } from "./git-state.js";
+import { installCodeBox } from "./code-box.js";
+import { setChromeMargin } from "./chrome.js";
+import { SettingsManager } from "@earendil-works/pi-coding-agent";
 export default function piMinimalExtension(pi) {
     const stopWorkingStatus = installWorkingStatus(pi);
     const stopTurnRule = installTurnRule(pi);
     installToolRenderers(pi);
     installTranscript(pi);
+    installCodeBox();
+    const contributions = createFooterContributions();
+    let stopFooter = () => { };
+    let stopContributionEvents = () => { };
+    let sessionActive = false;
     let fastTimer;
     let slowTimer;
     let stealTimer;
@@ -124,11 +134,12 @@ export default function piMinimalExtension(pi) {
         return Math.max(0, Math.min(100, Math.round((usage.tokens / window) * 100)));
     };
     const installChromeFooter = (ctx) => {
-        installFooter(ctx, {
+        stopFooter();
+        stopFooter = installFooter(ctx, {
             busy: () => busy,
             editorText: () => (typeof ctx.ui.getEditorText === "function" ? ctx.ui.getEditorText() : ""),
             contextPct: () => contextPct(ctx),
-        });
+        }, contributions);
     };
     const installStatusLine = (ctx) => {
         installCwd(ctx, {
@@ -145,6 +156,11 @@ export default function piMinimalExtension(pi) {
         installStatusLine(ctx);
     };
     pi.on("session_start", async (_event, ctx) => {
+        stopFooter();
+        stopContributionEvents();
+        sessionActive = true;
+        generation += 1;
+        stopContributionEvents = bindFooterContributionEvents(pi.events, contributions, ctx.sessionManager.getSessionId(), ctx.mode);
         if (ctx.mode !== "tui")
             return;
         const config = loadPiMinimalConfig({
@@ -154,6 +170,13 @@ export default function piMinimalExtension(pi) {
         });
         hideWidgets = config.hideGauntletWidgets;
         currentCwd = ctx.cwd;
+        try {
+            const settings = SettingsManager.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted() });
+            setChromeMargin(settings.getOutputPad());
+        }
+        catch {
+            // Keep the default margin when settings are unavailable.
+        }
         installHeader(ctx);
         installChromeFooter(ctx);
         installStatusLine(ctx);
@@ -161,8 +184,13 @@ export default function piMinimalExtension(pi) {
         pinChrome(ctx, "session_start");
         ctx.ui.setHiddenThinkingLabel("◆ Thought");
         ctx.ui.setWorkingIndicator();
-        setTimeout(() => pinChrome(ctx, "session_settle"), 0);
-        setTimeout(() => pinChrome(ctx, "session_settle"), 50);
+        const sessionGeneration = generation;
+        const settle = () => {
+            if (sessionActive && generation === sessionGeneration)
+                pinChrome(ctx, "session_settle");
+        };
+        setTimeout(settle, 0);
+        setTimeout(settle, 50);
         if (!stealTimer) {
             stealTimer = setInterval(() => hideForeignChrome(ctx, "interval"), 200);
         }
@@ -186,6 +214,9 @@ export default function piMinimalExtension(pi) {
         void gitState.refresh();
     });
     pi.on("session_shutdown", async () => {
+        sessionActive = false;
+        stopFooter();
+        stopContributionEvents();
         busy = false;
         stopTimers();
         stopWorkingStatus();

package/dist/tools.js

@@ -1,10 +1,13 @@
 import { Container, truncateToWidth } from "@earendil-works/pi-tui";
 import { rowIsRunning } from "./activity.js";
+import * as chrome from "./chrome.js";
 import { createLiveWatch } from "./live-watch.js";
 import { bashBody, formatDuration, formatOutcome, layoutRow, resultText, rowGlyph, toolItem, } from "./tool-rows.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));
 const live = createLiveWatch(400);
-/** Left indent of every tool row, in cells. */
-const ROW_INDENT = 2;
+/** Left indent of every tool row: chrome margin plus one cell so rows sit inside message text. */
+const rowIndent = () => margin() + 1;
 /** Max lines of output shown when a row is expanded. */
 const EXPANDED_MAX_LINES = 400;
 export function stopLiveWatch() {
@@ -44,7 +47,7 @@ function outputBlock(kind, result, theme) {
     const lines = expandedLines(kind, result);
     if (lines.length === 0)
         return new Container();
-    const indent = " ".repeat(ROW_INDENT + 2);
+    const indent = " ".repeat(rowIndent() + 2);
     const rule = theme.fg("borderMuted", "│");
     return {
         render(width) {
@@ -57,7 +60,7 @@ function outputBlock(kind, result, theme) {
 function errorLineBlock(line, theme) {
     if (!line)
         return undefined;
-    const indent = " ".repeat(ROW_INDENT + 2);
+    const indent = " ".repeat(rowIndent() + 2);
     const rule = theme.fg("error", "│");
     return {
         render(width) {
@@ -98,7 +101,7 @@ function activityRow(kind, args, theme, context) {
                     right = right ? `${stats} · ${right}` : stats;
                 }
             }
-            const inner = Math.max(8, width - ROW_INDENT);
+            const inner = Math.max(8, width - rowIndent());
             const row = layoutRow(inner, kind, item, right);
             let coloredRight;
             if (status === "running")
@@ -112,7 +115,7 @@ function activityRow(kind, args, theme, context) {
             }
             else
                 coloredRight = theme.fg("dim", row.outcome);
-            const line = " ".repeat(ROW_INDENT) +
+            const line = " ".repeat(rowIndent()) +
                 theme.fg(statusColor(status), glyph) +
                 " " +
                 theme.fg("dim", row.verb) +

package/dist/turn-rule.js

@@ -1,6 +1,8 @@
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { CHROME_MARGIN } from "./chrome.js";
+import * as chrome from "./chrome.js";
 import { formatElapsed } from "./working-status.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 const TURN_ENTRY_TYPE = "pi-minimal.turn";
 export function formatClock(epochMs) {
     const d = new Date(epochMs);
@@ -70,10 +72,10 @@ export function installTurnRule(pi) {
         const color = entry.data.outcome === "completed" ? "borderMuted" : entry.data.outcome === "aborted" ? "warning" : "error";
         return {
             render(width) {
-                const inner = Math.max(0, width - CHROME_MARGIN * 2);
+                const inner = Math.max(0, width - margin() * 2);
                 const rule = ruleLine(inner, label);
                 const colored = rule.replace(label, theme.fg("dim", label));
-                return ["", `${" ".repeat(CHROME_MARGIN)}${theme.fg(color, colored)}`];
+                return ["", `${" ".repeat(margin())}${theme.fg(color, colored)}`];
             },
             invalidate() { },
         };

package/doc/footer-contributions.md

@@ -0,0 +1,132 @@
+# Footer activity contributions (v1)
+
+Pi-minimal remains the single footer owner. A trusted companion extension can publish a bounded activity snapshot without replacing the footer or fighting other widgets. With no contributor, existing hints and legacy phase/task summaries are unchanged.
+
+Order: **input → existing hints → plan summary → activity rows last**. When either contribution is visible, a blank row separates the footer from input and separates each nonempty group. Agent rows stay compact, and empty groups leave no extra gaps. Legacy-only output is unchanged.
+
+Two independent slots are supported: `activity` and `summary`, with one owner per slot. An explicit plan summary replaces the legacy tracker projection while present, avoiding duplicate plan bars; clearing it restores the legacy summary. This is display composition, not a task tracker, subagent launcher, or PR/workspace display.
+
+## Events
+
+| Event | Direction | Payload |
+|---|---|---|
+| `pi-minimal:footer:v1:register` | consumer → host | Mutable registration request; host assigns `result` synchronously |
+| `pi-minimal:footer:v1:ready` | host → consumers | `{ version: 1, sessionId, slots: ["activity", "summary"] }` |
+| `pi-minimal:footer:v1:unavailable` | host → consumers | `{ version: 1, sessionId }` |
+
+Use `ctx.sessionManager.getSessionId()`, not a file path. Events are in-process only, not a cross-process API. One consumer owns each slot at a time; a tracker and activity extension can register independently. Names/keys are display identity, not permission or process-control tokens.
+
+Register during `session_start`; also listen for `ready` to tolerate either extension load order. Clear the local handle on `unavailable`. Do not attempt to reinstall the footer if no host responds.
+
+```ts
+const request = {
+  version: 1,
+  sessionId: ctx.sessionManager.getSessionId(),
+  owner: "my-activity-extension",
+  slot: "activity",
+  result: undefined as RegisterRequest["result"],
+};
+pi.events.emit("pi-minimal:footer:v1:register", request);
+if (request.result?.ok) {
+  const registration = request.result.registration;
+  const result = registration.publish({
+    revision: 0,
+    motion: "spinner",
+    format: "icons",
+    omitted: 0,
+    rows: [
+      { key: "child-1", agent: "worker", state: "running", text: "Last: executing tests" },
+      { key: "child-2", agent: "reviewer", state: "completed", text: "Review output available" },
+    ],
+  });
+  // Inspect result.ok; publication is not a task-completion acknowledgement.
+  // On consumer shutdown: registration.dispose().
+}
+```
+
+This snippet assumes the following structural types, copied into the consumer or maintained as a type-only development contract. No runtime import from an independently installed npm package is necessary. `src/footer-contribution-events.ts` and `src/footer-contributions.ts` are the host's canonical definitions.
+
+```ts
+type RegisterRequest = {
+  version: 1;
+  sessionId: string;
+  owner: string;
+  slot: "activity" | "summary";
+  result?:
+    | { ok: true; registration: {
+        publish(snapshot: unknown): { ok: true } | { ok: false; code: string };
+        dispose(): void;
+      } }
+    | { ok: false; code: string };
+};
+```
+
+No result means the host is absent/not ready. Registration errors include `invalid`, `wrong-session`, `occupied`, and `not-tui`. Publish errors include `invalid`, `stale`, and `disposed`.
+
+## Plan summary snapshot (`summary` slot)
+
+```ts
+{
+  revision: 0,
+  format: "icons", // or "plain"
+  plan: { id: "P12", accepted: 3, total: 7, inReview: 1, blocked: 1 }
+}
+```
+
+The plan ID follows row-key bounds. Counts/revision are nonnegative safe integers;
+accepted cannot exceed total; review and blocked counts cannot individually exceed
+remaining tasks. Counts are supplied by the tracker, never inferred from agent
+runs. Omit `plan` on a newer revision to clear the contribution without releasing
+ownership. Snapshot objects are cloned/frozen, and revision/disposal rules match
+the activity slot. Each slot has independent ownership and revision tracking.
+
+The label and filled segments use the semantic `accent` color (violet in
+minimal-dark); empty segments are muted. Up to 12 tasks use one slanted segment
+per task (`▰▰▰▱▱▱▱ 3/7`). Larger plans use ten proportional segments and retain the
+exact count; these represent aggregate progress, not individual task states.
+Plain mode uses `###....`. The strip drops before counts/attention on narrow
+terminals. Zero total displays `No tasks yet`. No animation or task persistence
+is introduced by this display slot.
+
+## Activity snapshot schema (`activity` slot)
+
+- `revision`: nonnegative safe integer, strictly increasing for each successful publish on one registration. Start at zero again after a new registration.
+- `motion`: `spinner` or `static`.
+- `format`: `icons` or `plain` (explicit textual state labels).
+- `omitted`: nonnegative safe integer; extra underlying records not supplied in this snapshot.
+- `rows`: at most 64 records; an empty array clears visible activity without releasing ownership.
+
+Each row:
+- `key`: unique 1–128 character identity, ASCII letters/numbers plus `. _ : @ + -`.
+- `agent`: nonempty label after sanitization, at most 96 input characters.
+- `state`: `queued`, `running`, `waiting`, `paused`, `stopping`, `completed`, `failed`, `stopped`, or `unknown`.
+- `text`: at most 256 input characters; keep it short, safe, and evidence-grounded.
+- Optional `parentKey`: references a key in the same snapshot. Missing references, self-parenting, and cycles are rejected.
+- Optional `metrics`: `{ elapsedMs?: number, tokens?: number }`. Both values must be nonnegative safe integers. An absent object preserves the original compact row; an empty object displays unknown values (`—`, or `-` in plain mode), never invented zeros.
+- Optional `task`: `{ planId: string, id: string, status: "todo" | "in_progress" | "blocked" | "in_review" | "done" | "cancelled" }`. Both IDs use the same bounds as row keys. The link is display context, not permission to read/write a plan.
+
+Metrics are right-aligned only if the full activity text still fits with at least two columns of separation. Drop tokens first, then time, before truncating activity. Elapsed time is supplied by the producer: compute from the run start while active, freeze at the run's end, and do not advance completed/unknown runs by inference. `tokens` means this child's own cumulative reported input + output tokens, excluding separately summed descendants. It is not context-window occupancy; omit unavailable data rather than guessing. The host does not calculate elapsed time from wall-clock time.
+
+Task IDs appear beside activity. In-progress tasks need no extra badge; blocked/review/accepted/cancelled tasks get a distinct badge, and plain mode retains textual status. A completed agent with an `in_review` task shows a green run check plus an accent review diamond. This optional data does not create a tracker or automatically accept a task.
+
+Owner uses the same character/length rules as row keys. Display text has ANSI/OSC, C0/C1, and bidi controls removed, with whitespace collapsed. The host clones and freezes validated snapshots. Invalid/stale publishes preserve the previous valid snapshot. Consumers must handle publish failure and send an explicit unknown/error observation when appropriate; an absent update does not prove a run ended.
+
+## Presentation and responsibility boundaries
+
+The host renders the first four supplied rows and one overflow line, without reordering them. Consumer owns stable ordering, priority, retention, dismissal and source reconciliation. Nesting is indented at most two levels. Terminal-width helpers enforce visible-column limits.
+
+Running uses pi-minimal's yellow `◐`/`◓` frames every 400ms. Completed uses green `✓`; failed uses red `✗`. Attention/stopping is yellow `!`; stopping includes an explicit prefix. Other shapes remain distinct in monochrome. Plain mode retains state words and does not animate. `static` also disables animation. Consumers should choose static/plain according to user accessibility preferences; this terminal contract does not pretend to detect browser reduced-motion settings.
+
+Only visible running rows animate; animation performs no provider queries, model calls, or filesystem reads. Host semantic theme colors are resolved each render. A completed run means only that run completed; it must not be presented as accepted task work without separate evidence.
+
+The host does not validate execution truth. It validates display shape and lifecycle ownership. It does not publish or hide pi-subagents widgets, mutate any other extension's settings, store run history, or expose stop/steer actions.
+
+## Lifecycle and rollback
+
+Footer component reinstalls preserve the session registry, while disposing old redraw/branch listeners and animation timers. Session shutdown/replacement invalidates registration handles even if the next session reuses the same ID. A stale disposer cannot clear a newer owner. Dispose is idempotent.
+
+Consumers dispose their handle and event subscriptions on shutdown, and register again in the new runtime. Use strictly increasing revisions to prevent late responses overwriting fresh data; request/session correlation remains the consumer's responsibility.
+
+Disable the consumer to remove activity rows. No process is stopped and no task state is changed. The host contribution API is inert without a consumer. Test a new consumer in an isolated pi profile before changing live configuration.
+
+This is a trusted extension contract, not a sandbox against malicious code already loaded into the process.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-minimal",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "license": "MIT",
   "type": "module",
   "private": false,

package/release-notes.md

@@ -1,30 +1,31 @@
 ### Added
-- Automated releases: when `version` in `package.json` changes on `main`, the
-  Publish workflow verifies the build, tags `vX.Y.Z`, creates a GitHub Release
-  (CHANGELOG section + generated notes + package tarball), records a deployment
-  to the `npm` environment, and publishes to npm via OIDC trusted publishing.
-- `CHANGELOG.md` and a "Releasing" section in the README.
-- The Publish workflow upgrades npm to >= 11.5.1 (required for OIDC trusted
-  publishing) and is re-runnable: an existing tag whose version is missing
-  from npm is published without re-tagging.
-- `repository`, `homepage`, and `bugs` fields in `package.json`, required for
-  npm provenance verification.
+- 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.
 
-### Changed
-- The release-triggered publish workflow is now a manual, token-based fallback
-  (`release.yml`) for re-publishing an existing tag.
+### 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.
 
 ## What's Changed
-* Document trusted publishing setup by @raviy06 in https://github.com/raviy06/pi-minimal/pull/3
-* Use npm for installation by @raviy06 in https://github.com/raviy06/pi-minimal/pull/4
-* Design pass: tool rows, turn rule, status line, minimal-dark theme by @raviy06 in https://github.com/raviy06/pi-minimal/pull/5
-* Automate releases on version change (0.2.1) by @raviy06 in https://github.com/raviy06/pi-minimal/pull/6
+* feat: add cooperative footer activity contributions by @raviy06 in https://github.com/raviy06/pi-minimal/pull/14
 
 
-**Full Changelog**: https://github.com/raviy06/pi-minimal/compare/v0.1.0...v0.2.1
+**Full Changelog**: https://github.com/raviy06/pi-minimal/compare/v0.2.2...v0.2.3
 
 ---
 **Install / upgrade**
 ```bash
-pi install npm:pi-minimal@0.2.1   # or: pi update --extensions
+pi install npm:pi-minimal@0.2.3   # or: pi update --extensions
 ```

package/src/chrome.ts

@@ -1 +1,19 @@
+/**
+ * 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 as unknown as Record<symbol, number | undefined>
+
+/** Kept for modules linked against an older copy of this file across a hot reload. */
 export const CHROME_MARGIN = 1
+
+export function chromeMargin(): number {
+  return store[KEY] ?? CHROME_MARGIN
+}
+
+export function setChromeMargin(value: number): void {
+  store[KEY] = value === 0 ? 0 : 1
+}

package/src/code-box.ts

@@ -0,0 +1,86 @@
+import { Markdown, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui"
+
+/**
+ * pi-tui renders fenced code as literal ``` lines. Pi exposes no hook for the code token, so
+ * pi-minimal post-processes the rendered lines of every `code` token into a closed box:
+ *
+ *   ╭─ json ──────────────╮
+ *   │ { "a": 1 }          │
+ *   ╰─────────────────────╯
+ *
+ * Code lines longer than the box are wrapped inside it so the right edge stays intact.
+ */
+
+type CodeToken = { type?: string; lang?: string; text?: string }
+type MarkdownThemeLike = {
+  codeBlockBorder: (text: string) => string
+  codeBlockIndent?: string
+}
+
+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")
+
+type Framer = (lines: string[], lang: string | undefined, width: number, theme: MarkdownThemeLike) => string[]
+const slots = globalThis as unknown as Record<symbol, Framer | undefined>
+
+export function frameCodeLines(lines: string[], lang: string | undefined, width: number, theme: MarkdownThemeLike): string[] {
+  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: string[] = []
+  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]
+}
+
+type RenderToken = (this: { theme: MarkdownThemeLike }, token: CodeToken, width: number, next?: string, style?: unknown) => string[]
+
+/**
+ * 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(): boolean {
+  slots[FRAME_SLOT] = frameCodeLines
+  const proto = Markdown.prototype as unknown as Record<string | symbol, unknown>
+  if (proto[PATCHED]) return true
+  const original = proto.renderToken
+  if (typeof original !== "function") return false
+  const originalRender = original as RenderToken
+  proto.renderToken = function (this: { theme: MarkdownThemeLike }, token: CodeToken, width: number, next?: string, style?: unknown) {
+    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/src/cwd.ts

@@ -1,10 +1,14 @@
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui"
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
 import path from "node:path"
-import { CHROME_MARGIN } from "./chrome.js"
+import * as chrome from "./chrome.js"
 import { formatGitState, type GitState } from "./git-state.js"
 import type { Sibling } from "./herdr.js"
 
+/** Tolerates a stale chrome module after /reload, where only CHROME_MARGIN may exist. */
+const margin = (): number => (typeof chrome.chromeMargin === "function" ? chrome.chromeMargin() : (chrome.CHROME_MARGIN ?? 1))
+
+
 export function formatCwd(cwd: string): string {
   const home = process.env.HOME || process.env.USERPROFILE || ""
   if (!home) return cwd
@@ -103,7 +107,7 @@ export function installCwd(ctx: ExtensionContext, sources: StatusLineSources): v
         dispose: unsub,
         invalidate() {},
         render(width: number): string[] {
-          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))
@@ -147,7 +151,7 @@ export function installCwd(ctx: ExtensionContext, sources: StatusLineSources): v
             )
           }
           const row = splitRow(left, right, inner)
-          return [`${" ".repeat(CHROME_MARGIN)}${row}`]
+          return [`${" ".repeat(margin())}${row}`]
         },
       }
     },

package/src/footer-activity-details.ts

@@ -0,0 +1,43 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui"
+import type { ActivityMetrics, ActivityTask } from "./footer-contributions.js"
+
+export type ActivityTone = "warning" | "success" | "error" | "muted" | "accent"
+export type ActivityTheme = { fg: (color: ActivityTone, text: string) => string }
+
+export function taskPrefix(task: ActivityTask | undefined, plain: boolean, theme: ActivityTheme): string {
+  if (!task) return ""
+  if (plain) return `[${task.status}] ${task.id} / `
+  const badges: Partial<Record<ActivityTask["status"], [string, ActivityTone]>> = {
+    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: number | undefined, missing: string): string {
+  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: number | undefined, missing: string): string {
+  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: string, metrics: ActivityMetrics | undefined, width: number, plain: boolean, theme: ActivityTheme): string {
+  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/src/footer-activity.ts

@@ -0,0 +1,31 @@
+import { truncateToWidth } from "@earendil-works/pi-tui"
+import { cleanActivityText, type ActivitySnapshot, type ActivityState } from "./footer-contributions.js"
+import { rowGlyph } from "./tool-rows.js"
+import { alignActivityMetrics, taskPrefix, type ActivityTone, type ActivityTheme } from "./footer-activity-details.js"
+const MAX_ROWS = 4
+const indicators: Record<ActivityState, [string, ActivityTone]> = {
+  queued: ["○", "muted"], running: ["◐", "warning"], waiting: ["!", "warning"], paused: ["Ⅱ", "muted"],
+  stopping: ["!", "warning"], completed: ["✓", "success"], failed: ["✗", "error"], stopped: ["⊘", "muted"], unknown: ["?", "muted"],
+}
+export function activityNeedsAnimation(snapshot: ActivitySnapshot | undefined): boolean {
+  return snapshot?.motion === "spinner" && snapshot.format === "icons" && snapshot.rows.slice(0, MAX_ROWS).some(row => row.state === "running")
+}
+export function renderFooterActivity(snapshot: ActivitySnapshot | undefined, width: number, theme: ActivityTheme, frame: 0 | 1 = 0): string[] {
+  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/src/footer-contribution-events.ts

@@ -0,0 +1,38 @@
+import type { FooterContributions, RegistrationResult } from "./footer-contributions.js"
+
+export const FOOTER_EVENTS = {
+  register: "pi-minimal:footer:v1:register",
+  ready: "pi-minimal:footer:v1:ready",
+  unavailable: "pi-minimal:footer:v1:unavailable",
+} as const
+export type RegisterRequest = {
+  version: 1; sessionId: string; owner: string; slot: "activity" | "summary"
+  result?: RegistrationResult | { ok: false; code: "not-tui" }
+}
+type Events = {
+  on(name: string, handler: (value: unknown) => void): () => void
+  emit(name: string, value: unknown): void
+}
+
+/** Bind once per session, not once per footer mount. Trusted in-process protocol. */
+export function bindFooterContributionEvents(events: Events, registry: FooterContributions, sessionId: string, mode: string): () => void {
+  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 as Partial<RegisterRequest>
+    // 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 })
+  }
+}