pi-editor-footer 0.1.2 → 0.2.0

package/CHANGELOG.md

@@ -4,20 +4,41 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-08-21
+
+### Added
+
+- Real-time telemetry via `TurnTelemetryTracker.peekLive()` and 1 s live tick — bottom border `> TPS 60.6 tok/s | ~ TTFT 2.5s | + 8.3s | ↑ 395 | ↓ 505 | $0.16` refreshes on every `agent/turn/message/tool` event during streaming
+- Top-border run activity `T1 · 8s · 2 tools · 1 failed` via `RunActivityTracker` (turn · duration · tool calls · failed) adapted from `pi-atelier/src/run-activity.ts`
+- Context bar moved to left bottom border `── # [#####-------] 39.6% · 416k/1.0M ──` (`formatContextBar` helper, `barWidth 10`, theme-aware, respects `footerSegments.context`, live-updates)
+- Architecture deepening: split `utils.ts` into 5 focused modules (`path-format`, `color-policy`, `format`, `layout`, `tip-policy`), deepened `ConfigStore`, `Footer`, `TrackingEditor` (`BorderRenderer`/`CursorPolicy`), `SessionKernel` (candidates 1–5)
+
+### Changed
+
+- Footer no longer renders context (moved to border); right block is now just stats (`↑`/`↓`/`$`)
+- Context window `formatContextWindow` now `1.0M` (was `1m` lowercase no decimal) to match `fmtTokens` (`362k/1.0M`)
+
+### Fixed
+
+- Streaming `TPS — | ↓ 0` until `turn_end` — now estimates live tokens (`~4 chars/token`) and shows live `TPS`/`↓` during `message_update`
+- Cost duplicate `$ $0.16/M` → `$0.16` (single `$` when glyph is `$`, nerd keeps ` $0.16`) and hid `per M` suffix as common sense
+- Cost duplicate in footer `$ $0.000` → `$0.000`
+- `formatContextWindow` `1m` → `1.0M` (capital `M`, one decimal) for `0.9k/1.0M` consistency
+
 ## [0.1.2] - 2026-08-20
 
 ### Fixed
+
 - `npm:pi-editor-footer` not being discovered when installed via `pi install npm:pi-editor-footer` — added `pi.extensions` (`dist/index.js`) and `keywords` so pi loads the theme from `~/.pi/agent/npm/node_modules`
 
 ## [0.1.1] - 2026-08-20
 
-
 ### Fixed
+
 - `npm:pi-editor-footer` now works when installed via `pi install npm:pi-editor-footer` — added `main` (`dist/index.js`), `files`, and `build` (`tsc --project tsconfig.build.json`) so pi can discover the extension from `~/.pi/agent/npm/node_modules`
 
 ## [0.1.0] - 2026-08-20
 
-
 ### Added
 
 - Full TUI theme `pi-editor-footer` rebuilt on `TrackingEditor`: project-aware footer (`cwd` · `git` • `runtime` left, `tokens` next to `context` right), model-info border glow top, live theme respect, detail window preserved

package/dist/border-renderer.js

@@ -0,0 +1,139 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { applyModelInfo, } from "./model-info.js";
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function isBorderLine(line) {
+    const plain = stripAnsi(line);
+    return /^─+$/.test(plain) || /^─── [↑↓] \d+ more/.test(plain);
+}
+/**
+ * BorderRenderer — deep module owning top glow + bottom border embedding.
+ * Deduplicates stripAnsi/isBorder logic previously spread between model-info.ts
+ * and tracking-editor.ts. Behind a single seam, tested via render().
+ */
+export class BorderRenderer {
+    getLiveTheme;
+    getModelInfo;
+    constructor(getLiveTheme, getModelInfo) {
+        this.getLiveTheme = getLiveTheme;
+        this.getModelInfo = getModelInfo;
+    }
+    renderWithBorders(lines, width, opts) {
+        let out = [...lines];
+        if (out.length === 0)
+            return out;
+        // Top glow + label (+ optional right side for run activity)
+        if (opts.glowEnabled || opts.topRightText) {
+            if (opts.glowEnabled) {
+                out = applyModelInfo(out, width, this.getLiveTheme(), this.getModelInfo());
+            }
+            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);
+            }
+        }
+        // Bottom embedding (telemetry left/right)
+        if (opts.telemetryText || opts.bottomLeftText) {
+            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 = embedBottomBorder(out, width, opts.bottomLeftText ?? "", opts.telemetryText ?? "", glow);
+        }
+        return out;
+    }
+}
+function embedBottomBorder(lines, width, leftText, rightText, getGlow) {
+    if ((!leftText && !rightText) || lines.length === 0)
+        return lines;
+    let bottomIdx = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (isBorderLine(lines[i] ?? "")) {
+            bottomIdx = i;
+            break;
+        }
+    }
+    if (bottomIdx === -1)
+        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[bottomIdx] = truncateToWidth(embedded, width, "");
+    if (visibleWidth(embedded) !== width)
+        result[bottomIdx] = embedded;
+    return result;
+}
+function embedTopRightBorder(lines, width, rightText, getGlow) {
+    if (!rightText || lines.length === 0)
+        return lines;
+    // Top border is always lines[0] — unless it's a scroll indicator, treat similarly
+    const top = lines[0] ?? "";
+    const plainTop = stripAnsi(top);
+    // If top is scroll indicator, don't embed right — keep glow recolor only
+    if (/^─── [↑↓] \d+ more/.test(plainTop))
+        return lines;
+    const rightW = visibleWidth(rightText);
+    // left label already embedded by applyModelInfo — its visible width is width - middle - right
+    // We need to truncate right if too wide, preserving at least 10 chars for left
+    const maxRight = Math.max(0, width - 12);
+    let displayRight = rightText;
+    if (rightW > maxRight)
+        displayRight = truncateToWidth(rightText, maxRight, "");
+    const displayW = visibleWidth(displayRight);
+    // Rebuild top: keep existing left-embedded line, replace its right tail
+    const existing = lines[0] ?? "";
+    // Strip then rebuild: we need to preserve left part and insert right
+    // Simple approach: truncate existing to width - displayW - 3, then add " " + displayRight + " " + glow("─")
+    const availableForLeft = Math.max(0, width - displayW - 3);
+    const leftPart = truncateToWidth(existing, availableForLeft, "");
+    // Ensure leftPart ends with glow dash if truncated
+    const rightSegment = ` ${displayRight} ${getGlow("─")}`;
+    const leftW2 = visibleWidth(leftPart);
+    const rightW2 = visibleWidth(rightSegment);
+    const middleWidth = Math.max(0, width - leftW2 - rightW2);
+    const middle = getGlow("─".repeat(middleWidth));
+    const embedded = `${leftPart}${middle}${rightSegment}`;
+    const result = [...lines];
+    result[0] = truncateToWidth(embedded, width, "");
+    if (visibleWidth(embedded) !== width)
+        result[0] = embedded;
+    return result;
+}

package/dist/color-policy.js

@@ -0,0 +1,53 @@
+export function stressColor(value, warn = 70, danger = 90) {
+    if (value >= danger)
+        return "error";
+    if (value >= warn)
+        return "warning";
+    return "accent";
+}
+export function cacheHitColor(value) {
+    if (value < 30)
+        return "error";
+    if (value < 70)
+        return "warning";
+    return "success";
+}
+export function providerColor(provider) {
+    switch (provider.toLowerCase()) {
+        case "anthropic":
+            return "accent";
+        case "openai":
+        case "openai-codex":
+            return "success";
+        case "google":
+        case "google-vertex":
+            return "warning";
+        case "amazon-bedrock":
+            return "thinkingHigh";
+        case "github-copilot":
+            return "mdLink";
+        case "deepseek":
+            return "thinkingLow";
+        case "xai":
+        case "groq":
+            return "error";
+        default:
+            return "muted";
+    }
+}
+export function effortColor(level) {
+    switch (level) {
+        case "minimal":
+            return "thinkingMinimal";
+        case "low":
+            return "thinkingLow";
+        case "medium":
+            return "thinkingMedium";
+        case "high":
+            return "thinkingHigh";
+        case "xhigh":
+            return "thinkingXhigh";
+        default:
+            return "thinkingMedium";
+    }
+}

package/dist/config.js

@@ -63,69 +63,123 @@ function deepMerge(base, override) {
     }
     return result;
 }
+function isBoolean(v) {
+    return typeof v === "boolean";
+}
 function validate(config) {
-    // workspaceDisplay
     if (config.workspaceDisplay !== "path" &&
         config.workspaceDisplay !== "name") {
         config.workspaceDisplay = DEFAULT_CONFIG.workspaceDisplay;
     }
-    // cursorStyle
     if (config.cursorStyle !== "block" &&
         config.cursorStyle !== "bar" &&
         config.cursorStyle !== "underline") {
         config.cursorStyle = DEFAULT_CONFIG.cursorStyle;
     }
-    // icons.mode
     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;
+    }
+    const fs = config.footerSegments;
+    const dfs = DEFAULT_CONFIG.footerSegments;
+    for (const k of Object.keys(dfs)) {
+        if (!isBoolean(fs[k]))
+            fs[k] = dfs[k];
+    }
+    const t = config.telemetry;
+    const dt = DEFAULT_CONFIG.telemetry;
+    for (const k of Object.keys(dt)) {
+        if (!isBoolean(t[k]))
+            t[k] = dt[k];
+    }
     return config;
 }
-export function ensureConfigExists() {
-    const path = getConfigPath();
-    if (existsSync(path))
-        return;
-    try {
-        const dir = join(path, "..");
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        writeFileSync(path, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n", "utf8");
+export class ConfigStore {
+    readFile;
+    writeFile;
+    exists;
+    mkdirSyncFn;
+    explicitPath;
+    listeners = new Set();
+    constructor(deps = {}) {
+        this.readFile =
+            deps.readFile ??
+                ((p, enc) => readFileSync(p, enc));
+        this.writeFile =
+            deps.writeFile ??
+                ((p, d, enc) => writeFileSync(p, d, enc));
+        this.exists = deps.exists ?? existsSync;
+        this.mkdirSyncFn = deps.mkdirSync ?? mkdirSync;
+        this.explicitPath = deps.path;
     }
-    catch {
-        // best-effort
+    getPath() {
+        return this.explicitPath ?? getConfigPath();
     }
-}
-export function loadConfig() {
-    const path = getConfigPath();
-    if (!existsSync(path)) {
-        ensureConfigExists();
-        return structuredClone(DEFAULT_CONFIG);
+    get() {
+        const p = this.getPath();
+        if (!this.exists(p)) {
+            try {
+                const dir = join(p, "..");
+                if (!this.exists(dir))
+                    this.mkdirSyncFn(dir, { recursive: true });
+                this.writeFile(p, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n", "utf8");
+            }
+            catch {
+                // best-effort
+            }
+            return structuredClone(DEFAULT_CONFIG);
+        }
+        try {
+            const raw = this.readFile(p, "utf8");
+            const parsed = JSON.parse(raw);
+            const merged = deepMerge(structuredClone(DEFAULT_CONFIG), parsed);
+            return validate(merged);
+        }
+        catch (err) {
+            console.warn(`[pi-skill-desc] config parse error (${p}): ${err instanceof Error ? err.message : String(err)} — using defaults`);
+            return structuredClone(DEFAULT_CONFIG);
+        }
     }
-    try {
-        const raw = readFileSync(path, "utf8");
-        const parsed = JSON.parse(raw);
-        const merged = deepMerge(structuredClone(DEFAULT_CONFIG), parsed);
-        return validate(merged);
+    patch(patch) {
+        const prev = this.get();
+        const merged = validate(deepMerge(prev, patch));
+        const p = this.getPath();
+        try {
+            const dir = join(p, "..");
+            if (!this.exists(dir))
+                this.mkdirSyncFn(dir, { recursive: true });
+            this.writeFile(p, JSON.stringify(merged, null, 2) + "\n", "utf8");
+        }
+        catch {
+            // best-effort
+        }
+        for (const fn of this.listeners) {
+            try {
+                fn(merged, prev);
+            }
+            catch {
+                // subscriber error should not break store
+            }
+        }
+        return merged;
     }
-    catch (err) {
-        console.warn(`[pi-skill-desc] config parse error (${path}): ${err instanceof Error ? err.message : String(err)} — using defaults`);
-        return structuredClone(DEFAULT_CONFIG);
+    subscribe(fn) {
+        this.listeners.add(fn);
+        return () => this.listeners.delete(fn);
     }
 }
+// Default singleton for backward-compat free functions
+const defaultStore = new ConfigStore();
+export function ensureConfigExists() {
+    void defaultStore.get();
+}
+export function loadConfig() {
+    return defaultStore.get();
+}
 export function saveConfig(patch) {
-    const current = loadConfig();
-    const merged = validate(deepMerge(current, patch));
-    const path = getConfigPath();
-    try {
-        const dir = join(path, "..");
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        writeFileSync(path, JSON.stringify(merged, null, 2) + "\n", "utf8");
-    }
-    catch {
-        // best-effort
-    }
-    return merged;
+    return defaultStore.patch(patch);
 }

package/dist/cursor-policy.js

@@ -0,0 +1,77 @@
+import { CURSOR_MARKER } from "@earendil-works/pi-tui";
+const CURSOR_STYLE_SEQUENCES = {
+    bar: "\x1b[6 q",
+    underline: "\x1b[4 q",
+};
+const DEFAULT_CURSOR_STYLE_SEQUENCE = "\x1b[0 q";
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function removeSoftwareCursor(line, cursorMarker = "") {
+    return line.replace(/\x1b\[7m([\s\S]*?)\x1b\[0m/g, (_match, cursor) => {
+        const replacement = `${cursorMarker}${cursor}`;
+        cursorMarker = "";
+        return replacement;
+    });
+}
+function configureCursor(tui, cursorStyle) {
+    if (cursorStyle === "block")
+        return;
+    const setShow = tui.setShowHardwareCursor;
+    if (typeof setShow === "function")
+        setShow.call(tui, true);
+    const seq = CURSOR_STYLE_SEQUENCES[cursorStyle];
+    const term = tui
+        .terminal;
+    if (seq && term && typeof term.write === "function")
+        term.write(seq);
+}
+/**
+ * CursorPolicy — owns cursor style + hardware cursor juggling behind one seam.
+ * Previously tangled inside TrackingEditor; now a deep collaborator injected
+ * into the editor. Interface is the test surface.
+ */
+export class CursorPolicy {
+    tui;
+    style = "block";
+    previewHardwareCursor = false;
+    constructor(tui) {
+        this.tui = tui;
+    }
+    getStyle() {
+        return this.style;
+    }
+    setStyle(style) {
+        const changed = style !== this.style;
+        this.previewHardwareCursor = style !== "block";
+        this.style = style;
+        if (changed) {
+            const tuiAny = this.tui;
+            if (style === "block") {
+                if (tuiAny.terminal)
+                    tuiAny.terminal.write(DEFAULT_CURSOR_STYLE_SEQUENCE);
+                if (typeof tuiAny.setShowHardwareCursor === "function")
+                    tuiAny.setShowHardwareCursor(false);
+            }
+            else {
+                configureCursor(this.tui, style);
+            }
+        }
+    }
+    // Called by TrackingEditor.renderBase — removes software cursor and injects hardware marker when needed
+    mapLines(lines, isFocused) {
+        if (this.style === "block")
+            return lines;
+        let cursorMarker = this.previewHardwareCursor && !isFocused ? CURSOR_MARKER : "";
+        if (isFocused)
+            this.previewHardwareCursor = false;
+        return lines.map((line) => {
+            const rendered = removeSoftwareCursor(line, cursorMarker);
+            if (rendered !== line)
+                cursorMarker = "";
+            return rendered;
+        });
+    }
+}
+export { configureCursor, removeSoftwareCursor };
+export const __testing = { stripAnsi };

package/dist/footer-controller.js

@@ -0,0 +1,70 @@
+import { readGitStatus } from "./git.js";
+import { readRuntimeInfo } from "./runtime.js";
+import { createInitialState } from "./state.js";
+/**
+ * FooterController — deep module owning FooterState + git/runtime polling behind one seam.
+ * Previously FooterState lived in index.ts and callers had to orchestrate readGitStatus/readRuntimeInfo
+ * and merge into state. Now all that hides behind Controller.
+ *
+ * Interface is the test surface: new FooterController({ getCwd }) → { getState, refresh, setWorking, setDone }
+ * The rendering adapter (setFooter vs setWidget) is also hidden inside install path (two adapters → real seam).
+ */
+export class FooterController {
+    state = createInitialState();
+    getCwd;
+    constructor(opts) {
+        this.getCwd = opts.getCwd;
+        if (opts.initialState)
+            this.state = opts.initialState;
+    }
+    getState() {
+        return this.state;
+    }
+    setWorking(since) {
+        this.state = {
+            ...this.state,
+            workingSince: since,
+            lastDoneIn: since === undefined ? this.state.lastDoneIn : undefined,
+        };
+    }
+    setDone(doneIn) {
+        this.state = { ...this.state, lastDoneIn: doneIn, workingSince: undefined };
+    }
+    async refreshGit() {
+        try {
+            const cwd = this.getCwd();
+            const git = await readGitStatus(cwd);
+            this.state = { ...this.state, git };
+        }
+        catch {
+            // best-effort
+        }
+    }
+    async refreshRuntime() {
+        try {
+            const cwd = this.getCwd();
+            const runtime = await readRuntimeInfo(cwd);
+            this.state = { ...this.state, runtime };
+        }
+        catch {
+            // best-effort
+        }
+    }
+    async refreshAll() {
+        await this.refreshGit();
+        await this.refreshRuntime();
+    }
+}
+/**
+ * createFooter — deep public factory.
+ * Owns polling and state; callers supply only getCwd/getConfig/getContextUsage.
+ * Keeps renderFooter pure as internal seam.
+ */
+export function createFooter(opts) {
+    const ctrl = new FooterController({ getCwd: opts.getCwd });
+    return {
+        controller: ctrl,
+        getState: () => ctrl.getState(),
+        refresh: () => ctrl.refreshAll(),
+    };
+}

package/dist/footer.js

@@ -1,7 +1,10 @@
 import { truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
 import { getUsageTotals } from "./state.js";
-import { resolveGlyphs, resolveIconMode, runtimeSymbol } from "./icons.js";
-import { alignRight, basenamePath, cacheHitColor, fitSegmentsByPriority, fmtTokens, formatCwd, formatDuration, formatProviderLabel, sanitizeStatus, stressColor, truncateBranch, truncatePath, } from "./utils.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 { 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;
@@ -13,6 +16,18 @@ function renderBar(theme, pct, barWidth, ascii) {
         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) {
     const parts = [];
     if (segments.gitBranch) {
@@ -87,13 +102,6 @@ export function renderFooter(width, state, config, theme, ctx) {
         cost: 0,
         latestCacheHitRate: undefined,
     };
-    const meta = ctx.getModelMeta
-        ? ctx.getModelMeta()
-        : {
-            provider: formatProviderLabel(ctx.model?.provider),
-            model: ctx.model?.name ?? ctx.model?.id ?? "no-model",
-            effort: undefined,
-        };
     const leftParts = [];
     if (segments.cwd) {
         const maxCwd = Math.min(30, Math.max(10, Math.floor(width * 0.4)));
@@ -151,35 +159,14 @@ export function renderFooter(width, state, config, theme, ctx) {
         }
     }
     if (segments.cost) {
-        stats.push(theme.fg("warning", `${glyphs.cost} $${totals.cost.toFixed(3)}`));
+        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}`;
+        stats.push(theme.fg("warning", costText));
     }
     const statsBlock = stats.join(` ${theme.fg("dim", "|")} `);
-    // Context
-    let contextText = "";
-    let contextCompact;
-    if (segments.context) {
-        const contextUsage = ctx.contextUsage;
-        const contextWindow = contextUsage?.contextWindow ?? 0;
-        if (contextWindow > 0) {
-            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 reserved = visibleWidth(contextIcon) +
-                visibleWidth(pctText) +
-                visibleWidth(ctxText) +
-                7;
-            const barWidth = Math.max(4, Math.min(12, width - reserved));
-            contextText = `${contextIcon} ${renderBar(theme, contextPct, barWidth, resolveIconMode(config.icons.mode) === "ascii")} ${pctText} ${theme.fg("dim", "·")} ${ctxText}`;
-            const compact = `${theme.fg(stressColor(contextPct), glyphs.context)} ${theme.fg(stressColor(contextPct), `${contextPct.toFixed(1)}%`)}`;
-            if (visibleWidth(compact) < visibleWidth(contextText))
-                contextCompact = compact;
-        }
-    }
-    // Tokens right next to context bar (user request): combine them as single right block
-    const rightBlock = [statsBlock, contextText].filter(Boolean).join("  ");
-    const rightCompact = statsBlock && contextCompact ? `${statsBlock}  ${contextCompact}` : statsBlock || contextCompact;
+    const rightBlock = statsBlock;
+    const rightCompact = statsBlock;
     const allParts = [...leftParts];
     if (rightBlock) {
         allParts.push({