pi-minimal 0.2.1 → 0.2.3

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

@@ -1,8 +1,16 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
 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 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))
+
 
 export type FooterSources = {
   /** True while an agent run is in progress. */
@@ -26,14 +34,37 @@ 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 - CHROME_MARGIN * 2)
+        const inner = Math.max(8, width - margin() * 2)
         const out: string[] = []
         const hints = footerHints(sources, [
           keyHint("tui.input.submit", "send"),
@@ -42,13 +73,22 @@ export function installFooter(ctx: ExtensionContext, sources: FooterSources): vo
         ].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 as { fg: (name: string, s: string) => string })) {
-          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 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"
@@ -11,12 +13,20 @@ 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: ExtensionAPI): void {
   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: ReturnType<typeof setInterval> | undefined
   let slowTimer: ReturnType<typeof setInterval> | undefined
   let stealTimer: ReturnType<typeof setInterval> | undefined
@@ -120,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) => {
@@ -143,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(),
@@ -151,6 +167,12 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
     })
     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)
@@ -158,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)
     }
@@ -185,6 +211,9 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
   })
 
   pi.on("session_shutdown", async () => {
+    sessionActive = false
+    stopFooter()
+    stopContributionEvents()
     busy = false
     stopTimers()
     stopWorkingStatus()

package/src/tools.ts

@@ -1,8 +1,10 @@
 import type { ExtensionAPI, Theme, ToolRenderers } from "@earendil-works/pi-coding-agent"
 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,
@@ -17,6 +19,9 @@ import {
   type ToolResultLike,
 } from "./tool-rows.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))
+
 type RenderOptions = {
   expanded?: boolean
 }
@@ -42,8 +47,8 @@ type RenderContext = {
 
 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
 
@@ -82,7 +87,7 @@ function expandedLines(kind: ToolKind, result: ToolResultLike | undefined): stri
 function outputBlock(kind: ToolKind, result: ToolResultLike | undefined, theme: 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: number): string[] {
@@ -95,7 +100,7 @@ function outputBlock(kind: ToolKind, result: ToolResultLike | undefined, theme:
 
 function errorLineBlock(line: string | undefined, theme: Theme) {
   if (!line) return undefined
-  const indent = " ".repeat(ROW_INDENT + 2)
+  const indent = " ".repeat(rowIndent() + 2)
   const rule = theme.fg("error", "│")
   return {
     render(width: number): string[] {
@@ -135,7 +140,7 @@ function activityRow(kind: ToolKind, args: ToolArgs | undefined, theme: Theme, c
           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: string
@@ -148,7 +153,7 @@ function activityRow(kind: ToolKind, args: ToolArgs | undefined, theme: Theme, c
       } else coloredRight = theme.fg("dim", row.outcome)
 
       const line =
-        " ".repeat(ROW_INDENT) +
+        " ".repeat(rowIndent()) +
         theme.fg(statusColor(status), glyph) +
         " " +
         theme.fg("dim", row.verb) +

package/src/turn-rule.ts

@@ -1,8 +1,12 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
 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 = (): number => (typeof chrome.chromeMargin === "function" ? chrome.chromeMargin() : (chrome.CHROME_MARGIN ?? 1))
+
+
 export const TURN_ENTRY_TYPE = "pi-minimal.turn"
 
 export type TurnSummary = {
@@ -83,10 +87,10 @@ export function installTurnRule(pi: ExtensionAPI): () => void {
     const color = entry.data.outcome === "completed" ? "borderMuted" : entry.data.outcome === "aborted" ? "warning" : "error"
     return {
       render(width: number): string[] {
-        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/test/code-box.test.ts

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { Markdown } from "@earendil-works/pi-tui"
+import { frameCodeLines, installCodeBox } from "../src/code-box.js"
+
+const theme = { codeBlockBorder: (s: string) => s }
+const ESC = String.fromCharCode(27)
+const stripAnsi = (s: string) => s.split(ESC).map((p, i) => (i === 0 ? p : p.replace(/^\[[0-9;]*m/, ""))).join("")
+
+test("frameCodeLines replaces fences with a closed box and keeps the trailer", () => {
+	const out = frameCodeLines(["```json", '  {"a":1}', "  ", "```", ""], "json", 20, theme)
+	assert.equal(out.length, 5)
+	assert.ok(out[0].startsWith("╭─ json ─") && out[0].endsWith("╮"))
+	assert.equal(out[1], '│ {"a":1}          │')
+	assert.equal(out[2], "│                  │")
+	assert.ok(out[3].startsWith("╰─") && out[3].endsWith("╯"))
+	for (const l of out.slice(0, 4)) assert.equal(l.length, 20, l)
+	assert.equal(out[4], "")
+})
+
+test("frameCodeLines wraps long lines inside the box", () => {
+	const out = frameCodeLines(["```", "  " + "x".repeat(30), "```"], undefined, 20, theme)
+	assert.equal(out.length, 4, out.join("\n"))
+	assert.equal(out[1], `│ ${"x".repeat(16)} │`)
+	assert.equal(out[2], `│ ${"x".repeat(14)}   │`)
+	for (const l of out) assert.equal(l.length, 20, l)
+})
+
+test("frameCodeLines handles empty blocks and missing language", () => {
+	const out = frameCodeLines(["```", "```"], undefined, 10, theme)
+	assert.deepEqual(out.map((l) => l[0]), ["╭", "│", "╰"])
+	assert.deepEqual(out.map((l) => l[l.length - 1]), ["╮", "│", "╯"])
+	assert.ok(!out[0].includes(" "), "no language label")
+	assert.deepEqual(frameCodeLines(["x"], undefined, 10, theme), ["x"])
+})
+
+test("installCodeBox patches pi-tui's Markdown renderer idempotently", () => {
+	assert.equal(installCodeBox(), true)
+	assert.equal(installCodeBox(), true)
+	// A reload re-points the installed wrapper at the current framer.
+	const slot = Symbol.for("pi-minimal.code-box.frame")
+	const slots = globalThis as unknown as Record<symbol, unknown>
+	assert.equal(slots[slot], frameCodeLines)
+	const id = (s: string) => s
+	const mdTheme = {
+		heading: id, link: id, linkUrl: id, code: id, codeBlock: id, codeBlockBorder: id, quote: id, quoteBorder: id,
+		hr: id, listBullet: id, bold: id, italic: id, underline: id, strikethrough: id,
+	}
+	const md = new Markdown("before\n\n```ts\nconst x = 1\n```\n\nafter", 0, 0, mdTheme as never)
+	const lines = md.render(40).map(stripAnsi)
+	assert.ok(lines.some((l) => l.startsWith("╭─ ts ") && l.endsWith("╮")), lines.join("\n"))
+	assert.ok(lines.some((l) => l.startsWith("│ const x = 1") && l.endsWith("│")), lines.join("\n"))
+	assert.ok(lines.some((l) => l.startsWith("╰─") && l.endsWith("╯")), lines.join("\n"))
+	assert.ok(!lines.some((l) => l.includes("```")), "no literal fences remain")
+})

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("<◐>"))
+})