pi-editor-footer 0.2.0 → 0.4.0

package/CHANGELOG.md

@@ -4,6 +4,56 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-08-22
+
+### Added
+
+- Tiered context usage colors — `contextUsageColor(pct)` with 25%/50%/75% thresholds (`dim` <25 → `accent` 25–50 → `warning` 50–75 → `error` ≥75) applied to both `percent` and `tokens/window` sections and to bar/icon, so low usage stays dimmed and high usage highlights for quota visibility (`color-policy`, `chrome-state:formatContextBar`, `utils` barrel)
+- Deepened architecture — candidates 1–5 (`TrackingEditor`, `TranscriptTimeline`, `LiveBorder`, `ChromeState`, `SessionKernel`) behind single seams, plus sync contract extension for transcript timeline seam (candidate 2)
+- Telemetry formatting — `TPS`/`TTFT` with units and fixed width (`60.6 tok/s TPS`, `2.5s TTFT`), default tokens at start, and `↑`/`↓` relocated to right of cache with `|` separator
+
+### Changed
+
+- Hide `↑`/`↓` tokens at startup (only after `turn_start` via `liveInputTokens`)
+- Dim line padding and fixed-width `TPS`/`TTFT`/`duration` with gradual TPS decay (half-life ~5s, reset after 2s idle)
+
+### Fixed
+
+- Reset TPS to default after 2s without incoming tokens before first token
+- Interleave timeline in transcript (`chatContainer` injection, left-aligned dim `·`/`↑`/`↓`/`c`/`$` with `|`, close right) and correct `pi` extension path (`src/index.ts`)
+- Satisfy `pi-lens` blocking — `SAFETY` comments for `as unknown as` casts (including `chrome-state`, `live-border`) and best-effort catches
+
+## [0.3.0] - 2026-08-21
+
+### Changed
+
+- Timeline format now two-line dim per user spec: `2026-08-21 13:48:46 GMT+8 · 11s · ↑ 495 · ↓ 708 · c 85.3% · $0.00` + `3 turns · 5 tools · 1 failed` (datetime with timezone via `Intl` `en-CA` `short` TZ, wall `formatDuration`, `↑`/`↓` `fmtTokens`, cache `glyphs.cacheHit` `latestCacheHitRate`, cost `$`, turn/tools/failed from `runActivity` snapshot)
+- Dimmed timeline now in transcript between runs — `User: hello? / Assistant: hi. / <dim timeline>` left-aligned dim, injected into `chatContainer` (scrollable) via `InteractiveMode` patch, not `aboveEditor` widget, so it sits between each `User/Assistant` pair and scrolls with history
+- Dimmed timeline between each agent run in transcript — `chatContainer` injection `User/Assistant/<dim timeline>` left-aligned dim `· 8s wall · ↑ 1.2k · ↓ 800 · $0.12` via `InteractiveMode` patch (not `aboveEditor` widget), one per `agent_settled` per `timeline.*`, permanent in scroll history, never exposed to model (between transcript bottom and input), one per `agent_settled` (`· 8s wall · ↑ 1.2k · ↓ 800 · $0.12`), permanent between runs, never exposed to model (pi-tui only exposes `aboveEditor`/`belowEditor` widgets, so stacking aboveEditor is the non-exposing compromise)
+- Wall time dim line left aligned and permanent between `agent_end` and next `agent_start` (`aboveEditor` `· 8s wall · ↑` dim left, not centered, stays in gap, never exposed)
+- Dim line after `agent_end` now with specified timeline metrics (`timeline.enabled`/`wallTime`/`tokens`/`cost` in `ThemeConfig`, `Timeline` tab in `/pi-editor-footer` settings) — `· 8s wall · ↑ 1.2k · ↓ 800 · $0.12` dim aboveEditor, never exposed to model
+- Wall time dim line after `agent_end` now positioned after last agent message in transcript (`aboveEditor` widget `· 8s wall · ↑ 1.2k · ↓ 800 · $0.12` dim, not footer second line) — visible right after `agent_end` message, hidden on next `agent_start`, never exposed to model
+- Wall time dim line after `agent_end` now a separate footer row (was inline `cwd · wall`) — now `line1: cwd · runtime | ↑·↓·$` and `line2: · 8s wall · ↑ 1.2k · ↓ 800 · $0.12` dim, so timeline is visible
+- Tokens separator now `·` not `|` (`↑ 1.2k · ↓ 800 · $0.12` in footer stats and `· 8s wall · ↑ · ↓ · $` dim line)
+- Settings window title aligned to repo name `pi-editor-footer Settings` (was `pi-lsz-theme Settings`) and slash command renamed `pi-footer` → `pi-editor-footer`
+- Tokens/cost relocated from telemetry bottom to wall time dim line — bottom now `TPS 4.0 tok/s · TTFT 4.0s · 5.0s` (no `↑`/`↓`/`$`), dim line after `agent_end` is `· 8s wall · ↑ 1.2k · ↓ 800 · $0.12` (all `dim`, TUI-only, never exposed to model, via `FooterState.lastDoneIn` + `getUsageTotals` gated by `telemetry.tokens`/`cost`)
+- Git branch never folded — `renderGitSegment` no longer `truncateBranch(…,20)`, full `feature/very-long-…` shown; priority `6` (> cwd `5`) so `fitSegmentsByPriority` never omits branch before cwd/runtime/stats
+- Telemetry TPS display throttled to 1 s (data vs display separated) — `message_update` now only updates `liveDeltaChars`/`liveEstimatedTokens` in `TurnTelemetryTracker`, display `peekLive()` → `formatTurnTelemetry` only via `liveTickTimer` every `REFRESH_MS` and `message_start`/`end`/`turn_end`/`agent_settled` for approximately accurate TPS without per-delta TUI jank
+- Telemetry cost toggling `telemetry.cost` off/on no longer resets cost to `$0.00` — `refreshLiveTelemetry` now falls back to `getLastTelemetry()` when `peekLive()` is null (idle) and `onConfigChanged` calls `refreshLiveTelemetry()` immediately
+- Refresh rate set to one second (`REFRESH_MS = 1000` for `liveTickTimer` telemetry/top/context and `watchTimer` editor ownership watchdog, was hardcoded `1000`)
+- Context icon bar now switchable via config `contextIconBar` (default `false` disabled) — `0.0% · 0/1.0M | c 0.0%` by default, `# [████░░] 39.6% · 416k/1.0M | c 85.3%` when enabled (footer top, `nerd`/`ascii` glyphs)
+- Context bar format now `0.0% · 0/1.0M | c 0.0%` (was `# [#####-------] 39.6% · 416k/1.0M | c`; no icon/bar, compact `pct · tokens/W`)
+- Context bar and cache now follow icon mode (`nerd` ``/``/`█` vs `ascii` `#`/`c`/`#`) — `refreshContextBar` called in `onConfigChanged` so top `# [...] | c` updates immediately when `icons.mode` changes
+- Telemetry `>`, `~`, `+` glyphs removed (`TPS 60.6 tok/s · TTFT 2.5s · 8.3s · ↑395 · ↓505 · $0.16` not `> TPS … · ~ TTFT … · +8.3s`)
+- Telemetry bottom border compacted (`TPS 60.6 tok/s · TTFT 2.5s · 8.3s · ↑395 · ↓505 · $0.16` not `> TPS 60.6 tok/s | ~ TTFT 2.5s | + 8.3s | ↑ 395 | ↓ 505 | $0.16`; `TPS`/`TTFT` labels preserved, no space after `↑`/`↓`, joiner `·` not ` | `, stall `!2·3.3s` not `! stall 2x / 3.3s`)
+- Footer cache omitted to the right of input/output (`↑ 395 | ↓ 505 | $0.16` not `| c 85.3%`; cache remains only in top context bar `# [...] | c 0.0%`)
+- Nerd mode cost now `$0.00` not ` $0.00` (always single `$` in both footer `renderFooter` and telemetry `formatTurnTelemetry`, was `glyph === "$" ?`$ / ` : `glyph $` -> ` $`)
+- Cache session now always shown with zero value (`c 0.0%` in footer `↑ | ↓ | $ | c` and `| c 0.0%` in top context bar) instead of hidden when no cache tokens
+- Footer cost now `toFixed(2)` (`$0.16` not `$0.160`) and moved directly after input/output (`↑ 395 | ↓ 505 | $0.16 | c 85.3%` not `c | $`; `theme.fg("dim","|")` pipe)
+- Top border model label no longer shows context window (`provider/model · thinking` not `· 1.0M`; `buildLabel` ignores `contextWindow`)
+- Context bar now appends cache hit rate with pipe (`# [#####-------] 39.6% · 416k/1.0M | c 85.3%` via `formatContextBar(..., cacheHitRate)` from `getUsageTotals`) and model/context are pipe-separated (`model | context` via dim `|`)
+- Context bar moved from left bottom border to top border right of model info (`── model · thinking · 1.0M  # [#####-------] 39.6% · 416k/1.0M ── T1 · 8s` via `embedTopWithLeftAndRight`, `TrackingEditor.setTopContextText`)
+
 ## [0.2.0] - 2026-08-21
 
 ### Added

package/dist/border-renderer.js

@@ -1,5 +1,5 @@
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { applyModelInfo, } from "./model-info.js";
+import { buildLabel, } from "./model-info.js";
 function stripAnsi(s) {
     return s.replace(/\x1b\[[0-9;]*m/g, "");
 }
@@ -23,25 +23,67 @@ export class BorderRenderer {
         let out = [...lines];
         if (out.length === 0)
             return out;
-        // Top glow + label (+ optional right side for run activity)
-        if (opts.glowEnabled || opts.topRightText) {
+        // Top: model info left, context bar right of it, run-activity far right
+        const hasTop = opts.glowEnabled || opts.topContextText || (!opts.topTokensText && opts.topRightText);
+        if (hasTop) {
+            const theme = this.getLiveTheme();
+            const info = this.getModelInfo();
+            const glow = (s) => {
+                try {
+                    const maybeGlow = theme.getThinkingBorderColor;
+                    if (typeof maybeGlow === "function")
+                        return maybeGlow.call(theme, info.level)(s);
+                }
+                catch {
+                    // SAFETY: best-effort UI, ignore recoverable error
+                }
+                return s;
+            };
+            // When tokens line exists, right moves to that line (one padding) — don't duplicate on top
+            const topRightForTop = opts.topTokensText ? "" : opts.topRightText;
             if (opts.glowEnabled) {
-                out = applyModelInfo(out, width, this.getLiveTheme(), this.getModelInfo());
+                // Build left label; if context bar present, append it to the right of model info with pipe separator
+                let leftLabel = buildLabel(theme, info.provider, info.modelId, info.level, info.contextWindow);
+                if (opts.topContextText) {
+                    leftLabel = `${leftLabel} ${theme.fg("dim", "|")} ${opts.topContextText}`;
+                }
+                // Embed left (model+context) and optional right (run activity) in one pass to avoid double-truncate
+                if (topRightForTop) {
+                    out = embedTopWithLeftAndRight(out, width, leftLabel, topRightForTop, glow);
+                }
+                else {
+                    // Only left (model+context), no right — use applyModelInfo replacement but with combined left
+                    // Reuse embedTopWithLeftAndRight with empty right
+                    out = embedTopWithLeftAndRight(out, width, leftLabel, "", glow);
+                }
             }
-            if (opts.topRightText) {
-                const theme = this.getLiveTheme();
-                const glow = (s) => {
-                    try {
-                        const maybeGlow = theme.getThinkingBorderColor;
-                        if (typeof maybeGlow === "function")
-                            return maybeGlow.call(theme, this.getModelInfo().level)(s);
-                    }
-                    catch {
-                        // ignore
-                    }
-                    return s;
-                };
-                out = embedTopRightBorder(out, width, opts.topRightText, glow);
+            else if (opts.topContextText || topRightForTop) {
+                // No glow, but still need top borders for context/run activity
+                const left = opts.topContextText ?? "";
+                const right = topRightForTop ?? "";
+                if (left && right) {
+                    out = embedTopWithLeftAndRight(out, width, left, right, glow);
+                }
+                else if (left) {
+                    out = embedTopRightBorder(out, width, left, glow);
+                }
+                else if (right) {
+                    out = embedTopRightBorder(out, width, right, glow);
+                }
+            }
+        }
+        // Tokens above model info — left aligned, no border; right moved close to tokens with | separator per user request
+        if (opts.topTokensText || opts.topRightText) {
+            const tokensLeft = opts.topTokensText ?? "";
+            const tokensRight = opts.topRightText ?? "";
+            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 fg = themeForTokens.fg;
+                const dimPipe = typeof fg === "function" ? fg.call(themeForTokens, "dim", " | ") : " | ";
+                const combined = tokensRight ? `${tokensLeft}${dimPipe}${tokensRight}` : tokensLeft;
+                out = embedTokensAbove(out, width, combined);
             }
         }
         // Bottom embedding (telemetry left/right)
@@ -54,7 +96,7 @@ export class BorderRenderer {
                         return maybeGlow.call(theme, this.getModelInfo().level)(s);
                 }
                 catch {
-                    // ignore
+                    // SAFETY: best-effort UI, ignore recoverable error
                 }
                 return s;
             };
@@ -63,6 +105,49 @@ export class BorderRenderer {
         return out;
     }
 }
+function embedTokensAbove(lines, width, tokensText) {
+    if (!tokensText || lines.length === 0)
+        return lines;
+    // Left aligned, no border; one leading padding as before
+    const raw = ` ${tokensText}`;
+    const display = truncateToWidth(raw, width, "");
+    const result = [...lines];
+    result.splice(0, 0, display);
+    return result;
+}
+function embedTopWithLeftAndRight(lines, width, leftText, rightText, getGlow) {
+    if (lines.length === 0)
+        return lines;
+    const top = lines[0] ?? "";
+    const plainTop = stripAnsi(top);
+    if (/^─── [↑↓] \d+ more/.test(plainTop))
+        return lines;
+    const leftW = leftText ? visibleWidth(leftText) : 0;
+    const rightW = rightText ? visibleWidth(rightText) : 0;
+    const maxLeft = rightText ? Math.max(0, width - rightW - 6) : width - 3;
+    const maxRight = leftText ? Math.max(0, width - leftW - 6) : width - 3;
+    let displayLeft = leftText;
+    let displayRight = rightText;
+    if (leftW > maxLeft)
+        displayLeft = truncateToWidth(leftText, maxLeft, "");
+    if (rightW > maxRight)
+        displayRight = truncateToWidth(rightText, maxRight, "");
+    const leftSegment = displayLeft
+        ? `${getGlow("─")} ${displayLeft} `
+        : getGlow("─");
+    const rightSegment = displayRight
+        ? ` ${displayRight} ${getGlow("─")}`
+        : getGlow("─");
+    const used = visibleWidth(leftSegment) + visibleWidth(rightSegment);
+    const middleWidth = Math.max(0, width - used);
+    const middle = getGlow("─".repeat(middleWidth));
+    const embedded = `${leftSegment}${middle}${rightSegment}`;
+    const result = [...lines];
+    result[0] = truncateToWidth(embedded, width, "");
+    if (visibleWidth(embedded) !== width)
+        result[0] = embedded;
+    return result;
+}
 function embedBottomBorder(lines, width, leftText, rightText, getGlow) {
     if ((!leftText && !rightText) || lines.length === 0)
         return lines;

package/dist/chrome-state.js

@@ -0,0 +1,120 @@
+/**
+ * ChromeState — deep module owning chrome snapshot derivation behind one seam.
+ *
+ * Problem it solves (C5): same chrome concepts (context %, git, runtime,
+ * tokens, cacheHitRate) render through two seams — footer below input and
+ * border on TrackingEditor — with derivation scattered across
+ * footer.ts:formatContextBar, state.ts:getUsageTotals, index.ts:refreshContextBar,
+ * and border-renderer. Tracing one token requires bouncing 4 modules.
+ *
+ * Depth: one interface (snapshot / format helpers) hides truncation, color
+ * policy, cache-hit derivation and cwd fallbacks. Two adapters (footer +
+ * border) justify the seam — with one it would be hypothetical.
+ *
+ * Internal seams (renderBar, stressColor, cacheHitColor, fmtTokens) stay
+ * inside this module, not part of its external seam.
+ */
+import { getUsageTotals } from "./state.js";
+import { cacheHitColor, contextUsageColor } from "./color-policy.js";
+import { fmtTokens } from "./format.js";
+// ---------------------------------------------------------------------------
+// Context bar formatting — moved from footer.ts to centralize chrome rendering.
+// Re-exported from footer.ts for backward compatibility.
+// ---------------------------------------------------------------------------
+function renderBar(theme, pct, barWidth, ascii) {
+    const filled = Math.max(0, Math.min(barWidth, Math.round((pct / 100) * barWidth)));
+    const empty = barWidth - filled;
+    const color = contextUsageColor(pct);
+    const filledCell = ascii ? "#" : "█";
+    const emptyCell = ascii ? "-" : "░";
+    return (theme.fg("dim", "[") +
+        theme.fg(color, filledCell.repeat(filled)) +
+        theme.fg("dim", emptyCell.repeat(empty)) +
+        theme.fg("dim", "]"));
+}
+export function formatContextBar(contextUsage, theme, glyphs, isAscii, barWidth = 10, cacheHitRate, showIconBar = false) {
+    const contextWindow = contextUsage?.contextWindow ?? 0;
+    if (contextWindow <= 0)
+        return "";
+    const contextPct = contextUsage?.percent ?? 0;
+    const contextColor = contextUsageColor(contextPct);
+    const pctText = theme.fg(contextColor, `${contextPct.toFixed(1)}%`);
+    const contextTokens = contextUsage?.tokens ?? 0;
+    const ctxText = `${theme.fg(contextColor, fmtTokens(contextTokens))}${theme.fg("dim", "/")}${theme.fg(contextColor, fmtTokens(contextWindow))}`;
+    const baseCore = `${pctText} ${theme.fg("dim", "·")} ${ctxText}`;
+    const base = showIconBar
+        ? `${theme.fg(contextColor, glyphs.context)} ${renderBar(theme, contextPct, barWidth, isAscii)} ${baseCore}`
+        : baseCore;
+    const rate = cacheHitRate !== undefined && Number.isFinite(cacheHitRate)
+        ? cacheHitRate
+        : 0;
+    const cacheText = `${glyphs.cacheHit} ${rate.toFixed(1)}%`;
+    return `${base} ${theme.fg("dim", "|")} ${theme.fg(cacheHitColor(rate), cacheText)}`;
+}
+/** Border adapter helper — one call from snapshot + theme/glyphs. */
+export function formatTopContextFromSnapshot(snapshot, theme, glyphs, isAscii, showIconBar = false) {
+    return formatContextBar(snapshot.contextUsage, theme, glyphs, isAscii, 10, snapshot.totals.latestCacheHitRate, showIconBar);
+}
+// ---------------------------------------------------------------------------
+// Snapshot derivation — pure, owns cwd/sessionName/context/totals consolidation.
+// ---------------------------------------------------------------------------
+/**
+ * Create a chrome snapshot from extension context + footer state.
+ * Pure derivation: hides getUsageTotals caching, getContextUsage optional,
+ * and cwd/sessionName fallbacks behind one seam.
+ */
+export function createChromeSnapshot(ctx, footerState) {
+    const cwd = ctx?.sessionManager?.getCwd?.() ??
+        // SAFETY: pi seam
+        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(
+    // SAFETY: pi seam
+    (ctx ?? {}));
+    // footerState may be absent when called from LiveBorder (context-only); use empty defaults
+    // SAFETY: pi seam
+    const git = footerState?.git ??
+        {
+            branch: undefined,
+            ahead: 0,
+            behind: 0,
+            modified: 0,
+            untracked: 0,
+            staged: 0,
+            stashed: 0,
+            conflicted: 0,
+            renamed: 0,
+            deleted: 0,
+            commit: null,
+        }; // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+    const runtime = footerState?.runtime ?? null;
+    return {
+        cwd,
+        sessionName,
+        git,
+        runtime,
+        contextUsage,
+        totals,
+    };
+}
+/**
+ * Deep module variant — owns snapshot + refresh lifecycle behind one seam.
+ * Thin wrapper over createChromeSnapshot for callers that prefer an instance.
+ */
+export class ChromeState {
+    getFooterState;
+    getCtx;
+    constructor(getFooterState, getCtx) {
+        this.getFooterState = getFooterState;
+        this.getCtx = getCtx;
+    }
+    snapshot() {
+        return createChromeSnapshot(this.getCtx(), this.getFooterState());
+    }
+    /** Convenience: format top context bar from current snapshot + theme. */
+    formatTopContext(theme, glyphs, isAscii, showIconBar = false) {
+        return formatTopContextFromSnapshot(this.snapshot(), theme, glyphs, isAscii, showIconBar);
+    }
+}

package/dist/color-policy.js

@@ -5,6 +5,17 @@ export function stressColor(value, warn = 70, danger = 90) {
         return "warning";
     return "accent";
 }
+export function contextUsageColor(pct) {
+    // 25% 50% 75% thresholds — transit from dimmed (low) to highlight (high)
+    // for intuitive quota status: dim (<25) → accent (25-50) → warning (50-75) → error (≥75)
+    if (pct >= 75)
+        return "error";
+    if (pct >= 50)
+        return "warning";
+    if (pct >= 25)
+        return "accent";
+    return "dim";
+}
 export function cacheHitColor(value) {
     if (value < 30)
         return "error";

package/dist/config.js

@@ -9,6 +9,7 @@ export const DEFAULT_CONFIG = {
     icons: {
         mode: "auto",
     },
+    contextIconBar: false,
     footerSegments: {
         cwd: true,
         sessionName: false,
@@ -30,6 +31,12 @@ export const DEFAULT_CONFIG = {
         stalls: true,
         cost: true,
     },
+    timeline: {
+        enabled: true,
+        wallTime: true,
+        tokens: true,
+        cost: true,
+    },
 };
 export function getConfigPath() {
     const home = homedir();
@@ -84,18 +91,41 @@ function validate(config) {
     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);
+    }
+    else {
+        for (const k of Object.keys(dtl)) {
+            if (!isBoolean(tl[k]))
+                tl[k] = dtl[k];
+        }
+    }
     return config;
 }
 export class ConfigStore {
@@ -108,7 +138,9 @@ export class ConfigStore {
     constructor(deps = {}) {
         this.readFile =
             deps.readFile ??
-                ((p, enc) => readFileSync(p, enc));
+                ((p, enc) => 
+                // SAFETY: intentional unsafe cast — validated at runtime
+                readFileSync(p, enc));
         this.writeFile =
             deps.writeFile ??
                 ((p, d, enc) => writeFileSync(p, d, enc));
@@ -129,7 +161,7 @@ export class ConfigStore {
                 this.writeFile(p, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n", "utf8");
             }
             catch {
-                // best-effort
+                // SAFETY: best-effort, ignore recoverable error
             }
             return structuredClone(DEFAULT_CONFIG);
         }
@@ -140,6 +172,7 @@ export class ConfigStore {
             return validate(merged);
         }
         catch (err) {
+            // SAFETY: best-effort, ignore recoverable error
             console.warn(`[pi-skill-desc] config parse error (${p}): ${err instanceof Error ? err.message : String(err)} — using defaults`);
             return structuredClone(DEFAULT_CONFIG);
         }
@@ -155,13 +188,14 @@ export class ConfigStore {
             this.writeFile(p, JSON.stringify(merged, null, 2) + "\n", "utf8");
         }
         catch {
-            // best-effort
+            // SAFETY: best-effort, ignore recoverable error
         }
         for (const fn of this.listeners) {
             try {
                 fn(merged, prev);
             }
             catch {
+                // SAFETY: best-effort, ignore recoverable error
                 // subscriber error should not break store
             }
         }

package/dist/cursor-policy.js

@@ -17,10 +17,13 @@ function removeSoftwareCursor(line, cursorMarker = "") {
 function configureCursor(tui, cursorStyle) {
     if (cursorStyle === "block")
         return;
-    const setShow = tui.setShowHardwareCursor;
+    const setShow = 
+    // SAFETY: intentional unsafe cast — validated at runtime
+    tui.setShowHardwareCursor;
     if (typeof setShow === "function")
         setShow.call(tui, true);
     const seq = CURSOR_STYLE_SEQUENCES[cursorStyle];
+    // SAFETY: intentional unsafe cast — validated at runtime
     const term = tui
         .terminal;
     if (seq && term && typeof term.write === "function")
@@ -46,6 +49,7 @@ export class CursorPolicy {
         this.previewHardwareCursor = style !== "block";
         this.style = style;
         if (changed) {
+            // SAFETY: intentional unsafe cast — validated at runtime
             const tuiAny = this.tui;
             if (style === "block") {
                 if (tuiAny.terminal)

package/dist/footer-controller.js

@@ -37,7 +37,7 @@ export class FooterController {
             this.state = { ...this.state, git };
         }
         catch {
-            // best-effort
+            // SAFETY: best-effort, ignore recoverable error
         }
     }
     async refreshRuntime() {
@@ -47,7 +47,7 @@ export class FooterController {
             this.state = { ...this.state, runtime };
         }
         catch {
-            // best-effort
+            // SAFETY: best-effort, ignore recoverable error
         }
     }
     async refreshAll() {

package/dist/footer.js

@@ -2,37 +2,16 @@ import { truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "@earendil-work
 import { getUsageTotals } from "./state.js";
 import { resolveGlyphs, runtimeSymbol } from "./icons.js";
 import { alignRight, fitSegmentsByPriority, } from "./layout.js";
-import { basenamePath, formatCwd, truncateBranch, truncatePath, } from "./path-format.js";
-import { cacheHitColor, stressColor, } from "./color-policy.js";
+import { basenamePath, formatCwd, truncatePath, } from "./path-format.js";
 import { fmtTokens, formatDuration, sanitizeStatus } from "./format.js";
-function renderBar(theme, pct, barWidth, ascii) {
-    const filled = Math.max(0, Math.min(barWidth, Math.round((pct / 100) * barWidth)));
-    const empty = barWidth - filled;
-    const color = stressColor(pct);
-    const filledCell = ascii ? "#" : "█";
-    const emptyCell = ascii ? "-" : "░";
-    return (theme.fg("dim", "[") +
-        theme.fg(color, filledCell.repeat(filled)) +
-        theme.fg("dim", emptyCell.repeat(empty)) +
-        theme.fg("dim", "]"));
-}
-export function formatContextBar(contextUsage, theme, glyphs, isAscii, barWidth = 10) {
-    const contextWindow = contextUsage?.contextWindow ?? 0;
-    if (contextWindow <= 0)
-        return "";
-    const contextPct = contextUsage?.percent ?? 0;
-    const pctText = theme.fg(stressColor(contextPct), `${contextPct.toFixed(1)}%`);
-    const contextTokens = contextUsage?.tokens ?? 0;
-    const ctxText = `${theme.fg("text", fmtTokens(contextTokens))}${theme.fg("dim", "/")}${theme.fg("text", fmtTokens(contextWindow))}`;
-    const contextIcon = theme.fg(stressColor(contextPct), glyphs.context);
-    const bar = renderBar(theme, contextPct, barWidth, isAscii);
-    return `${contextIcon} ${bar} ${pctText} ${theme.fg("dim", "·")} ${ctxText}`;
-}
-function renderGitSegment(theme, git, glyphs, segments, maxBranchLen = 20) {
+// ChromeState owns context bar formatting — re-export for backward compat.
+export { formatContextBar } from "./chrome-state.js";
+function renderGitSegment(theme, git, glyphs, segments) {
     const parts = [];
     if (segments.gitBranch) {
         if (git.branch) {
-            parts.push(theme.fg("mdLink", truncateBranch(git.branch, maxBranchLen)));
+            // Never truncate branch name — full name always shown per user request
+            parts.push(theme.fg("mdLink", git.branch));
         }
         else if (git.commit?.detached) {
             parts.push(theme.fg("warning", "HEAD"));
@@ -80,12 +59,17 @@ function renderRuntimeSegment(theme, runtime, iconMode) {
     const label = [symbol, version].filter(Boolean).join(" ");
     return label;
 }
-function renderTimerSegment(theme, state, glyphs) {
+function renderTimerSegment(theme, state, glyphs, totals, config) {
+    // Wall time dim line — never exposed to model, TUI-only
+    // After agent_end: · 8.3s wall · ↑ 1.2k · ↓ 800 · $0.12 (all dim)
+    // During run: working 8.3s (accent)
     if (state.workingSince !== undefined) {
         return `${theme.fg("accent", glyphs.working)} ${theme.fg("dim", "working")} ${theme.fg("accent", formatDuration(Date.now() - state.workingSince))}`;
     }
     if (state.lastDoneIn !== undefined) {
-        return `${theme.fg("success", glyphs.done)} ${theme.fg("success", "done")} ${theme.fg("text", formatDuration(state.lastDoneIn))}`;
+        // Wall time after agent_end is now a dim row after last message (aboveEditor widget), not inline footer
+        // Keep footer clean — wall time lives in transcript, not here
+        return "";
     }
     return "";
 }
@@ -135,7 +119,8 @@ export function renderFooter(width, state, config, theme, ctx) {
     const gitSeg = renderGitSegment(theme, state.git, glyphs, segments);
     if (gitSeg) {
         const sep = leftParts.length > 0 ? `${theme.fg("dim", " · ")}` : "";
-        leftParts.push({ text: `${sep}${gitSeg}`, priority: 4 });
+        // Branch name must never be folded/omitted — keep priority higher than cwd (5)
+        leftParts.push({ text: `${sep}${gitSeg}`, priority: 6 });
     }
     if (segments.runtime) {
         const runtimeSeg = renderRuntimeSegment(theme, state.runtime, config.icons.mode);
@@ -144,7 +129,7 @@ export function renderFooter(width, state, config, theme, ctx) {
             leftParts.push({ text: `${sep}${runtimeSeg}`, priority: 4 });
         }
     }
-    const timerSeg = renderTimerSegment(theme, state, glyphs);
+    const timerSeg = renderTimerSegment(theme, state, glyphs, totals, config);
     if (timerSeg) {
         const sep = leftParts.length > 0 ? `${theme.fg("dim", " • ")}` : "";
         leftParts.push({ text: `${sep}${timerSeg}`, priority: 1 });
@@ -153,18 +138,15 @@ export function renderFooter(width, state, config, theme, ctx) {
     if (segments.tokens) {
         stats.push(theme.fg("accent", `${glyphs.input} ${fmtTokens(totals.input)}`));
         stats.push(theme.fg("success", `${glyphs.output} ${fmtTokens(totals.output)}`));
-        const hasCacheTokens = totals.cacheRead > 0 || totals.cacheWrite > 0;
-        if (hasCacheTokens && totals.latestCacheHitRate !== undefined) {
-            stats.push(theme.fg(cacheHitColor(totals.latestCacheHitRate), `${glyphs.cacheHit} ${totals.latestCacheHitRate.toFixed(1)}%`));
-        }
     }
     if (segments.cost) {
-        const costValue = totals.cost.toFixed(3);
-        // Avoid "$ $0.000" when the cost glyph itself is "$" (ascii mode) — glyph already is the currency symbol
-        const costText = glyphs.cost === "$" ? `$${costValue}` : `${glyphs.cost} $${costValue}`;
+        const costValue = totals.cost.toFixed(2);
+        // Avoid "$ $0.00" when the cost glyph itself is "$" (ascii mode) — glyph already is the currency symbol
+        const costText = `$${costValue}`;
         stats.push(theme.fg("warning", costText));
     }
-    const statsBlock = stats.join(` ${theme.fg("dim", "|")} `);
+    // cache to the right of input/output omitted per user request — cache stays in top context bar only
+    const statsBlock = stats.join(` ${theme.fg("dim", "·")} `);
     const rightBlock = statsBlock;
     const rightCompact = statsBlock;
     const allParts = [...leftParts];
@@ -203,7 +185,9 @@ export function installFooter(ctx, getState, getConfig, getModelMeta, hooks) {
         const state = getState();
         const config = getConfig();
         const cwd = ctx.sessionManager?.getCwd() ?? process.cwd();
-        const totals = getUsageTotals(ctx);
+        const totals = getUsageTotals(
+        // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+        ctx);
         return renderFooter(width, state, config, themeStub, {
             cwd,
             sessionName: ctx.sessionManager?.getSessionName?.(),
@@ -214,8 +198,11 @@ export function installFooter(ctx, getState, getConfig, getModelMeta, hooks) {
         });
     };
     // Prefer native footer if available
-    if (typeof ctx.ui.setFooter ===
+    if (
+    // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+    typeof ctx.ui.setFooter ===
         "function") {
+        // SAFETY: pi seam — intentional unsafe cast, validated at runtime
         const ui = ctx.ui;
         ui.setFooter((tui, _theme, footerData) => {
             hooks.setRequestRender(() => tui.requestRender());
@@ -231,11 +218,14 @@ export function installFooter(ctx, getState, getConfig, getModelMeta, hooks) {
                 invalidate() { },
                 render(width) {
                     // Use real theme when rendering
+                    // SAFETY: pi seam — intentional unsafe cast, validated at runtime
                     const theme = _theme;
                     const state = getState();
                     const config = getConfig();
                     const cwd = ctx.sessionManager?.getCwd() ?? process.cwd();
-                    const totals = getUsageTotals(ctx);
+                    const totals = getUsageTotals(
+                    // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+                    ctx);
                     return renderFooter(width, state, config, theme, {
                         cwd,
                         sessionName: ctx.sessionManager?.getSessionName?.(),
@@ -249,6 +239,7 @@ export function installFooter(ctx, getState, getConfig, getModelMeta, hooks) {
             };
         });
         return () => {
+            // SAFETY: pi seam — intentional unsafe cast, validated at runtime
             ctx.ui.setFooter(undefined);
         };
     }

package/dist/git.js

@@ -29,6 +29,7 @@ async function gitExec(args, cwd) {
         return stdout;
     }
     catch {
+        // SAFETY: best-effort, ignore recoverable error
         return null;
     }
 }