pi-minimal 0.2.2 → 0.2.3

package/release-notes.md

@@ -1,32 +1,31 @@
 ### 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.
+- 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
-- 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.
+### 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
-* Fix trusted publishing: upgrade npm, make Publish re-runnable by @raviy06 in https://github.com/raviy06/pi-minimal/pull/7
-* Add Dependabot configuration file by @raviy06 in https://github.com/raviy06/pi-minimal/pull/9
-* Create SECURITY.md for security policy by @raviy06 in https://github.com/raviy06/pi-minimal/pull/10
-* Pin npm 11 for trusted publishing by @raviy06 in https://github.com/raviy06/pi-minimal/pull/8
-* Drop registry-url so npm uses OIDC instead of a placeholder token by @raviy06 in https://github.com/raviy06/pi-minimal/pull/11
-* Add repository metadata required for npm provenance by @raviy06 in https://github.com/raviy06/pi-minimal/pull/12
-* Frame fenced code, align chrome with outputPad (0.2.2) by @raviy06 in https://github.com/raviy06/pi-minimal/pull/13
+* 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.2.1...v0.2.2
+**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.2   # or: pi update --extensions
+pi install npm:pi-minimal@0.2.3   # or: pi update --extensions
 ```

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 })
+  }
+}

package/src/footer-contributions.ts

@@ -0,0 +1,132 @@
+import { stripVTControlCharacters } from "node:util"
+import { normalizePlanSnapshot } from "./footer-plan.js"
+
+export const ACTIVITY_STATES = ["queued", "running", "waiting", "paused", "stopping", "completed", "failed", "stopped", "unknown"] as const
+export type ActivityState = typeof ACTIVITY_STATES[number]
+export type ActivityMetrics = Readonly<{ elapsedMs?: number; tokens?: number }>
+export const TASK_STATUSES = ["todo", "in_progress", "blocked", "in_review", "done", "cancelled"] as const
+export type ActivityTask = Readonly<{ planId: string; id: string; status: typeof TASK_STATUSES[number] }>
+export type ActivityRow = Readonly<{
+  key: string; agent: string; state: ActivityState; text: string; parentKey?: string
+  metrics?: ActivityMetrics; task?: ActivityTask
+}>
+export type ActivitySnapshot = Readonly<{
+  revision: number; rows: readonly ActivityRow[]; omitted: number
+  motion: "spinner" | "static"; format: "icons" | "plain"
+}>
+type Failure = { ok: false; code: "invalid" | "wrong-session" | "occupied" | "stale" | "disposed" }
+export type ActivityRegistration = {
+  publish(snapshot: unknown): { ok: true } | Failure
+  dispose(): void
+}
+export type RegistrationResult = { ok: true; registration: ActivityRegistration } | Failure
+
+function record(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+function identity(value: unknown): value is string {
+  return typeof value === "string" && /^[a-zA-Z0-9._:@+-]{1,128}$/.test(value)
+}
+export function cleanActivityText(value: string): string {
+  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: unknown): value is ActivityMetrics {
+  return record(value) && [value.elapsedMs, value.tokens].every(n => n === undefined || (Number.isSafeInteger(n) && (n as number) >= 0))
+}
+function validTask(value: unknown): value is ActivityTask {
+  return record(value) && identity(value.planId) && identity(value.id) && TASK_STATUSES.includes(value.status as ActivityTask["status"])
+}
+function normalizeSnapshot(input: unknown): ActivitySnapshot | undefined {
+  if (!record(input) || !Number.isSafeInteger(input.revision) || (input.revision as number) < 0 ||
+    !Number.isSafeInteger(input.omitted) || (input.omitted as number) < 0 ||
+    !["spinner", "static"].includes(input.motion as string) || !["icons", "plain"].includes(input.format as string) ||
+    !Array.isArray(input.rows) || input.rows.length > 64) return
+  const rows: ActivityRow[] = []
+  const parents = new Map<string, string | undefined>()
+  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 as ActivityState) ||
+      (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 as string | undefined)
+    rows.push(Object.freeze({ key: item.key, agent: cleanActivityText(item.agent), state: item.state as ActivityState,
+      text: cleanActivityText(item.text), ...(item.parentKey === undefined ? {} : { parentKey: item.parentKey as string }),
+      ...(item.metrics === undefined ? {} : { metrics: Object.freeze({ elapsedMs: (item.metrics as ActivityMetrics).elapsedMs, tokens: (item.metrics as ActivityMetrics).tokens }) }),
+      ...(item.task === undefined ? {} : { task: Object.freeze({ planId: (item.task as ActivityTask).planId, id: (item.task as ActivityTask).id, status: (item.task as ActivityTask).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 as number, rows: Object.freeze(rows), omitted: input.omitted as number,
+    motion: input.motion as ActivitySnapshot["motion"], format: input.format as ActivitySnapshot["format"] })
+}
+
+function createFooterSlot<T extends { revision: number }>(normalize: (input: unknown) => T | undefined, initialSessionId: string | null) {
+  let sessionId = initialSessionId
+  let owner: symbol | undefined
+  let snapshot: T | undefined
+  const observers = new Set<() => void>()
+  const notify = () => {
+    for (const observer of [...observers]) {
+      try { observer() } catch { /* A disposed UI must not invalidate a successful publish. */ }
+    }
+  }
+  return {
+    read: () => snapshot,
+    subscribe(observer: () => void) { observers.add(observer); return () => { observers.delete(observer) } },
+    reset(nextSessionId: string | null) {
+      sessionId = nextSessionId; owner = undefined; snapshot = undefined; notify()
+    },
+    register(input: unknown): RegistrationResult {
+      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: unknown) {
+          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: string | null = 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: () => void) {
+      const offActivity = activity.subscribe(observer), offSummary = summary.subscribe(observer)
+      return () => { offActivity(); offSummary() }
+    },
+    reset(sessionId: string | null) { activity.reset(sessionId); summary.reset(sessionId) },
+  }
+}
+export type FooterContributions = ReturnType<typeof createFooterContributions>

package/src/footer-plan.ts

@@ -0,0 +1,44 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui"
+import type { ActivityTheme } from "./footer-activity-details.js"
+
+export type PlanSnapshot = Readonly<{
+  revision: number
+  format: "icons" | "plain"
+  plan?: Readonly<{ id: string; accepted: number; total: number; inReview: number; blocked: number }>
+}>
+function record(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+const count = (value: unknown): value is number => Number.isSafeInteger(value) && (value as number) >= 0
+
+export function normalizePlanSnapshot(value: unknown): PlanSnapshot | undefined {
+  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: PlanSnapshot | undefined, width: number, theme: ActivityTheme): string[] {
+  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/src/footer.ts

@@ -3,6 +3,10 @@ import { keyHint } from "@earendil-works/pi-coding-agent"
 import { truncateToWidth } from "@earendil-works/pi-tui"
 import * as chrome from "./chrome.js"
 import { formatTrackerLines } from "./tracker.js"
+import type { FooterContributions } from "./footer-contributions.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 = (): number => (typeof chrome.chromeMargin === "function" ? chrome.chromeMargin() : (chrome.CHROME_MARGIN ?? 1))
@@ -30,11 +34,34 @@ export function footerHints(sources: FooterSources, hints: string[]): string[] {
   return out
 }
 
-export function installFooter(ctx: ExtensionContext, sources: FooterSources): void {
+export function installFooter(ctx: ExtensionContext, sources: FooterSources, contributions?: FooterContributions): () => void {
+  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: number): string[] {
         const inner = Math.max(8, width - margin() * 2)
@@ -48,11 +75,20 @@ export function installFooter(ctx: ExtensionContext, sources: FooterSources): vo
           const line = theme.fg("dim", hints.join("  ·  "))
           out.push(`${" ".repeat(margin())}${truncateToWidth(line, inner, "")}`)
         }
-        for (const extra of formatTrackerLines(ctx, theme as { fg: (name: string, s: string) => string })) {
-          out.push(`${" ".repeat(margin())}${truncateToWidth(extra, 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 as { fg: (name: string, s: string) => string }))
+          .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() }
 }

package/src/index.ts

@@ -2,6 +2,8 @@ import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil
 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, type Sibling } from "./herdr.js"
 import { hideGauntletWidgets } from "./tracker.js"
@@ -21,6 +23,10 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
   installToolRenderers(pi)
   installTranscript(pi)
   installCodeBox()
+  const contributions = createFooterContributions()
+  let stopFooter = () => {}
+  let stopContributionEvents = () => {}
+  let sessionActive = false
   let fastTimer: ReturnType<typeof setInterval> | undefined
   let slowTimer: ReturnType<typeof setInterval> | undefined
   let stealTimer: ReturnType<typeof setInterval> | undefined
@@ -124,11 +130,12 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
   }
 
   const installChromeFooter = (ctx: ExtensionContext) => {
-    installFooter(ctx, {
+    stopFooter()
+    stopFooter = installFooter(ctx, {
       busy: () => busy,
       editorText: () => (typeof ctx.ui.getEditorText === "function" ? ctx.ui.getEditorText() : ""),
       contextPct: () => contextPct(ctx),
-    })
+    }, contributions)
   }
 
   const installStatusLine = (ctx: ExtensionContext) => {
@@ -147,6 +154,11 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
   }
 
   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({
       agentDir: getAgentDir(),
@@ -168,8 +180,12 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
     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)
     }
@@ -195,6 +211,9 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
   })
 
   pi.on("session_shutdown", async () => {
+    sessionActive = false
+    stopFooter()
+    stopContributionEvents()
     busy = false
     stopTimers()
     stopWorkingStatus()

package/test/footer-activity.test.ts

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { visibleWidth } from "@earendil-works/pi-tui"
+import { renderFooterActivity, activityNeedsAnimation } from "../src/footer-activity.js"
+import { ACTIVITY_STATES, type ActivitySnapshot } from "../src/footer-contributions.js"
+
+const theme = { fg: (_color: string, text: string) => text }
+const snapshot = (): ActivitySnapshot => ({ revision: 0, rows: [{ key: "1", agent: "worker", state: "running", text: "Last: tests" }], omitted: 0, motion: "spinner", format: "icons" })
+
+test("matches pi-minimal spinner/check/failure and explicit other state glyphs", () => {
+  const glyphs = ["○", "◐", "!", "Ⅱ", "!", "✓", "✗", "⊘", "?"]
+  for (const [i, state] of ACTIVITY_STATES.entries()) {
+    const input = { ...snapshot(), rows: [{ ...snapshot().rows[0], state }] }
+    const [line] = renderFooterActivity(input, 80, theme, 0)
+    assert.ok(line.startsWith(glyphs[i]+" "), line)
+    const plain = renderFooterActivity({ ...input, format: "plain" }, 80, theme, 1)[0]
+    assert.ok(plain.includes(`[${state}]`))
+  }
+  assert.ok(renderFooterActivity(snapshot(), 80, theme, 1)[0].startsWith("◓"))
+  assert.ok(renderFooterActivity({ ...snapshot(), motion: "static" }, 80, theme, 1)[0].startsWith("◐"))
+})
+
+test("caps rows, reports overflow, and only animates visible running rows", () => {
+  const rows = Array.from({ length: 6 }, (_, i) => ({ key: `${i}`, agent: "agent", state: "completed" as const, text: "Done" }))
+  const input: ActivitySnapshot = { ...snapshot(), rows, omitted: 2 }
+  const lines = renderFooterActivity(input, 80, theme)
+  assert.equal(lines.length, 5)
+  assert.ok(lines[4].includes("4 more"))
+  assert.equal(activityNeedsAnimation(input), false)
+  assert.equal(activityNeedsAnimation({ ...input, rows: [...rows, snapshot().rows[0]] }), false)
+  assert.equal(activityNeedsAnimation(snapshot()), true)
+  assert.equal(activityNeedsAnimation({ ...snapshot(), format: "plain" }), false)
+  assert.equal(activityNeedsAnimation({ ...snapshot(), motion: "static" }), false)
+  assert.deepEqual(renderFooterActivity(undefined, 80, theme), [])
+  assert.deepEqual(renderFooterActivity({ ...snapshot(), rows: [] }, 80, theme), [])
+})
+
+test("bounds Unicode visible widths, strips controls, and limits nested indentation", () => {
+  const input: ActivitySnapshot = { ...snapshot(), rows: [{ key: "p", agent: "工人👩‍💻é", state: "running", text: "\u001b[31mhello\nworld\u001b[0m" },
+    { key: "c", parentKey: "p", agent: "child", state: "running", text: "test" }] }
+  for (const width of [0, 1, 2, 20, 60, 80, 120]) {
+    for (const format of ["icons", "plain"] as const) {
+      for (const line of renderFooterActivity({ ...input, format }, width, theme)) {
+        assert.ok(visibleWidth(line) <= width, `${width}: ${line}`)
+        assert.ok(!line.includes("\n") && !line.includes("\u001b[31m"))
+        // pi-tui adds its own safe SGR reset when truncating plain text.
+        assert.ok(!line.replaceAll("\u001b[0m", "").includes("\u001b"))
+      }
+    }
+  }
+  assert.ok(renderFooterActivity(input, 80, theme)[1].startsWith("  ◐"))
+})
+
+test("right-aligns metrics and drops tokens then time before truncating activity", () => {
+  const input: ActivitySnapshot = { ...snapshot(), rows: [{ ...snapshot().rows[0], metrics: { elapsedMs: 134000, tokens: 8200 }, task: { planId: "P12", id: "T3", status: "in_progress" } }] }
+  const full = renderFooterActivity(input, 80, theme)[0]
+  assert.ok(full.includes("T3 · Last: tests"))
+  assert.ok(full.endsWith("2m 14s · 8.2k tok"))
+  assert.equal(visibleWidth(full), 80)
+  const timeOnly = renderFooterActivity(input, 40, theme)[0]
+  assert.ok(timeOnly.endsWith("2m 14s"), timeOnly)
+  assert.ok(!timeOnly.includes("tok"))
+  const narrow = renderFooterActivity(input, 30, theme)[0]
+  assert.ok(narrow.includes("T3 · Last: tests"))
+  assert.ok(!narrow.includes("2m"))
+})
+
+test("missing metrics are not zero and completed elapsed values do not advance", () => {
+  const input: ActivitySnapshot = { ...snapshot(), rows: [{ ...snapshot().rows[0], state: "completed", metrics: {} }] }
+  assert.ok(renderFooterActivity(input, 80, theme)[0].endsWith("— · — tok"))
+  const ended: ActivitySnapshot = { ...input, rows: [{ ...input.rows[0], metrics: { elapsedMs: 66000, tokens: 0 } }] }
+  assert.ok(renderFooterActivity(ended, 80, theme, 0)[0].endsWith("1m 06s · 0 tok"))
+  assert.equal(renderFooterActivity(ended, 80, theme, 0)[0], renderFooterActivity(ended, 80, theme, 1)[0])
+})
+
+test("task status is independent of agent status and plain mode keeps task labels", () => {
+  for (const [status, marker] of [["blocked", "!"], ["in_review", "◇"], ["done", "✓"]] as const) {
+    const input: ActivitySnapshot = { ...snapshot(), rows: [{ ...snapshot().rows[0], state: "completed", task: { planId: "P12", id: "T3", status } }] }
+    assert.ok(renderFooterActivity(input, 80, theme)[0].includes(`${marker} T3`))
+    const plain = renderFooterActivity({ ...input, format: "plain" }, 100, theme)[0]
+    assert.ok(plain.includes(`[${status}] T3`))
+    assert.ok(plain.includes("[completed]"))
+  }
+})
+
+test("uses current semantic theme and never caches colored text", () => {
+  const colors: string[] = []
+  const themed = { fg: (color: string, text: string) => { colors.push(color); return text } }
+  renderFooterActivity(snapshot(), 80, themed)
+  assert.ok(colors.includes("warning"))
+  const changed = renderFooterActivity(snapshot(), 80, { fg: (_c, text) => `<${text}>` })
+  assert.ok(changed[0].includes("<◐>"))
+})