pi-minimal 0.2.2 → 0.3.0

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";
@@ -20,6 +22,10 @@ export default function piMinimalExtension(pi) {
     installToolRenderers(pi);
     installTranscript(pi);
     installCodeBox();
+    const contributions = createFooterContributions();
+    let stopFooter = () => { };
+    let stopContributionEvents = () => { };
+    let sessionActive = false;
     let fastTimer;
     let slowTimer;
     let stealTimer;
@@ -128,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, {
@@ -149,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({
@@ -172,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);
         }
@@ -197,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,6 +1,7 @@
-import { Container, truncateToWidth } from "@earendil-works/pi-tui";
+import { Container, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { rowIsRunning } from "./activity.js";
 import * as chrome from "./chrome.js";
+import { callSummary, codemodeOutcome, nestedCalls, nestedItem, scriptOutput } from "./codemode-rows.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. */
@@ -157,6 +158,141 @@ export function compactRenderers(kind) {
         },
     };
 }
+/** Max nested calls shown under a collapsed codemode row; the rest are counted. */
+const NESTED_PREVIEW = 8;
+/** Width of the nested tool-name column. */
+const NESTED_NAME_MAX = 14;
+function nestedGlyph(call, frame) {
+    if (call.status === "running")
+        return { glyph: rowGlyph("running", frame), color: "warning" };
+    if (call.status === "error")
+        return { glyph: "\u2717", color: "error" };
+    if (call.status === "cancelled")
+        return { glyph: "\u2298", color: "dim" };
+    return { glyph: "\u2713", color: "success" };
+}
+/** Lines of a `\u2502`-ruled block, dim and truncated, for script source or output on expand. */
+function ruledLines(text, width, theme, indent, label) {
+    const inner = Math.max(0, width - indent.length - 2);
+    const rule = theme.fg("borderMuted", "\u2502");
+    let lines = text.split("\n");
+    if (lines.length > EXPANDED_MAX_LINES)
+        lines = [...lines.slice(0, EXPANDED_MAX_LINES), `\u2026 ${lines.length - EXPANDED_MAX_LINES} more lines`];
+    const out = label ? [`${indent}${rule} ${theme.fg("dim", truncateToWidth(label, inner))}`] : [];
+    return out.concat(lines.map((line) => `${indent}${rule} ${theme.fg("dim", truncateToWidth(line, inner))}`));
+}
+/**
+ * codemode as a tool row: `\u2713 code  3 calls \u00b7 plan_tracker \u00d72, bash \u2026 54 lines \u00b7 1.2s`, then one
+ * child row per nested call. The script and its output appear only when expanded, undecorated,
+ * so syntax colours never compete with status colours in the transcript.
+ */
+export function codemodeRenderers() {
+    return {
+        renderShell: "self",
+        renderCall(args, theme, rawContext) {
+            const context = rawContext;
+            const code = typeof args?.code === "string" ? (args.code) : "";
+            context.state.code = code;
+            const id = context.toolCallId || "codemode";
+            const running = rowIsRunning(context);
+            context.state.running = running;
+            if (running) {
+                context.state.startedAt ??= Date.now();
+                live.watch(id, context.invalidate);
+            }
+            else
+                live.unwatch(id);
+            return {
+                render(width) {
+                    const state = context.state;
+                    const status = state.outcome?.errorLine !== undefined || context.isError ? "error" : rowIsRunning(context) ? "running" : "ok";
+                    const frame = status === "running" && live.has(id) ? live.frame : 0;
+                    const calls = state.calls ?? [];
+                    const right = status === "running" ? (state.startedAt ? formatDuration(Date.now() - state.startedAt) : "") : (state.outcome?.text ?? "");
+                    const inner = Math.max(8, width - rowIndent());
+                    const row = layoutRow(inner, "code", callSummary(calls), right);
+                    const rightColor = status === "running" ? "warning" : status === "error" ? "error" : "dim";
+                    const lines = [
+                        " ".repeat(rowIndent()) +
+                            theme.fg(statusColor(status), rowGlyph(status, frame)) +
+                            " " +
+                            theme.fg("dim", row.verb) +
+                            " " +
+                            theme.fg(status === "error" ? "text" : "muted", row.item) +
+                            " ".repeat(row.gap) +
+                            theme.fg(rightColor, row.outcome),
+                    ];
+                    const expanded = Boolean(context.expanded);
+                    const shown = expanded ? calls : calls.slice(-NESTED_PREVIEW);
+                    const childIndent = " ".repeat(rowIndent() + 4);
+                    if (shown.length < calls.length) {
+                        lines.push(`${childIndent}${theme.fg("dim", `\u2026 ${calls.length - shown.length} earlier calls`)}`);
+                    }
+                    const nameWidth = Math.min(NESTED_NAME_MAX, Math.max(0, ...shown.map((call) => (call.name ?? "tool").length)));
+                    for (const call of shown) {
+                        const { glyph, color } = nestedGlyph(call, frame);
+                        const name = truncateToWidth(call.name ?? "tool", nameWidth, "\u2026").padEnd(nameWidth);
+                        const dur = call.status === "error" ? `failed \u00b7 ${formatDuration(call.durationMs)}` : formatDuration(call.durationMs);
+                        const room = Math.max(8, width - childIndent.length);
+                        // Reuse the row grid with the name as the "verb" column, then fix the glyph slot.
+                        const prefixWidth = 2 + nameWidth + 1;
+                        const itemRoom = Math.max(0, room - prefixWidth - (dur ? visibleWidth(dur) + 2 : 0));
+                        const item = truncateToWidth(nestedItem(call), itemRoom, "\u2026");
+                        const gap = dur ? Math.max(2, room - prefixWidth - visibleWidth(item) - visibleWidth(dur)) : 0;
+                        lines.push(childIndent +
+                            theme.fg(color, glyph) +
+                            " " +
+                            theme.fg("dim", name) +
+                            " " +
+                            theme.fg(call.status === "error" ? "text" : "muted", item) +
+                            " ".repeat(gap) +
+                            theme.fg(call.status === "error" ? "error" : "dim", dur));
+                    }
+                    return lines;
+                },
+                invalidate() { },
+            };
+        },
+        renderResult(result, options, theme, rawContext) {
+            const context = rawContext;
+            const typed = result;
+            context.state.calls = nestedCalls(typed);
+            if (!context.isPartial) {
+                context.state.done = true;
+                context.state.running = false;
+                const outcome = codemodeOutcome(typed, Boolean(context.isError), context.durationMs);
+                context.state.outcome = { text: outcome.text, errorLine: outcome.failed ? (outcome.errorLine ?? "") : undefined };
+                context.state.output = scriptOutput(typed);
+                live.unwatch(context.toolCallId || "codemode");
+            }
+            // No invalidate here: the host runs renderCall and renderResult in one updateDisplay() and
+            // paints afterwards, so the call row's lazy render() already sees these calls. Calling
+            // invalidate() would re-enter updateDisplay() and recurse.
+            const container = new Container();
+            const expanded = Boolean(options.expanded);
+            const errorLine = context.state.outcome?.errorLine;
+            if (errorLine && !expanded)
+                container.addChild(errorLineBlock(errorLine, theme));
+            if (expanded) {
+                const indent = " ".repeat(rowIndent() + 4);
+                const code = context.state.code ?? "";
+                const output = context.state.output ?? "";
+                container.addChild({
+                    render(width) {
+                        const lines = [];
+                        if (code)
+                            lines.push(...ruledLines(code.trimEnd(), width, theme, indent, `// script \u00b7 ${code.trimEnd().split("\n").length} lines`));
+                        if (output)
+                            lines.push(...ruledLines(output, width, theme, indent, "// output"));
+                        return lines;
+                    },
+                    invalidate() { },
+                });
+            }
+            return container;
+        },
+    };
+}
 /**
  * Attach the compact renderers to the built-in tools without re-registering them. Registered at
  * extension load so a resumed transcript draws its earlier tool calls the same way as new ones.
@@ -165,6 +301,8 @@ export function installToolRenderers(pi) {
     if (typeof pi.registerToolRenderer !== "function")
         return;
     pi.registerToolRenderer((toolName, next) => {
+        if (toolName === "codemode")
+            return codemodeRenderers();
         if (!isToolKind(toolName))
             return next();
         return compactRenderers(toolName);

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.2",
+  "version": "0.3.0",
   "license": "MIT",
   "type": "module",
   "private": false,

package/release-notes.md

@@ -1,32 +1,32 @@
 ### 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.
+- `codemode` renders as a tool row: `✓ code  3 calls · plan_tracker ×2, bash … 54 lines · 1.2s`,
+  with one child row per nested call. Built-in tools inside a script read exactly like their
+  top-level rows (`bash` shows its command); other tools show up to three scalar arguments as
+  `key=value` instead of raw JSON. Children update live while the script runs. The script source
+  and output appear only on `ctrl+o`, in plain dim text, so syntax colours no longer compete with
+  status colours. A failed nested call or script error shows its first line under the row, like
+  `bash`. Previously codemode fell through to pi-core's default panel: a background slab with the
+  highlighted script, JSON arguments, an output preview and a `Took …` timer.
 
 ### 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.
+- `minimal-dark` contrast: `dim` (verbs, outcomes, tool output) L 48 % → 56 % and `thinkingText`
+  52 % → 58 %, estimated ~3.1:1 → ~4.4:1 and ~3.7:1 → ~4.8:1 on the background. They were within
+  4 % of each other and below WCAG's 4.5:1 text target. `faint` 34 % → 36 %.
+- `minimal-dark` keeps syntax colours off the status hues: `syntaxFunction` was warning-yellow
+  (now lavender) and `syntaxNumber` was success-green (now teal), so code no longer looks like a
+  spinner or a check mark.
+- `minimal-dark` draws no background behind pending/successful tool output (`toolPendingBg`,
+  `toolSuccessBg` → `bg`). Tools pi-minimal does not restyle yet (`subagent`, MCP tools) lose
+  their slab; failures keep `toolErrorBg`.
 
 ## 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: render codemode as a tool row; raise minimal-dark contrast (0.3.0) by @raviy06 in https://github.com/raviy06/pi-minimal/pull/15
 
 
-**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.3...v0.3.0
 
 ---
 **Install / upgrade**
 ```bash
-pi install npm:pi-minimal@0.2.2   # or: pi update --extensions
+pi install npm:pi-minimal@0.3.0   # or: pi update --extensions
 ```

package/src/codemode-rows.ts

@@ -0,0 +1,121 @@
+import { firstLine, formatDuration, resultText, toolItem, type ToolKind, type ToolResultLike } from "./tool-rows.js"
+
+/** Mirrors pi-core's `CodemodeNestedCall`; every field is optional so older hosts degrade quietly. */
+export type NestedCall = {
+	id?: string
+	name?: string
+	/** Compact JSON of the arguments, truncated by the host at 200 chars (may not parse). */
+	args?: string
+	status?: "running" | "ok" | "error" | "cancelled"
+	durationMs?: number
+	error?: string
+	cost?: number
+}
+
+const KINDS: ReadonlySet<string> = new Set<ToolKind>(["bash", "read", "edit", "write", "grep", "find", "ls"])
+const SCRIPT_HEADER = /^Script (?:completed|failed)\nWall time [\d.]+ seconds\nOutput:\n?/
+/** Argument keys toolItem() reads, in the order it prefers them. */
+const ITEM_KEYS = ["command", "path", "file_path", "target_directory", "pattern"] as const
+
+export function nestedCalls(result: ToolResultLike | undefined): NestedCall[] {
+	const calls = (result?.details as { calls?: unknown } | undefined)?.calls
+	if (!Array.isArray(calls)) return []
+	return calls.filter((call): call is NestedCall => Boolean(call) && typeof call === "object")
+}
+
+/** Script output without pi-core's "Script completed / Wall time / Output:" header. */
+export function scriptOutput(result: ToolResultLike | undefined): string {
+	return resultText(result).replace(SCRIPT_HEADER, "").trim()
+}
+
+/**
+ * Parse the host's argument preview. Complete JSON parses directly; a preview cut at 200 chars
+ * still yields the first string value of each known key, which is all a one-line row needs.
+ */
+export function parseArgs(args: string | undefined): Record<string, unknown> {
+	if (!args) return {}
+	try {
+		const value = JSON.parse(args) as unknown
+		return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {}
+	} catch {
+		const out: Record<string, unknown> = {}
+		const pair = /"([A-Za-z_$][\w$]*)":(?:"((?:[^"\\]|\\.)*)"?|(-?\d+(?:\.\d+)?|true|false|null))/g
+		for (const m of args.matchAll(pair)) {
+			if (m[1] in out) continue
+			if (m[2] !== undefined) out[m[1]] = unescape(m[2])
+			else if (m[3] !== undefined) out[m[1]] = JSON.parse(m[3])
+		}
+		return out
+	}
+}
+
+function unescape(raw: string): string {
+	// A cut can land inside an escape; drop a dangling backslash so JSON.parse accepts the rest.
+	const safe = raw.replace(/\\(u[0-9a-fA-F]{0,3})?$/, "")
+	try {
+		return JSON.parse(`"${safe}"`) as string
+	} catch {
+		return safe
+	}
+}
+
+function scalar(value: unknown): string | undefined {
+	if (typeof value === "string") return value.split("\n")[0]?.trim()
+	if (typeof value === "number" || typeof value === "boolean") return String(value)
+	return undefined
+}
+
+/**
+ * The item column of a nested call. Built-in tools read exactly like their top-level rows
+ * (`bash` shows its command, `read` a short path). Other tools show up to three scalar
+ * arguments as `key=value`, strings unquoted, instead of raw JSON.
+ */
+export function nestedItem(call: NestedCall): string {
+	const name = call.name ?? "tool"
+	const args = parseArgs(call.args)
+	if (KINDS.has(name)) {
+		const picked: Record<string, unknown> = {}
+		for (const key of ITEM_KEYS) if (key in args) picked[key] = args[key]
+		return toolItem(name as ToolKind, picked)
+	}
+	const parts: string[] = []
+	for (const [key, value] of Object.entries(args)) {
+		const shown = scalar(value)
+		if (shown === undefined || shown === "") continue
+		parts.push(`${key}=${shown}`)
+		if (parts.length === 3) break
+	}
+	return parts.join(" ")
+}
+
+/** `3 calls · plan_tracker ×2, bash` — names in first-call order with repeat counts. */
+export function callSummary(calls: readonly NestedCall[]): string {
+	if (calls.length === 0) return "script"
+	const counts = new Map<string, number>()
+	for (const call of calls) counts.set(call.name ?? "tool", (counts.get(call.name ?? "tool") ?? 0) + 1)
+	const names = [...counts].map(([name, n]) => (n > 1 ? `${name} ×${n}` : name)).join(", ")
+	return `${calls.length} call${calls.length === 1 ? "" : "s"} · ${names}`
+}
+
+export type CodemodeOutcome = { text: string; failed: boolean; errorLine?: string }
+
+/** Right-hand outcome of the parent row, and the line shown under it when something failed. */
+export function codemodeOutcome(
+	result: ToolResultLike | undefined,
+	isError: boolean,
+	durationMs: number | undefined,
+): CodemodeOutcome {
+	const calls = nestedCalls(result)
+	const output = scriptOutput(result)
+	const failedCalls = calls.filter((call) => call.status === "error")
+	const dur = formatDuration(durationMs)
+	const join = (...parts: string[]) => parts.filter(Boolean).join(" · ")
+	if (isError || failedCalls.length > 0) {
+		const label = failedCalls.length > 0 ? `${failedCalls.length} failed` : "failed"
+		const scriptError = /Script error:\s*(.*)/.exec(output)?.[1]
+		const errorLine = firstLine(failedCalls[0]?.error ?? "") ?? scriptError ?? firstLine(output)
+		return { text: join(label, dur), failed: true, errorLine }
+	}
+	const lines = output ? output.split("\n").filter((line) => line.length > 0).length : 0
+	return { text: join(lines === 0 ? "ok" : `${lines} line${lines === 1 ? "" : "s"}`, dur), failed: false }
+}

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