pi-editor-footer 0.1.2 → 0.3.0

package/CHANGELOG.md

@@ -4,20 +4,70 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [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
+
+- 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,194 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { buildLabel, } 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: model info left, context bar right of it, run-activity far right
+        const hasTop = opts.glowEnabled || opts.topRightText || opts.topContextText;
+        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 {
+                    // ignore
+                }
+                return s;
+            };
+            if (opts.glowEnabled) {
+                // 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 (opts.topRightText) {
+                    out = embedTopWithLeftAndRight(out, width, leftLabel, opts.topRightText, 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);
+                }
+            }
+            else if (opts.topContextText || opts.topRightText) {
+                // No glow, but still need top borders for context/run activity
+                const left = opts.topContextText ?? "";
+                const right = opts.topRightText ?? "";
+                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);
+                }
+            }
+        }
+        // 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 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;
+    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

@@ -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();
@@ -63,69 +70,137 @@ 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;
+    }
+    if (!isBoolean(config.contextIconBar)) {
+        config.contextIconBar = DEFAULT_CONFIG.contextIconBar;
+    }
+    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];
+    }
+    const tl = config.timeline;
+    const dtl = DEFAULT_CONFIG.timeline;
+    if (!tl || typeof tl !== "object") {
+        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 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");
-    }
-    catch {
-        // best-effort
+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;
     }
-}
-export function loadConfig() {
-    const path = getConfigPath();
-    if (!existsSync(path)) {
-        ensureConfigExists();
-        return structuredClone(DEFAULT_CONFIG);
+    getPath() {
+        return this.explicitPath ?? getConfigPath();
     }
-    try {
-        const raw = readFileSync(path, "utf8");
-        const parsed = JSON.parse(raw);
-        const merged = deepMerge(structuredClone(DEFAULT_CONFIG), parsed);
-        return validate(merged);
+    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);
+        }
     }
-    catch (err) {
-        console.warn(`[pi-skill-desc] config parse error (${path}): ${err instanceof Error ? err.message : String(err)} — using defaults`);
-        return structuredClone(DEFAULT_CONFIG);
+    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;
+    }
+    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(),
+    };
+}