gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/gsd/auto/session.js

@@ -0,0 +1,182 @@
+/**
+ * AutoSession — encapsulates all mutable auto-mode state into a single instance.
+ *
+ * Replaces ~40 module-level variables scattered across auto.ts with typed
+ * properties on a class instance. Benefits:
+ *
+ * - reset() clears everything in one call (was 25+ manual resets in stopAuto)
+ * - toJSON() provides diagnostic snapshots
+ * - grep `s.` shows every state access
+ * - Constructable for testing
+ *
+ * MAINTENANCE RULE: All new mutable auto-mode state MUST be added here as a
+ * class property, not as a module-level variable in auto.ts. If the state
+ * needs clearing on stop, add it to reset(). Tests in
+ * auto-session-encapsulation.test.ts enforce that auto.ts has no module-level
+ * `let` or `var` declarations.
+ */
+// ─── Constants ───────────────────────────────────────────────────────────────
+export const MAX_UNIT_DISPATCHES = 3;
+export const STUB_RECOVERY_THRESHOLD = 2;
+export const MAX_LIFETIME_DISPATCHES = 6;
+export const NEW_SESSION_TIMEOUT_MS = 30_000;
+// ─── AutoSession ─────────────────────────────────────────────────────────────
+export class AutoSession {
+    // ── Lifecycle ────────────────────────────────────────────────────────────
+    active = false;
+    paused = false;
+    stepMode = false;
+    verbose = false;
+    cmdCtx = null;
+    // ── Paths ────────────────────────────────────────────────────────────────
+    basePath = "";
+    originalBasePath = "";
+    gitService = null;
+    // ── Dispatch counters ────────────────────────────────────────────────────
+    unitDispatchCount = new Map();
+    unitLifetimeDispatches = new Map();
+    unitRecoveryCount = new Map();
+    // ── Timers ───────────────────────────────────────────────────────────────
+    unitTimeoutHandle = null;
+    wrapupWarningHandle = null;
+    idleWatchdogHandle = null;
+    continueHereHandle = null;
+    // ── Current unit ─────────────────────────────────────────────────────────
+    currentUnit = null;
+    currentUnitRouting = null;
+    completedUnits = [];
+    currentMilestoneId = null;
+    // ── Model state ──────────────────────────────────────────────────────────
+    autoModeStartModel = null;
+    originalModelId = null;
+    originalModelProvider = null;
+    lastBudgetAlertLevel = 0;
+    // ── Recovery ─────────────────────────────────────────────────────────────
+    pendingCrashRecovery = null;
+    pendingVerificationRetry = null;
+    verificationRetryCount = new Map();
+    pausedSessionFile = null;
+    resourceVersionOnStart = null;
+    lastStateRebuildAt = 0;
+    // ── Sidecar queue ─────────────────────────────────────────────────────
+    sidecarQueue = [];
+    // ── Metrics ──────────────────────────────────────────────────────────────
+    autoStartTime = 0;
+    lastPromptCharCount;
+    lastBaselineCharCount;
+    pendingQuickTasks = [];
+    // ── Signal handler ───────────────────────────────────────────────────────
+    sigtermHandler = null;
+    // ── Loop promise state ──────────────────────────────────────────────────
+    /**
+     * True only while runUnit is rotating into a fresh session. agent_end events
+     * emitted from the previous session's abort during this window must be
+     * ignored; they do not belong to the new unit.
+     */
+    sessionSwitchInFlight = false;
+    /**
+     * One-shot resolver for the current unit's agent_end promise.
+     * Non-null only while a unit is in-flight (between sendMessage and agent_end).
+     * Scoped to the session to prevent concurrent session corruption.
+     */
+    pendingResolve = null;
+    /**
+     * Queue for agent_end events that arrive when no pendingResolve exists.
+     * This happens when error-recovery sendMessage retries produce agent_end
+     * events between loop iterations. The next runUnit drains this queue
+     * instead of waiting for a new event.
+     */
+    pendingAgentEndQueue = [];
+    // ── Methods ──────────────────────────────────────────────────────────────
+    clearTimers() {
+        if (this.unitTimeoutHandle) {
+            clearTimeout(this.unitTimeoutHandle);
+            this.unitTimeoutHandle = null;
+        }
+        if (this.wrapupWarningHandle) {
+            clearTimeout(this.wrapupWarningHandle);
+            this.wrapupWarningHandle = null;
+        }
+        if (this.idleWatchdogHandle) {
+            clearInterval(this.idleWatchdogHandle);
+            this.idleWatchdogHandle = null;
+        }
+        if (this.continueHereHandle) {
+            clearInterval(this.continueHereHandle);
+            this.continueHereHandle = null;
+        }
+    }
+    resetDispatchCounters() {
+        this.unitDispatchCount.clear();
+        this.unitLifetimeDispatches.clear();
+    }
+    get lockBasePath() {
+        return this.originalBasePath || this.basePath;
+    }
+    completeCurrentUnit() {
+        if (!this.currentUnit)
+            return null;
+        const done = { ...this.currentUnit, finishedAt: Date.now() };
+        this.completedUnits.push(done);
+        this.currentUnit = null;
+        return done;
+    }
+    reset() {
+        this.clearTimers();
+        // Lifecycle
+        this.active = false;
+        this.paused = false;
+        this.stepMode = false;
+        this.verbose = false;
+        this.cmdCtx = null;
+        // Paths
+        this.basePath = "";
+        this.originalBasePath = "";
+        this.gitService = null;
+        // Dispatch
+        this.unitDispatchCount.clear();
+        this.unitLifetimeDispatches.clear();
+        this.unitRecoveryCount.clear();
+        // Unit
+        this.currentUnit = null;
+        this.currentUnitRouting = null;
+        this.completedUnits = [];
+        this.currentMilestoneId = null;
+        // Model
+        this.autoModeStartModel = null;
+        this.originalModelId = null;
+        this.originalModelProvider = null;
+        this.lastBudgetAlertLevel = 0;
+        // Recovery
+        this.pendingCrashRecovery = null;
+        this.pendingVerificationRetry = null;
+        this.verificationRetryCount.clear();
+        this.pausedSessionFile = null;
+        this.resourceVersionOnStart = null;
+        this.lastStateRebuildAt = 0;
+        // Metrics
+        this.autoStartTime = 0;
+        this.lastPromptCharCount = undefined;
+        this.lastBaselineCharCount = undefined;
+        this.pendingQuickTasks = [];
+        this.sidecarQueue = [];
+        // Signal handler
+        this.sigtermHandler = null;
+        // Loop promise state
+        this.sessionSwitchInFlight = false;
+        this.pendingResolve = null;
+        this.pendingAgentEndQueue = [];
+    }
+    toJSON() {
+        return {
+            active: this.active,
+            paused: this.paused,
+            stepMode: this.stepMode,
+            basePath: this.basePath,
+            currentMilestoneId: this.currentMilestoneId,
+            currentUnit: this.currentUnit,
+            completedUnits: this.completedUnits.length,
+            unitDispatchCount: Object.fromEntries(this.unitDispatchCount),
+        };
+    }
+}

package/dist/resources/extensions/gsd/auto-budget.js

@@ -0,0 +1,30 @@
+/**
+ * Budget alert level tracking and enforcement for auto-mode.
+ * Pure functions — no module state or side effects.
+ */
+export function getBudgetAlertLevel(budgetPct) {
+    if (budgetPct >= 1.0)
+        return 100;
+    if (budgetPct >= 0.90)
+        return 90;
+    if (budgetPct >= 0.80)
+        return 80;
+    if (budgetPct >= 0.75)
+        return 75;
+    return 0;
+}
+export function getNewBudgetAlertLevel(previousLevel, budgetPct) {
+    const currentLevel = getBudgetAlertLevel(budgetPct);
+    if (currentLevel === 0 || currentLevel <= previousLevel)
+        return null;
+    return currentLevel;
+}
+export function getBudgetEnforcementAction(enforcement, budgetPct) {
+    if (budgetPct < 1.0)
+        return "none";
+    if (enforcement === "halt")
+        return "halt";
+    if (enforcement === "pause")
+        return "pause";
+    return "warn";
+}

package/dist/resources/extensions/gsd/auto-dashboard.js

@@ -0,0 +1,429 @@
+/**
+ * Auto-mode Dashboard — progress widget rendering, elapsed time formatting,
+ * unit description helpers, and slice progress caching.
+ *
+ * Pure functions that accept specific parameters — no module-level globals
+ * or AutoContext dependency. State accessors are passed as callbacks.
+ */
+import { getCurrentBranch } from "./worktree.js";
+import { getActiveHook } from "./post-unit-hooks.js";
+import { getLedger, getProjectTotals, formatTierSavings } from "./metrics.js";
+import { resolveMilestoneFile, resolveSliceFile, } from "./paths.js";
+import { parseRoadmap, parsePlan } from "./files.js";
+import { readFileSync, existsSync } from "node:fs";
+import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
+import { makeUI, GLYPH, INDENT } from "../shared/mod.js";
+// ─── Unit Description Helpers ─────────────────────────────────────────────────
+export function unitVerb(unitType) {
+    if (unitType.startsWith("hook/"))
+        return `hook: ${unitType.slice(5)}`;
+    switch (unitType) {
+        case "research-milestone":
+        case "research-slice": return "researching";
+        case "plan-milestone":
+        case "plan-slice": return "planning";
+        case "execute-task": return "executing";
+        case "complete-slice": return "completing";
+        case "replan-slice": return "replanning";
+        case "rewrite-docs": return "rewriting";
+        case "reassess-roadmap": return "reassessing";
+        case "run-uat": return "running UAT";
+        default: return unitType;
+    }
+}
+export function unitPhaseLabel(unitType) {
+    if (unitType.startsWith("hook/"))
+        return "HOOK";
+    switch (unitType) {
+        case "research-milestone": return "RESEARCH";
+        case "research-slice": return "RESEARCH";
+        case "plan-milestone": return "PLAN";
+        case "plan-slice": return "PLAN";
+        case "execute-task": return "EXECUTE";
+        case "complete-slice": return "COMPLETE";
+        case "replan-slice": return "REPLAN";
+        case "rewrite-docs": return "REWRITE";
+        case "reassess-roadmap": return "REASSESS";
+        case "run-uat": return "UAT";
+        default: return unitType.toUpperCase();
+    }
+}
+function peekNext(unitType, state) {
+    // Show active hook info in progress display
+    const activeHookState = getActiveHook();
+    if (activeHookState) {
+        return `hook: ${activeHookState.hookName} (cycle ${activeHookState.cycle})`;
+    }
+    const sid = state.activeSlice?.id ?? "";
+    if (unitType.startsWith("hook/"))
+        return `continue ${sid}`;
+    switch (unitType) {
+        case "research-milestone": return "plan milestone roadmap";
+        case "plan-milestone": return "plan or execute first slice";
+        case "research-slice": return `plan ${sid}`;
+        case "plan-slice": return "execute first task";
+        case "execute-task": return `continue ${sid}`;
+        case "complete-slice": return "reassess roadmap";
+        case "replan-slice": return `re-execute ${sid}`;
+        case "rewrite-docs": return "continue execution";
+        case "reassess-roadmap": return "advance to next slice";
+        case "run-uat": return "reassess roadmap";
+        default: return "";
+    }
+}
+/**
+ * Describe what the next unit will be, based on current state.
+ */
+export function describeNextUnit(state) {
+    const sid = state.activeSlice?.id;
+    const sTitle = state.activeSlice?.title;
+    const tid = state.activeTask?.id;
+    const tTitle = state.activeTask?.title;
+    switch (state.phase) {
+        case "needs-discussion":
+            return { label: "Discuss milestone draft", description: "Milestone has a draft context — needs discussion before planning." };
+        case "pre-planning":
+            return { label: "Research & plan milestone", description: "Scout the landscape and create the roadmap." };
+        case "planning":
+            return { label: `Plan ${sid}: ${sTitle}`, description: "Research and decompose into tasks." };
+        case "executing":
+            return { label: `Execute ${tid}: ${tTitle}`, description: "Run the next task in a fresh session." };
+        case "summarizing":
+            return { label: `Complete ${sid}: ${sTitle}`, description: "Write summary, UAT, and merge to main." };
+        case "replanning-slice":
+            return { label: `Replan ${sid}: ${sTitle}`, description: "Blocker found — replan the slice." };
+        case "completing-milestone":
+            return { label: "Complete milestone", description: "Write milestone summary." };
+        default:
+            return { label: "Continue", description: "Execute the next step." };
+    }
+}
+// ─── Elapsed Time Formatting ──────────────────────────────────────────────────
+/** Format elapsed time since auto-mode started */
+export function formatAutoElapsed(autoStartTime) {
+    if (!autoStartTime)
+        return "";
+    const ms = Date.now() - autoStartTime;
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    const rs = s % 60;
+    if (m < 60)
+        return `${m}m${rs > 0 ? ` ${rs}s` : ""}`;
+    const h = Math.floor(m / 60);
+    const rm = m % 60;
+    return `${h}h ${rm}m`;
+}
+/** Format token counts for compact display */
+export function formatWidgetTokens(count) {
+    if (count < 1000)
+        return count.toString();
+    if (count < 10000)
+        return `${(count / 1000).toFixed(1)}k`;
+    if (count < 1000000)
+        return `${Math.round(count / 1000)}k`;
+    if (count < 10000000)
+        return `${(count / 1000000).toFixed(1)}M`;
+    return `${Math.round(count / 1000000)}M`;
+}
+// ─── ETA Estimation ──────────────────────────────────────────────────────────
+/**
+ * Estimate remaining time based on average unit duration from the metrics ledger.
+ * Returns a formatted string like "~12m remaining" or null if insufficient data.
+ */
+export function estimateTimeRemaining() {
+    const ledger = getLedger();
+    if (!ledger || ledger.units.length < 2)
+        return null;
+    const sliceProgress = getRoadmapSlicesSync();
+    if (!sliceProgress || sliceProgress.total === 0)
+        return null;
+    const remainingSlices = sliceProgress.total - sliceProgress.done;
+    if (remainingSlices <= 0)
+        return null;
+    // Compute average duration per completed slice from the ledger
+    const completedSliceUnits = ledger.units.filter(u => u.finishedAt > 0 && u.startedAt > 0);
+    if (completedSliceUnits.length < 2)
+        return null;
+    const totalDuration = completedSliceUnits.reduce((sum, u) => sum + (u.finishedAt - u.startedAt), 0);
+    const avgDuration = totalDuration / completedSliceUnits.length;
+    // Rough estimate: remaining slices × average units per slice × avg duration
+    const completedSlices = sliceProgress.done || 1;
+    const unitsPerSlice = completedSliceUnits.length / completedSlices;
+    const estimatedMs = remainingSlices * unitsPerSlice * avgDuration;
+    if (estimatedMs < 5_000)
+        return null; // Too small to display
+    const s = Math.floor(estimatedMs / 1000);
+    if (s < 60)
+        return `~${s}s remaining`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `~${m}m remaining`;
+    const h = Math.floor(m / 60);
+    const rm = m % 60;
+    return rm > 0 ? `~${h}h ${rm}m remaining` : `~${h}h remaining`;
+}
+// ─── Slice Progress Cache ─────────────────────────────────────────────────────
+/** Cached slice progress for the widget — avoid async in render */
+let cachedSliceProgress = null;
+export function updateSliceProgressCache(base, mid, activeSid) {
+    try {
+        const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
+        if (!roadmapFile)
+            return;
+        const content = readFileSync(roadmapFile, "utf-8");
+        const roadmap = parseRoadmap(content);
+        let activeSliceTasks = null;
+        if (activeSid) {
+            try {
+                const planFile = resolveSliceFile(base, mid, activeSid, "PLAN");
+                if (planFile && existsSync(planFile)) {
+                    const planContent = readFileSync(planFile, "utf-8");
+                    const plan = parsePlan(planContent);
+                    activeSliceTasks = {
+                        done: plan.tasks.filter(t => t.done).length,
+                        total: plan.tasks.length,
+                    };
+                }
+            }
+            catch {
+                // Non-fatal — just omit task count
+            }
+        }
+        cachedSliceProgress = {
+            done: roadmap.slices.filter(s => s.done).length,
+            total: roadmap.slices.length,
+            milestoneId: mid,
+            activeSliceTasks,
+        };
+    }
+    catch {
+        // Non-fatal — widget just won't show progress bar
+    }
+}
+export function getRoadmapSlicesSync() {
+    return cachedSliceProgress;
+}
+export function clearSliceProgressCache() {
+    cachedSliceProgress = null;
+}
+// ─── Footer Factory ───────────────────────────────────────────────────────────
+/**
+ * Footer factory that renders zero lines — hides the built-in footer entirely.
+ * All footer info (pwd, branch, tokens, cost, model) is shown inside the
+ * progress widget instead, so there's no gap or redundancy.
+ */
+export const hideFooter = () => ({
+    render(_width) { return []; },
+    invalidate() { },
+    dispose() { },
+});
+export function updateProgressWidget(ctx, unitType, unitId, state, accessors, tierBadge) {
+    if (!ctx.hasUI)
+        return;
+    const verb = unitVerb(unitType);
+    const phaseLabel = unitPhaseLabel(unitType);
+    const mid = state.activeMilestone;
+    const slice = state.activeSlice;
+    const task = state.activeTask;
+    const next = peekNext(unitType, state);
+    // Cache git branch at widget creation time (not per render)
+    let cachedBranch = null;
+    try {
+        cachedBranch = getCurrentBranch(accessors.getBasePath());
+    }
+    catch { /* not in git repo */ }
+    // Cache pwd with ~ substitution
+    let widgetPwd = process.cwd();
+    const widgetHome = process.env.HOME || process.env.USERPROFILE;
+    if (widgetHome && widgetPwd.startsWith(widgetHome)) {
+        widgetPwd = `~${widgetPwd.slice(widgetHome.length)}`;
+    }
+    if (cachedBranch)
+        widgetPwd = `${widgetPwd} (${cachedBranch})`;
+    ctx.ui.setWidget("gsd-progress", (tui, theme) => {
+        let pulseBright = true;
+        let cachedLines;
+        let cachedWidth;
+        const pulseTimer = setInterval(() => {
+            pulseBright = !pulseBright;
+            cachedLines = undefined;
+            tui.requestRender();
+        }, 800);
+        // Refresh progress cache from disk every 15s so the widget reflects
+        // task/slice completion mid-unit. Without this, the progress bar only
+        // updates at dispatch time, appearing frozen during long-running units.
+        // 15s (vs 5s) reduces synchronous file I/O on the hot path.
+        const progressRefreshTimer = mid ? setInterval(() => {
+            try {
+                updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
+                cachedLines = undefined;
+            }
+            catch { /* non-fatal */ }
+        }, 15_000) : null;
+        return {
+            render(width) {
+                if (cachedLines && cachedWidth === width)
+                    return cachedLines;
+                const ui = makeUI(theme, width);
+                const lines = [];
+                const pad = INDENT.base;
+                // ── Line 1: Top bar ───────────────────────────────────────────────
+                lines.push(...ui.bar());
+                const dot = pulseBright
+                    ? theme.fg("accent", GLYPH.statusActive)
+                    : theme.fg("dim", GLYPH.statusPending);
+                const elapsed = formatAutoElapsed(accessors.getAutoStartTime());
+                const modeTag = accessors.isStepMode() ? "NEXT" : "AUTO";
+                const headerLeft = `${pad}${dot} ${theme.fg("accent", theme.bold("GSD"))}  ${theme.fg("success", modeTag)}`;
+                const headerRight = elapsed ? theme.fg("dim", elapsed) : "";
+                lines.push(rightAlign(headerLeft, headerRight, width));
+                lines.push("");
+                if (mid) {
+                    lines.push(truncateToWidth(`${pad}${theme.fg("dim", mid.title)}`, width));
+                }
+                if (slice && unitType !== "research-milestone" && unitType !== "plan-milestone") {
+                    lines.push(truncateToWidth(`${pad}${theme.fg("text", theme.bold(`${slice.id}: ${slice.title}`))}`, width));
+                }
+                lines.push("");
+                const target = task ? `${task.id}: ${task.title}` : unitId;
+                const actionLeft = `${pad}${theme.fg("accent", "▸")} ${theme.fg("accent", verb)}  ${theme.fg("text", target)}`;
+                const tierTag = tierBadge ? theme.fg("dim", `[${tierBadge}] `) : "";
+                const phaseBadge = `${tierTag}${theme.fg("dim", phaseLabel)}`;
+                lines.push(rightAlign(actionLeft, phaseBadge, width));
+                lines.push("");
+                if (mid) {
+                    const roadmapSlices = getRoadmapSlicesSync();
+                    if (roadmapSlices) {
+                        const { done, total, activeSliceTasks } = roadmapSlices;
+                        const barWidth = Math.max(8, Math.min(24, Math.floor(width * 0.3)));
+                        const pct = total > 0 ? done / total : 0;
+                        const filled = Math.round(pct * barWidth);
+                        const bar = theme.fg("success", "█".repeat(filled))
+                            + theme.fg("dim", "░".repeat(barWidth - filled));
+                        let meta = theme.fg("dim", `${done}/${total} slices`);
+                        if (activeSliceTasks && activeSliceTasks.total > 0) {
+                            const taskNum = Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
+                            meta += theme.fg("dim", `  ·  task ${taskNum}/${activeSliceTasks.total}`);
+                        }
+                        // ETA estimate
+                        const eta = estimateTimeRemaining();
+                        if (eta) {
+                            meta += theme.fg("dim", `  ·  ${eta}`);
+                        }
+                        lines.push(truncateToWidth(`${pad}${bar}  ${meta}`, width));
+                    }
+                }
+                lines.push("");
+                if (next) {
+                    lines.push(truncateToWidth(`${pad}${theme.fg("dim", "→")} ${theme.fg("dim", `then ${next}`)}`, width));
+                }
+                // ── Footer info (pwd, tokens, cost, context, model) ──────────────
+                lines.push("");
+                lines.push(truncateToWidth(theme.fg("dim", `${pad}${widgetPwd}`), width, theme.fg("dim", "…")));
+                // Token stats from current unit session + cumulative cost from metrics
+                {
+                    const cmdCtx = accessors.getCmdCtx();
+                    let totalInput = 0, totalOutput = 0;
+                    let totalCacheRead = 0, totalCacheWrite = 0;
+                    if (cmdCtx) {
+                        for (const entry of cmdCtx.sessionManager.getEntries()) {
+                            if (entry.type === "message") {
+                                const msgEntry = entry;
+                                if (msgEntry.message?.role === "assistant") {
+                                    const u = msgEntry.message.usage;
+                                    if (u) {
+                                        totalInput += u.input || 0;
+                                        totalOutput += u.output || 0;
+                                        totalCacheRead += u.cacheRead || 0;
+                                        totalCacheWrite += u.cacheWrite || 0;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    const mLedger = getLedger();
+                    const autoTotals = mLedger ? getProjectTotals(mLedger.units) : null;
+                    const cumulativeCost = autoTotals?.cost ?? 0;
+                    const cxUsage = cmdCtx?.getContextUsage?.();
+                    const cxWindow = cxUsage?.contextWindow ?? cmdCtx?.model?.contextWindow ?? 0;
+                    const cxPctVal = cxUsage?.percent ?? 0;
+                    const cxPct = cxUsage?.percent !== null ? cxPctVal.toFixed(1) : "?";
+                    const sp = [];
+                    if (totalInput)
+                        sp.push(`↑${formatWidgetTokens(totalInput)}`);
+                    if (totalOutput)
+                        sp.push(`↓${formatWidgetTokens(totalOutput)}`);
+                    if (totalCacheRead)
+                        sp.push(`R${formatWidgetTokens(totalCacheRead)}`);
+                    if (totalCacheWrite)
+                        sp.push(`W${formatWidgetTokens(totalCacheWrite)}`);
+                    // Cache hit rate for current unit
+                    if (totalCacheRead + totalInput > 0) {
+                        const hitRate = Math.round((totalCacheRead / (totalCacheRead + totalInput)) * 100);
+                        sp.push(`\u26A1${hitRate}%`);
+                    }
+                    if (cumulativeCost)
+                        sp.push(`$${cumulativeCost.toFixed(3)}`);
+                    const cxDisplay = cxPct === "?"
+                        ? `?/${formatWidgetTokens(cxWindow)}`
+                        : `${cxPct}%/${formatWidgetTokens(cxWindow)}`;
+                    if (cxPctVal > 90) {
+                        sp.push(theme.fg("error", cxDisplay));
+                    }
+                    else if (cxPctVal > 70) {
+                        sp.push(theme.fg("warning", cxDisplay));
+                    }
+                    else {
+                        sp.push(cxDisplay);
+                    }
+                    const sLeft = sp.map(p => p.includes("\x1b[") ? p : theme.fg("dim", p))
+                        .join(theme.fg("dim", " "));
+                    const modelId = cmdCtx?.model?.id ?? "";
+                    const modelProvider = cmdCtx?.model?.provider ?? "";
+                    const modelPhase = phaseLabel ? theme.fg("dim", `[${phaseLabel}] `) : "";
+                    const modelDisplay = modelProvider && modelId
+                        ? `${modelProvider}/${modelId}`
+                        : modelId;
+                    const sRight = modelDisplay
+                        ? `${modelPhase}${theme.fg("dim", modelDisplay)}`
+                        : "";
+                    lines.push(rightAlign(`${pad}${sLeft}`, sRight, width));
+                    // Dynamic routing savings summary
+                    if (mLedger && mLedger.units.some(u => u.tier)) {
+                        const savings = formatTierSavings(mLedger.units);
+                        if (savings) {
+                            lines.push(truncateToWidth(theme.fg("dim", `${pad}${savings}`), width));
+                        }
+                    }
+                }
+                const hintParts = [];
+                hintParts.push("esc pause");
+                hintParts.push(process.platform === "darwin" ? "⌃⌥G dashboard" : "Ctrl+Alt+G dashboard");
+                lines.push(...ui.hints(hintParts));
+                lines.push(...ui.bar());
+                cachedLines = lines;
+                cachedWidth = width;
+                return lines;
+            },
+            invalidate() {
+                cachedLines = undefined;
+                cachedWidth = undefined;
+            },
+            dispose() {
+                clearInterval(pulseTimer);
+                if (progressRefreshTimer)
+                    clearInterval(progressRefreshTimer);
+            },
+        };
+    });
+}
+// ─── Right-align Helper ───────────────────────────────────────────────────────
+/** Right-align helper: build a line with left content and right content. */
+function rightAlign(left, right, width) {
+    const leftVis = visibleWidth(left);
+    const rightVis = visibleWidth(right);
+    const gap = Math.max(1, width - leftVis - rightVis);
+    return truncateToWidth(left + " ".repeat(gap) + right, width);
+}