pi-editor-footer 0.6.2 → 0.8.0

package/CHANGELOG.md

@@ -4,6 +4,34 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.8.0] - 2026-08-26
+
+### Added
+
+- ~ prefix for live estimate — `TurnTelemetry.estimated` and `AgentRunLedger` propagation, `↑ ~1k · ↓ ~2k` and `~42.1 tok/s` while streaming vs authoritative after `turn_end` (#29)
+
+### Changed
+
+- TPS whole-turn stable rate — absorb `pi-core-tps-stats` one-rate `output / turnDuration` (41/14/55 vs window 263/801/89), live and final share denominator, `CONTENT_START_EVENTS` for TTFT, reset on `model_select` (#29)
+- Collapse Agent-run timeline into one seam — `TranscriptTimeline` now owns history, formatting (`buildTimelineText`), injection and rebuild replay; `SessionOrchestrator` wallTimeHistory deleted, seam turns hypothetical → real with two adapters (prod `chatContainer` + in-memory fake) (#23)
+- Prune LiveBorder fallback — `AgentRunLedger` required, 80-line manual delta deleted, single `ChromeComposition` cached per `render()` (#24)
+
+### Fixed
+
+- Delete dead `SessionKernel` (255 lines, 0 adapters) and ghost `liveTickTimer` wrappers — `SessionOrchestrator` calls `LiveBorder.startTick/stopTick` directly (#27)
+- pi-lens `SAFETY` comments for `as unknown as` casts (#29)
+
+### Refactored
+
+- Table-driven config validation — `CONFIG_SCHEMA` single source for defaults + validation; removes 10 `as unknown as` casts, `theme-settings` trusts typed boundaries (#25)
+- Retire TrackingEditor compat wrappers — `setChrome`/`getChrome` is the single interface; 7 wrappers + 2 glow accessors deleted, codemod `LiveBorder`/`SessionOrchestrator` (#26)
+
+## [0.7.0] - 2026-08-25
+
+### Changed
+
+- Deepen architecture — 5 candidates behind single seams: AgentRunLedger owns per-agent capping and max-vs-sum (C2), ChromeComposition centralizes glyph/theme (C3), TurnTelemetryTracker turn-scoped with ledger delegation (C4), DetailChrome owns Highlight→Detail window (C5), SessionOrchestrator owns lifecycle, footer deduplication and detail wiring — `src/index.ts` 899→93 lines, 139 tests (+52) (#20)
+
 ## [0.6.2] - 2026-08-25
 
 ### Fixed

package/dist/agent-run-ledger.js

@@ -0,0 +1,274 @@
+/**
+ * AgentRunLedger — deep module owning per-Agent-run accounting behind one seam.
+ *
+ * Domain: Agent run = agent_start → agent_settled, containing one or more Turns
+ * (CONTEXT.md). Per-agent totals must use max(input) not sum(input) — each Turn's
+ * input is the full prompt (includes history), so summing double-counts overlapping
+ * history (e.g. 50k+60k=110k > window 60k). Output/cost do sum. Live input is window
+ * occupancy, capped to contextWindow and session totals.
+ *
+ * Previously this logic was scattered across 3 call sites (telemetry.peekAgentLive
+ * max-vs-sum, live-border.refreshContextBar 70L capping, index.agent_settled 60L
+ * baseline fallback) with divergent caps. Bugs required holding 3 sites in one head.
+ *
+ * Depth: small interface (setBaseline / startRun / recordTurn / getTotals / getLive
+ * / cap helpers) hides baseline delta, max-vs-sum, predictive vs authoritative capping,
+ * and tps derivation. Two adapters (LiveBorder token bar, index timeline) justify the seam.
+ * Internal seams (aggregateTurns, capIdle, capLive) stay private.
+ */
+function round(value, decimals) {
+    const factor = 10 ** decimals;
+    return Math.round(value * factor) / factor;
+}
+/**
+ * Pure aggregation: max(input) + sum(output/cost/stalls) across turns, plus optional live turn.
+ * Shared by TurnTelemetryTracker.peekAgentLive / endAgent and ledger — single source for
+ * the "max not sum" invariant.
+ */
+export function aggregateAgentTurns(turns, live, startMs, now) {
+    const hasCompleted = turns.length > 0;
+    if (startMs === null) {
+        // No agent active — caller should handle fallback to lastTelemetry/live
+        if (!hasCompleted && !live)
+            return null;
+        // still produce cumulative if we have turns/live but no startMs (defensive)
+    }
+    else if (!hasCompleted && !live) {
+        return null;
+    }
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let totalTokens = 0;
+    let costUsd = 0;
+    let stallMs = 0;
+    let stallCount = 0;
+    let generationMs = 0;
+    let ttftMs = 0;
+    for (const t of turns) {
+        inputTokens = Math.max(inputTokens, t.inputTokens);
+        outputTokens += t.outputTokens;
+        costUsd += t.costUsd;
+        stallMs += t.stallMs;
+        stallCount += t.stallCount;
+        generationMs += t.generationMs;
+    }
+    if (turns.length > 0)
+        ttftMs = turns[0].ttftMs;
+    if (live) {
+        inputTokens = Math.max(inputTokens, live.inputTokens);
+        outputTokens += live.outputTokens;
+        costUsd += live.costUsd;
+        stallMs += live.stallMs;
+        stallCount += live.stallCount;
+        generationMs += live.generationMs;
+        if (ttftMs === 0)
+            ttftMs = live.ttftMs;
+    }
+    totalTokens = inputTokens + outputTokens;
+    const totalMs = startMs !== null ? Math.max(0, now - startMs) : 0;
+    const measurementMs = outputTokens > 0 && generationMs > 0 ? generationMs : null;
+    const tps = measurementMs === null
+        ? null
+        : round(outputTokens / (measurementMs / 1000), 1);
+    const validCost = Number.isFinite(costUsd) && costUsd > 0;
+    const validTokens = Number.isFinite(totalTokens) && totalTokens > 0;
+    return {
+        tps,
+        ttftMs,
+        totalMs,
+        inputTokens,
+        outputTokens,
+        stallMs,
+        stallCount,
+        rateUsdPerMTokens: validCost && validTokens
+            ? round(costUsd / (totalTokens / 1_000_000), 2)
+            : null,
+        generationMs,
+        totalTokens,
+        costUsd: validCost ? costUsd : 0,
+        measurementMs,
+        estimated: live?.estimated === true,
+    };
+}
+/**
+ * Capping helpers — single source for "live input 18k not 279k" invariant.
+ * Idle (settled) input is authoritative, capped to both context window and session total.
+ * Live (running) input is predictive, capped only to context window (not totals) — totals
+ * lag behind liveTurn, capping to totals would make live stale (50k) during second turn
+ * streaming instead of showing current window 60k.
+ */
+export function capInputForIdle(input, contextTokens, sessionTotalInput) {
+    let capped = input;
+    if (typeof contextTokens === "number" &&
+        Number.isFinite(contextTokens) &&
+        contextTokens > 0) {
+        capped = Math.min(capped, contextTokens);
+    }
+    if (sessionTotalInput > 0) {
+        capped = Math.min(capped, sessionTotalInput);
+    }
+    return Math.max(0, capped);
+}
+export function capInputForLive(input, contextTokens) {
+    let capped = input;
+    if (typeof contextTokens === "number" &&
+        Number.isFinite(contextTokens) &&
+        contextTokens > 0) {
+        capped = Math.min(capped, contextTokens);
+    }
+    return Math.max(0, capped);
+}
+/** Delta from baseline totals (session delta), used when telemetry not available. */
+export function deltaFromBaseline(cur, base) {
+    return {
+        input: Math.max(0, cur.input - base.input),
+        output: Math.max(0, cur.output - base.output),
+        cost: Math.max(0, cur.cost - base.cost),
+    };
+}
+export class AgentRunLedger {
+    baseline = null;
+    turns = [];
+    startMs = null;
+    now;
+    constructor(now = () => Date.now()) {
+        this.now = now;
+    }
+    /** Capture baseline at agent_start. Clone to avoid caller mutation. */
+    setBaseline(baseline) {
+        this.baseline = baseline ? { ...baseline } : null;
+    }
+    getBaseline() {
+        return this.baseline ? { ...this.baseline } : null;
+    }
+    startRun(startMs) {
+        this.startMs = typeof startMs === "number" ? startMs : this.now();
+        this.turns = [];
+    }
+    /** Record a completed turn's telemetry (called by telemetryTracker or directly). */
+    recordTurn(turn) {
+        this.turns.push({ ...turn });
+    }
+    /** Settled totals without live turn — used at agent_settled for timeline. */
+    getSettledTotals(now) {
+        const n = typeof now === "number" ? now : this.now();
+        return aggregateAgentTurns(this.turns, null, this.startMs, n);
+    }
+    /** Live totals including optional running turn. */
+    getLiveTotals(liveTurn, now) {
+        const n = typeof now === "number" ? now : this.now();
+        const result = aggregateAgentTurns(this.turns, liveTurn, this.startMs, n);
+        // If no agent active (startMs null) but we have turns/live, aggregateTurns handles it;
+        // otherwise fallback to null.
+        return result;
+    }
+    /**
+     * Timeline/display totals at agent_settled.
+     * Prefers authoritative telemetry (tel) when available; otherwise falls back to
+     * baseline delta; otherwise session totals. Caps idle input to context + session total.
+     * This is the single place that knows the "prefer tel, else delta capped" policy.
+     */
+    getPerAgentTotalsForTimeline(tel, snapshotTotals, contextTokens) {
+        if (tel) {
+            const cappedInput = capInputForIdle(tel.inputTokens, contextTokens, snapshotTotals.input);
+            return {
+                input: cappedInput,
+                output: tel.outputTokens,
+                cost: tel.costUsd,
+            };
+        }
+        if (this.baseline) {
+            const d = deltaFromBaseline(snapshotTotals, this.baseline);
+            const cappedInput = capInputForIdle(d.input, contextTokens, snapshotTotals.input);
+            return { input: cappedInput, output: d.output, cost: d.cost };
+        }
+        // No baseline — best effort session totals capped for input
+        const cappedInput = capInputForIdle(snapshotTotals.input, contextTokens, snapshotTotals.input);
+        return {
+            input: cappedInput,
+            output: snapshotTotals.output,
+            cost: snapshotTotals.cost,
+        };
+    }
+    /**
+     * Idle display totals for LiveBorder when not running.
+     * Prefers liveAgent/liveTelemetry when available; else baseline delta, capped to idle.
+     */
+    getIdleDisplayTotals(snapshotTotals, contextTokens, liveAgent) {
+        let displayInput;
+        let displayOutput;
+        let displayCost;
+        if (liveAgent) {
+            displayInput = liveAgent.inputTokens;
+            displayOutput = liveAgent.outputTokens;
+            displayCost = liveAgent.costUsd;
+        }
+        else if (this.baseline) {
+            const d = deltaFromBaseline(snapshotTotals, this.baseline);
+            displayInput = d.input;
+            displayOutput = d.output;
+            displayCost = d.cost;
+        }
+        else {
+            displayInput = snapshotTotals.input;
+            displayOutput = snapshotTotals.output;
+            displayCost = snapshotTotals.cost;
+        }
+        const cappedInput = capInputForIdle(displayInput, contextTokens, snapshotTotals.input);
+        return {
+            tps: null,
+            ttftMs: 0,
+            totalMs: 0,
+            inputTokens: cappedInput,
+            outputTokens: displayOutput,
+            stallMs: 0,
+            stallCount: 0,
+            rateUsdPerMTokens: null,
+            generationMs: 0,
+            totalTokens: cappedInput + displayOutput,
+            costUsd: displayCost,
+            measurementMs: null,
+            estimated: false,
+        };
+    }
+    /**
+     * Live display totals when running: liveTurn input (current window) replaces
+     * agentLive input, output/cost remain per-agent sum, capped to live context only.
+     */
+    getLiveDisplayTotals(liveTurn, agentLive, contextTokens) {
+        if (!agentLive && !liveTurn)
+            return null;
+        let displayLive = agentLive;
+        if (agentLive && liveTurn) {
+            displayLive = {
+                ...agentLive,
+                inputTokens: liveTurn.inputTokens,
+                totalTokens: liveTurn.inputTokens + agentLive.outputTokens,
+            };
+        }
+        else if (!agentLive && liveTurn) {
+            // Edge: no agent yet but liveTurn exists — use liveTurn window
+            displayLive = liveTurn;
+        }
+        if (!displayLive)
+            return null;
+        const cappedInput = capInputForLive(displayLive.inputTokens, contextTokens);
+        return {
+            ...displayLive,
+            inputTokens: cappedInput,
+            totalTokens: cappedInput + displayLive.outputTokens,
+            estimated: true,
+        };
+    }
+    reset() {
+        this.baseline = null;
+        this.turns = [];
+        this.startMs = null;
+    }
+    isActive() {
+        return this.startMs !== null;
+    }
+    getTurnCount() {
+        return this.turns.length;
+    }
+}

package/dist/chrome-composition.js

@@ -0,0 +1,91 @@
+/**
+ * ChromeComposition — deep module owning chrome glyph/theme derivation behind one seam.
+ *
+ * Problem it solves (C3): glyphs (resolveGlyphs / resolveIconMode) and the live TUI theme
+ * (with its `fg` + optional `getThinkingBorderColor`) were re-derived at every chrome island:
+ * live-border called resolveGlyphs in 3 methods, footer once, and the theme was reached
+ * through ~8 `as unknown as { ... }` SAFETY casts. A changed glyph or a pi theme shape change
+ * thus required touching 3-4 modules with no locality.
+ *
+ * Depth: one small interface (glyphs + isAscii + fg/dim/glow + format* helpers) hides
+ * icon-mode resolution, the SAFETY theme cast, colour application, and the chrome format
+ * entry points (context bar, telemetry, tokens, run activity, stall). Callers learn one
+ * shape; LiveBorder's islands become thin lookups.
+ *
+ * Internal seams (resolveGlyphs, resolveIconMode, formatTurnTelemetry, formatTelemetryTokens,
+ * formatRunActivityTopRight, formatTopContextFromSnapshot) stay inside this module, not part
+ * of its external seam. Two adapters (LiveBorder live chrome, footer/border elsewhere)
+ * justify the seam.
+ */
+import { resolveGlyphs, resolveIconMode } from "./icons.js";
+import { formatTopContextFromSnapshot } from "./chrome-state.js";
+import { formatRunActivityTopRight } from "./run-activity.js";
+import { formatTelemetryTokens, formatTurnDuration, formatTurnTelemetry, } from "./telemetry.js";
+/**
+ * Read the live pi theme into a typed { fg } surface. The cast is a SAFETY seam — a pi theme
+ * missing `fg` degrades to identity rather than throwing, keeping the chrome resilient.
+ */
+export function adaptTheme(rawTheme) {
+    const t = rawTheme; // SAFETY: pi theme seam — fg is optional, guarded below
+    return {
+        fg: (style, s) => (typeof t.fg === "function" ? t.fg(style, s) : s),
+    };
+}
+/** Optional thinking-border glow (pi theme extension). Falls back to identity. */
+export function resolveGlow(rawTheme) {
+    const t = rawTheme;
+    if (typeof t.getThinkingBorderColor !== "function")
+        return undefined;
+    return (level, s) => {
+        try {
+            return t.getThinkingBorderColor(level)(s);
+        }
+        catch {
+            // SAFETY: best-effort UI, ignore recoverable error
+            return s;
+        }
+    };
+}
+export class ChromeComposition {
+    glyphs;
+    isAscii;
+    theme;
+    glow;
+    constructor(iconMode, rawTheme, opts = {}) {
+        this.glyphs = resolveGlyphs(iconMode);
+        this.isAscii = resolveIconMode(iconMode) === "ascii";
+        this.theme = adaptTheme(rawTheme);
+        this.glow = opts.glow ?? resolveGlow(rawTheme);
+    }
+    /** Colour a string with a theme style (derived once, cast cached). */
+    fg(style, s) {
+        return this.theme.fg(style, s);
+    }
+    dim(s) {
+        return this.fg("dim", s);
+    }
+    /** Apply the thinking-border glow at the given level (identity when unavailable). */
+    applyGlow(level, s) {
+        return this.glow ? this.glow(level, s) : s;
+    }
+    /** Top context bar from a chrome snapshot. */
+    formatTopContext(snapshot, showIconBar) {
+        return formatTopContextFromSnapshot(snapshot, this.theme, this.glyphs, this.isAscii, showIconBar);
+    }
+    /** Bottom telemetry string (TPS/TTFT/stalls) for a turn. */
+    formatTurnTelemetry(tel, cfg, glyphs) {
+        return formatTurnTelemetry(tel, this.theme, cfg, glyphs ?? this.glyphs);
+    }
+    /** Tokens `↑ n · ↓ m` line for a turn. */
+    formatTelemetryTokens(tel, cfg, glyphs) {
+        return formatTelemetryTokens(tel, this.theme, cfg, glyphs ?? this.glyphs);
+    }
+    /** Run-activity top-right (turns · duration · tools · failed). */
+    formatRunActivityTopRight(snap) {
+        return formatRunActivityTopRight(snap, this.theme);
+    }
+    /** Stall badge `!N×dur` for the top-right stall segment. */
+    formatStall(tel) {
+        return this.fg("warning", `${this.glyphs.stall}${tel.stallCount}×${formatTurnDuration(tel.stallMs).trim()}`);
+    }
+}

package/dist/config.js

@@ -70,60 +70,74 @@ function deepMerge(base, override) {
     }
     return result;
 }
-function isBoolean(v) {
-    return typeof v === "boolean";
+/** Single schema table — adding a config leaf is one row. */
+export const CONFIG_SCHEMA = [
+    { path: "enabled", kind: "boolean" },
+    { path: "workspaceDisplay", kind: "enum", values: ["path", "name"] },
+    { path: "cursorStyle", kind: "enum", values: ["block", "bar", "underline"] },
+    { path: "icons.mode", kind: "enum", values: ["auto", "nerd", "ascii"] },
+    { path: "contextIconBar", kind: "boolean" },
+    { path: "footerSegments.cwd", kind: "boolean" },
+    { path: "footerSegments.sessionName", kind: "boolean" },
+    { path: "footerSegments.gitBranch", kind: "boolean" },
+    { path: "footerSegments.gitStatus", kind: "boolean" },
+    { path: "footerSegments.gitCommit", kind: "boolean" },
+    { path: "footerSegments.runtime", kind: "boolean" },
+    { path: "footerSegments.context", kind: "boolean" },
+    { path: "footerSegments.tokens", kind: "boolean" },
+    { path: "footerSegments.cost", kind: "boolean" },
+    { path: "footerSegments.extensionStatuses", kind: "boolean" },
+    { path: "telemetry.enabled", kind: "boolean" },
+    { path: "telemetry.tps", kind: "boolean" },
+    { path: "telemetry.ttft", kind: "boolean" },
+    { path: "telemetry.duration", kind: "boolean" },
+    { path: "telemetry.tokens", kind: "boolean" },
+    { path: "telemetry.stalls", kind: "boolean" },
+    { path: "telemetry.cost", kind: "boolean" },
+    { path: "timeline.enabled", kind: "boolean" },
+    { path: "timeline.wallTime", kind: "boolean" },
+    { path: "timeline.tokens", kind: "boolean" },
+    { path: "timeline.cost", kind: "boolean" },
+];
+function getByPath(obj, path) {
+    const parts = path.split(".");
+    let cur = obj;
+    for (const p of parts) {
+        if (cur === null || typeof cur !== "object")
+            return undefined;
+        // single controlled cast — validation table owns all path access
+        cur = cur[p];
+    }
+    return cur;
 }
-function validate(config) {
-    if (config.workspaceDisplay !== "path" &&
-        config.workspaceDisplay !== "name") {
-        config.workspaceDisplay = DEFAULT_CONFIG.workspaceDisplay;
-    }
-    if (config.cursorStyle !== "block" &&
-        config.cursorStyle !== "bar" &&
-        config.cursorStyle !== "underline") {
-        config.cursorStyle = DEFAULT_CONFIG.cursorStyle;
-    }
-    if (config.icons.mode !== "auto" &&
-        config.icons.mode !== "nerd" &&
-        config.icons.mode !== "ascii") {
-        config.icons.mode = DEFAULT_CONFIG.icons.mode;
-    }
-    if (!isBoolean(config.enabled)) {
-        config.enabled = DEFAULT_CONFIG.enabled;
-    }
-    // SAFETY: intentional unsafe cast — validated at runtime
-    if (!isBoolean(config.contextIconBar)) {
-        // SAFETY: intentional unsafe cast — validated at runtime
-        config.contextIconBar = DEFAULT_CONFIG.contextIconBar;
-    }
-    // SAFETY: intentional unsafe cast — validated at runtime
-    const fs = config.footerSegments;
-    // SAFETY: intentional unsafe cast — validated at runtime
-    const dfs = DEFAULT_CONFIG.footerSegments;
-    for (const k of Object.keys(dfs)) {
-        if (!isBoolean(fs[k]))
-            fs[k] = dfs[k];
-    }
-    // SAFETY: intentional unsafe cast — validated at runtime
-    const t = config.telemetry;
-    // SAFETY: intentional unsafe cast — validated at runtime
-    const dt = DEFAULT_CONFIG.telemetry;
-    for (const k of Object.keys(dt)) {
-        if (!isBoolean(t[k]))
-            t[k] = dt[k];
-    }
-    // SAFETY: intentional unsafe cast — validated at runtime
-    const tl = config.timeline;
-    // SAFETY: intentional unsafe cast — validated at runtime
-    const dtl = DEFAULT_CONFIG.timeline;
-    if (!tl || typeof tl !== "object") {
-        // SAFETY: intentional unsafe cast — validated at runtime
-        config.timeline = structuredClone(DEFAULT_CONFIG.timeline);
+function setByPath(obj, path, value) {
+    const parts = path.split(".");
+    let cur = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const p = parts[i];
+        const next = cur[p];
+        if (typeof next !== "object" || next === null || Array.isArray(next)) {
+            cur[p] = {};
+        }
+        cur = cur[p];
     }
-    else {
-        for (const k of Object.keys(dtl)) {
-            if (!isBoolean(tl[k]))
-                tl[k] = dtl[k];
+    cur[parts[parts.length - 1]] = value;
+}
+function getDefaultByPath(path) {
+    return getByPath(DEFAULT_CONFIG, path);
+}
+function validate(config) {
+    for (const desc of CONFIG_SCHEMA) {
+        const cur = getByPath(config, desc.path);
+        if (desc.kind === "boolean") {
+            if (typeof cur !== "boolean") {
+                setByPath(config, desc.path, getDefaultByPath(desc.path));
+            }
+        }
+        else if (desc.kind === "enum") {
+            if (!desc.values.includes(cur)) {
+                setByPath(config, desc.path, getDefaultByPath(desc.path));
+            }
         }
     }
     return config;

package/dist/detail-chrome.js

@@ -0,0 +1,75 @@
+import { contentLineCount, renderDetail, scroll, } from "./detail-render.js";
+import { decorateWindow } from "./window-presentation.js";
+/** Height cap of the detail window (the user's spec: up to 5 lines). */
+export const MAX_LINES = 5;
+/** Kind tag for the header — derived from the candidate's command prefix. */
+function kindOf(value) {
+    return value.startsWith("skill:") ? "skill" : "command";
+}
+function detailItemOf(item) {
+    return {
+        label: item.label,
+        kind: kindOf(item.value),
+        description: item.description ?? "",
+    };
+}
+export class DetailChrome {
+    item = null;
+    scrollOffset = 0;
+    lastWidth = 0;
+    maxLines;
+    constructor(maxLines = MAX_LINES) {
+        this.maxLines = Math.max(1, Math.floor(maxLines));
+    }
+    /** New candidate — restarts the scroll. Null hides the window. */
+    setItem(item) {
+        this.item = item;
+        this.scrollOffset = 0;
+    }
+    getItem() {
+        return this.item;
+    }
+    /** Current scroll offset (for tests / reading). */
+    getScrollOffset() {
+        return this.scrollOffset;
+    }
+    /** Whether the current item has a non-empty description (widget install decision). */
+    hasContent() {
+        return this.item !== null && (this.item.description ?? "").trim() !== "";
+    }
+    /**
+     * Move the scroll one line, clamped. No-op when the window is hidden or the
+     * description fits. Returns the resulting offset.
+     */
+    scrollBy(delta) {
+        const item = this.item;
+        if (!item || (item.description ?? "").trim() === "") {
+            return this.scrollOffset;
+        }
+        const width = this.lastWidth > 0 ? this.lastWidth : 80;
+        const innerWidth = Math.max(1, width - 4);
+        this.scrollOffset = scroll(this.scrollOffset, delta, contentLineCount(detailItemOf(item), innerWidth), this.maxLines);
+        return this.scrollOffset;
+    }
+    /**
+     * Rendered bordered window at `width`. Returns `[]` when hidden (window
+     * not shown). Reads the LIVE theme at render time so theme swaps apply
+     * immediately.
+     */
+    render(width, theme) {
+        this.lastWidth = width;
+        const item = this.item;
+        if (!item || (item.description ?? "").trim() === "") {
+            return [];
+        }
+        const t = theme;
+        const windowTheme = {
+            border: (s) => t.fg("border", s),
+            highlight: (s) => t.fg("accent", t.bold(s)),
+            dim: (s) => t.fg("dim", s),
+        };
+        const innerWidth = Math.max(1, width - 4);
+        const lines = renderDetail(detailItemOf(item), innerWidth, this.maxLines, this.scrollOffset);
+        return decorateWindow(lines, width, windowTheme);
+    }
+}

package/dist/detail-render.js

@@ -49,6 +49,17 @@ export function renderDetail(item, width, maxLines, scrollOffset) {
     }
     return [header, ...visibleLines];
 }
+/**
+ * Number of wrapped content lines for a description at a given width
+ * (excluding the header). Single source of wrapping truth for both render
+ * and scroll clamping — avoids re-parsing the rendered header marker.
+ */
+export function contentLineCount(item, width) {
+    if (!item || item.description.trim() === "") {
+        return 0;
+    }
+    return wrapDescription(item.description, Math.max(1, Math.floor(width))).length;
+}
 /**
  * Next scroll offset after moving by `delta` (-1 = back/up, +1 = forward/down).
  *

package/dist/footer.js

@@ -1,6 +1,7 @@
 import { truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
 import { getUsageTotals } from "./state.js";
-import { resolveGlyphs, runtimeSymbol } from "./icons.js";
+import { runtimeSymbol } from "./icons.js";
+import { ChromeComposition } from "./chrome-composition.js";
 import { alignRight, fitSegmentsByPriority, } from "./layout.js";
 import { basenamePath, formatCwd, truncatePath, } from "./path-format.js";
 import { fmtTokens, formatDuration, sanitizeStatus } from "./format.js";
@@ -76,7 +77,8 @@ function renderTimerSegment(theme, state, glyphs, totals, config) {
 export function renderFooter(width, state, config, theme, ctx) {
     if (width <= 0)
         return [""];
-    const glyphs = resolveGlyphs(config.icons.mode);
+    const comp = new ChromeComposition(config.icons.mode, theme);
+    const glyphs = comp.glyphs;
     const segments = config.footerSegments;
     const totals = ctx.totals ?? {
         input: 0,