pi-editor-footer 0.8.0 → 0.11.0

package/CHANGELOG.md

@@ -4,6 +4,32 @@ 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

package/dist/agent-run-ledger.js

@@ -15,11 +15,29 @@
  * / 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
@@ -65,7 +83,7 @@ export function aggregateAgentTurns(turns, live, startMs, now) {
             ttftMs = live.ttftMs;
     }
     totalTokens = inputTokens + outputTokens;
-    const totalMs = startMs !== null ? Math.max(0, now - startMs) : 0;
+    const totalMs = startMs === null ? 0 : Math.max(0, now - startMs);
     const measurementMs = outputTokens > 0 && generationMs > 0 ? generationMs : null;
     const tps = measurementMs === null
         ? null
@@ -131,6 +149,10 @@ export class AgentRunLedger {
     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;
     }
@@ -144,10 +166,54 @@ export class AgentRunLedger {
     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) {
@@ -231,9 +297,46 @@ export class AgentRunLedger {
             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)
@@ -260,10 +363,61 @@ export class AgentRunLedger {
             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;

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-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 {

package/dist/config.js

@@ -99,6 +99,7 @@ export const CONFIG_SCHEMA = [
     { path: "timeline.tokens", kind: "boolean" },
     { path: "timeline.cost", kind: "boolean" },
 ];
+// SAFETY: table-driven config access — path validated against CONFIG_SCHEMA, caller validates via validate()
 function getByPath(obj, path) {
     const parts = path.split(".");
     let cur = obj;
@@ -123,6 +124,7 @@ function setByPath(obj, path, value) {
     }
     cur[parts[parts.length - 1]] = value;
 }
+// SAFETY: table-driven config access — path validated against CONFIG_SCHEMA, caller validates via validate()
 function getDefaultByPath(path) {
     return getByPath(DEFAULT_CONFIG, path);
 }

package/dist/detail-chrome.js

@@ -1,3 +1,21 @@
+/**
+ * DetailChrome — deep module owning the whole Detail-window flow behind one seam.
+ *
+ * Previously the Highlight → Detail window flow was fragmented: TrackingEditor
+ * observed the Candidate highlight, src/index.ts held widget state
+ * (currentItem/scrollOffset/lastWidth), scroll math, and header-marker
+ * re-parsing (contentLinesFrom); src/detail-render.ts owned wrapping;
+ * src/window-presentation.ts owned the border. Fixing a wrapping bug required
+ * holding 3 modules in one head — no locality.
+ *
+ * Depth: small interface (setItem / getItem / scrollBy / render) hides scroll
+ * offset, width, MAX_LINES, wrapping, border, and header-marker parsing inside.
+ * detail-render + window-presentation are INTERNAL seams, not part of the
+ * interface. One place to learn — one place to test, no TUI needed.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import { contentLineCount, renderDetail, scroll, } from "./detail-render.js";
 import { decorateWindow } from "./window-presentation.js";
 /** Height cap of the detail window (the user's spec: up to 5 lines). */
@@ -6,12 +24,65 @@ export const MAX_LINES = 5;
 function kindOf(value) {
     return value.startsWith("skill:") ? "skill" : "command";
 }
+function resolveSkillPath(skillName) {
+    const name = skillName.trim();
+    if (!name)
+        return undefined;
+    const candidates = [];
+    const cwd = process.cwd();
+    const home = (() => {
+        try {
+            return os.homedir();
+        }
+        catch {
+            return "";
+        }
+    })();
+    // project-local candidates
+    candidates.push(path.join(cwd, ".pi", "agent", "skills", name, "SKILL.md"));
+    candidates.push(path.join(cwd, ".agents", "skills", name, "SKILL.md"));
+    candidates.push(path.join(cwd, ".pi", "skills", name, "SKILL.md"));
+    candidates.push(path.join(cwd, "skills", name, "SKILL.md"));
+    // user-global candidates
+    if (home) {
+        candidates.push(path.join(home, ".pi", "agent", "skills", name, "SKILL.md"));
+        candidates.push(path.join(home, ".agents", "skills", name, "SKILL.md"));
+        candidates.push(path.join(home, ".pi", ".agents", "skills", name, "SKILL.md"));
+        candidates.push(path.join(home, ".pi", "skills", name, "SKILL.md"));
+        candidates.push(path.join(home, "stowfiles", "dotfiles", ".pi", "agent", "skills", name, "SKILL.md"));
+        candidates.push(path.join(home, "stowfiles", "dotfiles", ".pi", "agent", ".agents", "skills", name, "SKILL.md"));
+    }
+    for (const p of candidates) {
+        try {
+            if (fs.existsSync(p))
+                return p;
+        }
+        catch {
+            // ignore
+        }
+    }
+    // fallback to global symlink path so header always shows a path for skills
+    if (home)
+        return path.join(home, ".pi", "agent", "skills", name, "SKILL.md");
+    return path.join(cwd, ".pi", "agent", "skills", name, "SKILL.md");
+}
 function detailItemOf(item) {
-    return {
+    const detail = {
         label: item.label,
         kind: kindOf(item.value),
         description: item.description ?? "",
     };
+    const rawPath = item.path?.trim() ?? "";
+    if (rawPath !== "") {
+        detail.path = rawPath;
+    }
+    else if (item.value.startsWith("skill:")) {
+        const skillName = item.value.slice("skill:".length);
+        const resolved = resolveSkillPath(skillName);
+        if (resolved !== undefined)
+            detail.path = resolved;
+    }
+    return detail;
 }
 export class DetailChrome {
     item = null;

package/dist/detail-render.js

@@ -5,6 +5,7 @@
  * lines to render in the 5-line detail window above the input box.
  * No pi imports — this is the single testable seam of the extension.
  */
+import * as os from "node:os";
 /**
  * Rendered lines for the detail window: `[header, ...contentLines]`.
  *
@@ -36,16 +37,40 @@ export function renderDetail(item, width, maxLines, scrollOffset) {
         visibleLines[visibleLines.length - 1] = "...";
     }
     const overflows = contentLines.length > capacity;
-    const namePart = `${item.label} · ${item.kind}`;
+    const base = `${item.label} · ${item.kind}`;
+    const marker = overflows ? ` ${offset + 1}/${contentLines.length}` : "";
+    const markerLen = marker.length;
     let header;
-    if (overflows) {
-        // Reserve room for the scroll marker so it always survives truncation.
-        const marker = ` ${offset + 1}/${contentLines.length}`;
-        const nameWidth = Math.max(0, wrapWidth - marker.length);
-        header = truncateToWidth(namePart, nameWidth) + marker;
+    const rawPath = item.path?.trim() ?? "";
+    if (rawPath !== "") {
+        const normalized = normalizePath(rawPath);
+        const availableForPath = Math.max(0, wrapWidth - base.length - markerLen - 2);
+        let pathSeg = "";
+        if (availableForPath >= 10) {
+            const truncated = normalized.length <= availableForPath
+                ? normalized
+                : truncateMiddle(normalized, availableForPath);
+            pathSeg = `  ${truncated}`;
+        }
+        const totalLen = base.length + pathSeg.length + markerLen;
+        if (totalLen <= wrapWidth) {
+            header = base + pathSeg + marker;
+        }
+        else if (pathSeg !== "") {
+            const baseWidth = Math.max(0, wrapWidth - pathSeg.length - markerLen);
+            header = truncateToWidth(base, baseWidth) + pathSeg + marker;
+        }
+        else {
+            const nameWidth = Math.max(0, wrapWidth - markerLen);
+            header = truncateToWidth(base, nameWidth) + marker;
+        }
+    }
+    else if (overflows) {
+        const nameWidth = Math.max(0, wrapWidth - markerLen);
+        header = truncateToWidth(base, nameWidth) + marker;
     }
     else {
-        header = truncateToWidth(namePart, wrapWidth);
+        header = truncateToWidth(base, wrapWidth);
     }
     return [header, ...visibleLines];
 }
@@ -58,7 +83,8 @@ export function contentLineCount(item, width) {
     if (!item || item.description.trim() === "") {
         return 0;
     }
-    return wrapDescription(item.description, Math.max(1, Math.floor(width))).length;
+    return wrapDescription(item.description, Math.max(1, Math.floor(width)))
+        .length;
 }
 /**
  * Next scroll offset after moving by `delta` (-1 = back/up, +1 = forward/down).
@@ -99,6 +125,44 @@ function wrapDescription(description, width) {
 function truncateToWidth(text, width) {
     return text.length <= width ? text : text.slice(0, width);
 }
+export function normalizePath(raw) {
+    if (!raw)
+        return raw;
+    let p = raw.replace(/\\/g, "/");
+    try {
+        const cwd = process.cwd().replace(/\\/g, "/");
+        if (p === cwd)
+            p = ".";
+        else if (p.startsWith(`${cwd}/`))
+            p = p.slice(cwd.length + 1);
+        else {
+            const home = os.homedir();
+            if (home) {
+                const homePosix = home.replace(/\\/g, "/");
+                if (p === homePosix)
+                    p = "~";
+                else if (p.startsWith(`${homePosix}/`))
+                    p = `~${p.slice(homePosix.length)}`;
+            }
+        }
+    }
+    catch {
+        // ignore homedir/cwd failures
+    }
+    return p;
+}
+export function truncateMiddle(text, maxWidth) {
+    if (text.length <= maxWidth)
+        return text;
+    if (maxWidth <= 1)
+        return text.slice(0, maxWidth);
+    if (maxWidth === 2)
+        return `${text.slice(0, 1)}…`;
+    const keep = maxWidth - 1;
+    const left = Math.ceil(keep / 2);
+    const right = Math.floor(keep / 2);
+    return `${text.slice(0, left)}…${text.slice(text.length - right)}`;
+}
 function clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
 }

package/dist/footer.js

@@ -188,8 +188,9 @@ export function installFooter(ctx, getState, getConfig, getModelMeta, hooks) {
         const config = getConfig();
         const cwd = ctx.sessionManager?.getCwd() ?? process.cwd();
         const totals = getUsageTotals(
+        // ast-grep-ignore: require-safety-comment-for-as-unknown-as
         // SAFETY: pi seam — intentional unsafe cast, validated at runtime
-        ctx);
+        /* SAFETY: intentional unsafe cast — validated at runtime */ ctx);
         return renderFooter(width, state, config, themeStub, {
             cwd,
             sessionName: ctx.sessionManager?.getSessionName?.(),
@@ -202,10 +203,13 @@ export function installFooter(ctx, getState, getConfig, getModelMeta, hooks) {
     // Prefer native footer if available
     if (
     // SAFETY: pi seam — intentional unsafe cast, validated at runtime
-    typeof ctx.ui.setFooter ===
+    // ast-grep-ignore: require-safety-comment-for-as-unknown-as
+    // SAFETY: intentional unsafe cast — validated at runtime
+    /* SAFETY: intentional unsafe cast — validated at runtime */ typeof /* SAFETY: intentional unsafe cast — validated at runtime */ ctx.ui.setFooter === // SAFETY: intentional unsafe cast — validated at runtime
         "function") {
+        // ast-grep-ignore: require-safety-comment-for-as-unknown-as
         // SAFETY: pi seam — intentional unsafe cast, validated at runtime
-        const ui = ctx.ui;
+        /* SAFETY: intentional unsafe cast — validated at runtime */ const ui = ctx.ui;
         ui.setFooter((tui, _theme, footerData) => {
             hooks.setRequestRender(() => tui.requestRender());
             const unsub = footerData.onBranchChange(() => {
@@ -220,14 +224,16 @@ export function installFooter(ctx, getState, getConfig, getModelMeta, hooks) {
                 invalidate() { },
                 render(width) {
                     // Use real theme when rendering
+                    // ast-grep-ignore: require-safety-comment-for-as-unknown-as
                     // SAFETY: pi seam — intentional unsafe cast, validated at runtime
-                    const theme = _theme;
+                    /* SAFETY: intentional unsafe cast — validated at runtime */ const theme = _theme; // SAFETY: intentional unsafe cast — validated at runtime
                     const state = getState();
                     const config = getConfig();
                     const cwd = ctx.sessionManager?.getCwd() ?? process.cwd();
                     const totals = getUsageTotals(
+                    // ast-grep-ignore: require-safety-comment-for-as-unknown-as
                     // SAFETY: pi seam — intentional unsafe cast, validated at runtime
-                    ctx);
+                    /* SAFETY: intentional unsafe cast — validated at runtime */ ctx);
                     return renderFooter(width, state, config, theme, {
                         cwd,
                         sessionName: ctx.sessionManager?.getSessionName?.(),
@@ -241,8 +247,10 @@ export function installFooter(ctx, getState, getConfig, getModelMeta, hooks) {
             };
         });
         return () => {
+            // ast-grep-ignore: require-safety-comment-for-as-unknown-as
             // SAFETY: pi seam — intentional unsafe cast, validated at runtime
-            ctx.ui.setFooter(undefined);
+            /* SAFETY: intentional unsafe cast — validated at runtime */ ctx.ui.setFooter(// SAFETY: intentional unsafe cast — validated at runtime
+            undefined);
         };
     }
     // Fallback: widget belowEditor

package/dist/live-border.js

@@ -58,7 +58,10 @@ export class LiveBorder {
         const comp = this.composition();
         if (!comp)
             return;
-        const snapshot = createChromeSnapshot(ctx, // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+        // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+        const snapshot = createChromeSnapshot(
+        // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+        ctx, // SAFETY: pi seam — intentional unsafe cast, validated at runtime
         undefined);
         this.refreshTopBorder(comp);
         this.refreshLiveTelemetry(comp);
@@ -179,9 +182,8 @@ export class LiveBorder {
             if (cfg.footerSegments.context &&
                 snapshot.contextUsage &&
                 snapshot.contextUsage.contextWindow) {
-                contextText = comp.formatTopContext(snapshot, 
-                // SAFETY: intentional unsafe cast — validated at runtime
-                cfg.contextIconBar ?? // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+                // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+                contextText = comp.formatTopContext(snapshot, cfg.contextIconBar ?? // SAFETY: pi seam — intentional unsafe cast, validated at runtime
                     false);
             }
             let tokensText = "";
@@ -189,15 +191,15 @@ export class LiveBorder {
                 const isRunning = this.deps.runActivityTracker.isRunning();
                 const contextTokens = snapshot.contextUsage?.tokens;
                 if (!isRunning) {
-                    const telIdle = this.deps.agentLedger.getLiveTotals(this.deps.telemetryTracker.peekLive()) ?? this.deps.telemetryTracker.getLastTelemetry();
-                    const display = this.deps.agentLedger.getIdleDisplayTotals(snapshot.totals, contextTokens, telIdle);
+                    // Hybrid Q7 b: idle shows authoritative billed total (no ~), live shows synthetic incremental (~)
+                    const display = this.deps.agentLedger.getIdleAuthoritativeDisplay(snapshot.totals, contextTokens);
                     tokensText = comp.formatTelemetryTokens(display, cfg.telemetry);
                 }
                 else {
                     const liveTurn = this.deps.telemetryTracker.peekLive();
                     const agentLive = this.deps.agentLedger.getLiveTotals(liveTurn) ??
                         this.deps.telemetryTracker.getLastTelemetry();
-                    const display = this.deps.agentLedger.getLiveDisplayTotals(liveTurn, agentLive, contextTokens);
+                    const display = this.deps.agentLedger.getIncrementalLiveDisplayTotals(liveTurn, agentLive, contextTokens);
                     if (display) {
                         tokensText = comp.formatTelemetryTokens(display, cfg.telemetry);
                     }