pi-minimal 0.2.2 → 0.3.0

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/src/tools.ts

@@ -1,7 +1,8 @@
 import type { ExtensionAPI, Theme, ToolRenderers } from "@earendil-works/pi-coding-agent"
-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, type NestedCall } from "./codemode-rows.js"
 import { createLiveWatch } from "./live-watch.js"
 import {
 
@@ -203,6 +204,141 @@ export function compactRenderers(kind: ToolKind): ToolRenderers {
   }
 }
 
+/** 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
+
+type CodemodeState = RowState & { calls?: NestedCall[]; output?: string; code?: string }
+
+function nestedGlyph(call: NestedCall, frame: 0 | 1): { glyph: string; color: "error" | "warning" | "success" | "dim" } {
+	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: string, width: number, theme: Theme, indent: string, label?: string): string[] {
+	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(): ToolRenderers {
+	return {
+		renderShell: "self",
+		renderCall(args, theme, rawContext) {
+			const context = rawContext as RenderContext & { state: CodemodeState }
+			const code = typeof (args as { code?: unknown })?.code === "string" ? ((args as { code: string }).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: number): string[] {
+					const state = context.state
+					const status: RowStatus = 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 as RenderContext & { state: CodemodeState }
+			const typed = result as ToolResultLike
+			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 as RenderOptions).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: number): string[] {
+						const lines: string[] = []
+						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.
@@ -210,6 +346,7 @@ export function compactRenderers(kind: ToolKind): ToolRenderers {
 export function installToolRenderers(pi: ExtensionAPI): void {
   if (typeof pi.registerToolRenderer !== "function") return
   pi.registerToolRenderer((toolName, next) => {
+    if (toolName === "codemode") return codemodeRenderers()
     if (!isToolKind(toolName)) return next()
     return compactRenderers(toolName)
   })

package/test/codemode-rows.test.ts

@@ -0,0 +1,61 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { callSummary, codemodeOutcome, nestedCalls, nestedItem, parseArgs, scriptOutput } from "../src/codemode-rows.js"
+
+const result = (text: string, calls: unknown[] = []) => ({
+	content: [
+		{ type: "text", text: "Script completed\nWall time 1.2 seconds\nOutput:\n" },
+		{ type: "text", text },
+	],
+	details: { calls },
+})
+
+test("parseArgs reads complete JSON and recovers keys from a preview cut at 200 chars", () => {
+	assert.deepEqual(parseArgs('{"action":"update","index":6}'), { action: "update", index: 6 })
+	const cut = '{"command":"cd ~/repo && sed -n 168,180p docs/a.md && echo \\"===\\" && rg -n x docs/b.md | sed -n 1,30p && ech...'
+	assert.equal(parseArgs(cut).command, 'cd ~/repo && sed -n 168,180p docs/a.md && echo "===" && rg -n x docs/b.md | sed -n 1,30p && ech...')
+	assert.deepEqual(parseArgs(""), {})
+	assert.deepEqual(parseArgs("[1,2]"), {})
+	// A cut inside an escape must not throw.
+	assert.equal(typeof parseArgs('{"command":"echo \\').command, "string")
+})
+
+test("nestedItem reads built-ins like their top-level rows and others as key=value", () => {
+	assert.equal(nestedItem({ name: "bash", args: '{"command":"git status\\ngit diff","timeout":10}' }), "git status")
+	assert.equal(nestedItem({ name: "read", args: '{"path":"/a/b/c/file.ts"}' }), "c/file.ts")
+	assert.equal(
+		nestedItem({ name: "plan_tracker", args: '{"action":"update","index":6,"status":"complete"}' }),
+		"action=update index=6 status=complete",
+	)
+	assert.equal(nestedItem({ name: "mcp__x__q", args: '{"query":"a","nested":{"b":1},"limit":5,"extra":1,"more":2}' }), "query=a limit=5 extra=1")
+	assert.equal(nestedItem({ name: "subagents_enable", args: "{}" }), "")
+})
+
+test("callSummary names tools in first-call order with repeat counts", () => {
+	assert.equal(callSummary([]), "script")
+	assert.equal(callSummary([{ name: "bash" }]), "1 call · bash")
+	assert.equal(
+		callSummary([{ name: "plan_tracker" }, { name: "plan_tracker" }, { name: "bash" }]),
+		"3 calls · plan_tracker ×2, bash",
+	)
+})
+
+test("scriptOutput drops pi-core's script header; nestedCalls tolerates missing details", () => {
+	assert.equal(scriptOutput(result("hello\n")), "hello")
+	assert.deepEqual(nestedCalls({ content: [] }), [])
+	assert.deepEqual(nestedCalls({ content: [], details: { calls: [null, { name: "bash" }] } }), [{ name: "bash" }])
+})
+
+test("codemodeOutcome counts output lines and surfaces the first failure", () => {
+	assert.deepEqual(codemodeOutcome(result("a\nb\n\nc"), false, 1200), { text: "3 lines · 1.2s", failed: false })
+	assert.deepEqual(codemodeOutcome(result(""), false, 300), { text: "ok · 0.3s", failed: false })
+	const failed = codemodeOutcome(
+		result("TEST_EXIT=1", [{ name: "bash", status: "ok" }, { name: "bash", status: "error", error: "\nboom: exit 2\nmore" }]),
+		false,
+		274_000,
+	)
+	assert.deepEqual(failed, { text: "1 failed · 4m 34s", failed: true, errorLine: "boom: exit 2" })
+	const scriptError = codemodeOutcome(result("partial\nScript error: ReferenceError: x is not defined"), true, 50)
+	assert.equal(scriptError.failed, true)
+	assert.equal(scriptError.errorLine, "ReferenceError: x is not defined")
+})