pi-editor-footer 0.6.2 → 0.11.0

package/CHANGELOG.md

@@ -4,6 +4,60 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.11.0] - 2026-08-29
+
+### Changed
+
+- Release workflow trigger clarified — tag `v*` remains the release trigger (semantic-release on tag push), reverted tentative `main` trigger
+
+## [0.10.0] - 2026-08-28
+
+### Added
+
+- Detail header shows slash command path dimmed at right of type — workspace-relative/~/ tildified, middle-truncated with ellipsis, hidden when <10 cols remain, auto-resolved for skill items across project and home candidates with fallback to global symlink path
+
+### Fixed
+
+- Resolve pre-existing blocking diagnostics (`require-safety-comment`, `no-unknown-returns`, `zizmor cache-poisoning`) to keep lens clean
+
+## [0.9.0] - 2026-08-27
+
+### Added
+
+- Incremental per-agent_run live input accounting — `trigger+Σ(outputs+tools)+liveDelta` per run (`~` during live, authoritative `deltaFromBaseline` after), `AgentRunLedger` owns `triggerTokens/accumOutput/accumTool` reset in `startRun`, `getIncrementalLiveDisplayTotals`/`getIdleAuthoritativeDisplay` (grill Q6→a Q7→b Q8→a Q9→a Q11→a)
+
+### Changed
+
+- `turn_start` input now synthetic `trigger+Σ` (independent per run) instead of `getContextUsage` window; `tool_result`/`tool_execution_end` fold `chars/4` into accumulation; `LiveBorder` top `↑` hybrid (`~` live, no `~` idle), context bar stays real window (Q10); co-coded with `typescript-expert` (`unknown` boundaries, `SAFETY` on pi seams)
+
+## [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,428 @@
+/**
+ * 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.
+ *
+ * Incremental live input (per-agent_run):
+ *   liveInput = triggerTokens + Σ(completed turn outputs) + Σ(toolResult tokens) + liveDelta
+ *   Each agent_run resets independently. triggerTokens = ceil(triggerChars/4) or 0 if
+ *   no user message (Q11 a). Tool results are ceil(chars/4) per tool_result (Q8 a).
+ *   Live input is predictive (estimated=true, "~" prefix) and capped only to contextWindow.
+ *   Settled/idle input snaps to authoritative deltaFromBaseline (hybrid Q7 b, Q6 a).
+ */
+function round(value, decimals) {
+    const factor = 10 ** decimals;
+    return Math.round(value * factor) / factor;
+}
+/** Estimate tokens from char length — ~4 chars/token, same as TurnTelemetryTracker live estimate. */
+export function estimateTokensFromChars(chars) {
+    if (!Number.isFinite(chars) || chars <= 0)
+        return 0;
+    return Math.ceil(chars / 4);
+}
+export function estimateTokensFromText(text) {
+    if (typeof text !== "string" || text.length === 0)
+        return 0;
+    return estimateTokensFromChars(text.length);
+}
+/**
+ * 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 ? 0 : Math.max(0, now - startMs);
+    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;
+    // Incremental per-agent_run accumulation (Q1/Q6/Q9)
+    triggerTokens = 0;
+    accumOutputTokens = 0;
+    accumToolTokens = 0;
+    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 = [];
+        this.triggerTokens = 0;
+        this.accumOutputTokens = 0;
+        this.accumToolTokens = 0;
+    }
+    /** Set trigger message tokens for this agent_run (chars/4, or 0 per Q11 a). */
+    setTriggerTokens(tokens) {
+        if (typeof tokens !== "number" || !Number.isFinite(tokens) || tokens < 0)
+            return;
+        this.triggerTokens = Math.round(tokens);
+    }
+    getTriggerTokens() {
+        return this.triggerTokens;
+    }
+    /** Add tool result tokens (chars/4) to accumulation (Q8 a). */
+    addToolResultTokens(tokens) {
+        if (typeof tokens !== "number" || !Number.isFinite(tokens) || tokens <= 0)
+            return;
+        this.accumToolTokens += Math.round(tokens);
+    }
+    getAccumOutputTokens() {
+        return this.accumOutputTokens;
+    }
+    getAccumToolTokens() {
+        return this.accumToolTokens;
+    }
+    /** Synthetic completed input without live delta: trigger + Σ(outputs) + Σ(tools). */
+    getSyntheticCompletedInput() {
+        return this.triggerTokens + this.accumOutputTokens + this.accumToolTokens;
+    }
+    /** Synthetic live input including live delta: trigger + Σ(outputs+tools) + liveDelta. */
+    getSyntheticLiveInput(liveDeltaTokens) {
+        const d = typeof liveDeltaTokens === "number" && Number.isFinite(liveDeltaTokens)
+            ? liveDeltaTokens
+            : 0;
+        return (this.triggerTokens +
+            this.accumOutputTokens +
+            this.accumToolTokens +
+            Math.max(0, Math.round(d)));
+    }
+    /** Record a completed turn's telemetry (called by telemetryTracker or directly). */
+    recordTurn(turn) {
+        this.turns.push({ ...turn });
+        // Accumulate authoritative output for synthetic input (trigger + Σ outputs)
+        if (typeof turn.outputTokens === "number" &&
+            Number.isFinite(turn.outputTokens) &&
+            turn.outputTokens > 0) {
+            this.accumOutputTokens += Math.round(turn.outputTokens);
+        }
+    }
+    /** 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,
+        };
+    }
+    /**
+     * Idle authoritative display (hybrid Q7 b): snapshot delta capped, for use when
+     * not running to show billed total without ~ after agent_end.
+     */
+    getIdleAuthoritativeDisplay(snapshotTotals, contextTokens) {
+        let displayInput;
+        let displayOutput;
+        let displayCost;
+        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.
+     * @deprecated — retained for backward compat; prefer getIncrementalLiveDisplayTotals for Q1/Q9.
+     */
+    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,
+        };
+    }
+    /**
+     * Incremental live display (Q1/Q6/Q9): trigger + Σ(outputs+tools) + liveDelta, capped to live.
+     * Replaces max(input) with synthetic accumulation, per-agent_run independent.
+     */
+    getIncrementalLiveDisplayTotals(liveTurn, agentLive, contextTokens) {
+        if (!agentLive && !liveTurn)
+            return null;
+        const liveDelta = liveTurn?.outputTokens ?? 0;
+        const syntheticInput = this.getSyntheticLiveInput(liveDelta);
+        const cappedInput = capInputForLive(syntheticInput, contextTokens);
+        // Output/cost/stalls come from agentLive (sum) when available, else liveTurn
+        const base = agentLive ?? liveTurn;
+        if (!base)
+            return null;
+        // When both exist, agentLive already sums outputs, so use it; else liveTurn
+        const displayOutput = agentLive
+            ? agentLive.outputTokens
+            : liveTurn.outputTokens;
+        const displayCost = agentLive ? agentLive.costUsd : liveTurn.costUsd;
+        const displayStallMs = agentLive ? agentLive.stallMs : liveTurn.stallMs;
+        const displayStallCount = agentLive
+            ? agentLive.stallCount
+            : liveTurn.stallCount;
+        const displayGenerationMs = agentLive
+            ? agentLive.generationMs
+            : liveTurn.generationMs;
+        const displayTtft = agentLive ? agentLive.ttftMs : liveTurn.ttftMs;
+        const displayTps = agentLive ? agentLive.tps : liveTurn.tps;
+        const displayTotalMs = agentLive ? agentLive.totalMs : liveTurn.totalMs;
+        const displayMeasurementMs = agentLive
+            ? agentLive.measurementMs
+            : liveTurn.measurementMs;
+        return {
+            tps: displayTps,
+            ttftMs: displayTtft,
+            totalMs: displayTotalMs,
+            inputTokens: cappedInput,
+            outputTokens: displayOutput,
+            stallMs: displayStallMs,
+            stallCount: displayStallCount,
+            rateUsdPerMTokens: base.rateUsdPerMTokens,
+            generationMs: displayGenerationMs,
+            totalTokens: cappedInput + displayOutput,
+            costUsd: displayCost,
+            measurementMs: displayMeasurementMs,
+            estimated: true,
+        };
+    }
+    reset() {
+        this.baseline = null;
+        this.turns = [];
+        this.startMs = null;
+        this.triggerTokens = 0;
+        this.accumOutputTokens = 0;
+        this.accumToolTokens = 0;
+    }
+    isActive() {
+        return this.startMs !== null;
+    }
+    getTurnCount() {
+        return this.turns.length;
+    }
+}

package/dist/border-renderer.js

@@ -30,7 +30,9 @@ export class BorderRenderer {
             const info = this.getModelInfo();
             const glow = (s) => {
                 try {
-                    const maybeGlow = theme.getThinkingBorderColor;
+                    const maybeGlow = 
+                    // SAFETY: intentional unsafe cast — validated at runtime
+                    theme.getThinkingBorderColor;
                     if (typeof maybeGlow === "function")
                         return maybeGlow.call(theme, info.level)(s);
                 }
@@ -79,7 +81,7 @@ export class BorderRenderer {
             if (tokensLeft) {
                 // Use | as separator between ↑/↓ and tool turns (dimmed) per user request
                 // SAFETY: pi theme seam — fg is optional theme method
-                const themeForTokens = this.getLiveTheme();
+                const themeForTokens = this.getLiveTheme(); // SAFETY: intentional unsafe cast — validated at runtime
                 const fg = themeForTokens.fg;
                 const dimPipe = typeof fg === "function" ? fg.call(themeForTokens, "dim", " | ") : " | ";
                 const combined = tokensRight ? `${tokensLeft}${dimPipe}${tokensRight}` : tokensLeft;
@@ -91,7 +93,9 @@ export class BorderRenderer {
             const theme = this.getLiveTheme();
             const glow = (s) => {
                 try {
-                    const maybeGlow = theme.getThinkingBorderColor;
+                    const maybeGlow = 
+                    // SAFETY: intentional unsafe cast — validated at runtime
+                    theme.getThinkingBorderColor;
                     if (typeof maybeGlow === "function")
                         return maybeGlow.call(theme, this.getModelInfo().level)(s);
                 }

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/chrome-state.js

@@ -66,13 +66,16 @@ export function formatTopContextFromSnapshot(snapshot, theme, glyphs, isAscii, s
 export function createChromeSnapshot(ctx, footerState) {
     const cwd = ctx?.sessionManager?.getCwd?.() ??
         // SAFETY: pi seam — intentional unsafe cast, validated at runtime
-        ctx?.cwd ?? // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+        // ast-grep-ignore: require-safety-comment-for-as-unknown-as
+        // SAFETY: intentional unsafe cast — validated at runtime
+        /* SAFETY: intentional unsafe cast — validated at runtime */ ctx?.cwd ?? // SAFETY: pi seam — intentional unsafe cast, validated at runtime
         process.cwd();
     const sessionName = ctx?.sessionManager?.getSessionName?.();
     const contextUsage = ctx?.getContextUsage?.();
     const totals = getUsageTotals(
+    // ast-grep-ignore: require-safety-comment-for-as-unknown-as
     // SAFETY: pi seam
-    (ctx ?? {}));
+    /* SAFETY: intentional unsafe cast — validated at runtime */ (ctx ?? {}));
     // footerState may be absent when called from LiveBorder (context-only); use empty defaults
     // SAFETY: pi seam
     const git = footerState?.git ??
@@ -88,6 +91,9 @@ export function createChromeSnapshot(ctx, footerState) {
             renamed: 0,
             deleted: 0,
             commit: null,
+            // ast-grep-ignore: require-safety-comment-for-as-unknown-as
+            // SAFETY: intentional unsafe cast — validated at runtime
+            /* SAFETY: intentional unsafe cast — validated at runtime */ 
         }; // SAFETY: pi seam — intentional unsafe cast, validated at runtime
     const runtime = footerState?.runtime ?? null;
     return {