@askdkc/dsh-cli 0.11.3

package/lib/types/screens/StatusLine.js

@@ -0,0 +1,453 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text, useTerminalSize, useTheme } from '../ui.js';
+import { formatTokens } from '../terminal-utils/format.js';
+import { t } from '../i18n.js';
+import { formatContextUsage, DEFAULT_STATUS_BAR, normalizeStatusBar } from '../tuiDisplayPrefs.js';
+import { estimateSessionCostCny, estimateSessionCostSplitCny, isDeepSeekOfficialProvider, isPeakHour } from '../deepseekPricing.js';
+import { ActivityLine, contextPressurePct } from '../components/ActivityLine.js';
+import { GoalStatusChip } from '../components/GoalTodoPanel.js';
+import { formatJobDuration } from '../dsh-adapter/jobs.js';
+/** Stable fallback for stubbed channels: verify/repro harnesses render the
+ *  real Chat with partial channel literals that predate the jobs field. */
+const NO_BACKGROUND_JOBS = [];
+import { modeDisplayName } from '../sessionModes.js';
+import { MiniWake } from '../components/trajectory/MiniWake.js';
+import { ContextBarView } from '../components/ContextBarView.js';
+import { TooltipTarget } from '../components/Tooltip.js';
+import { formatProject } from '../sessions/format.js';
+import { homeDir } from '../utils/paths.js';
+import { FREE_SEGMENT_FILL, USED_SEGMENTS, contextBarBreakdown, renderMiniContextBar, renderTpsGauge, renderTpsSparkline, speedColor, tpsStats, } from './StatusMetrics.js';
+/**
+ * The footer under the prompt input: the segmented context progress bar on
+ * its own first line, the
+ * status line below (left group: model · tokens · think level · cache · tps
+ * gauge/sparkline; right group: git · cwd · title · short session id,
+ * right-aligned), and the
+ * mode/hint line last. The right side of the footer shows the latest
+ * transient notification (errors in red, warnings in amber).
+ *
+ * Every metric field is hover-aware (fullscreen mouse): dwelling on a field
+ * swaps the ctx readout for a mini pressure gauge and parks that field's
+ * detailed breakdown on the supplemental row where the idle hint lives —
+ * the footer stays one line tall, the detail is a peek, not a layout
+ * change. The context bar answers the same way: it carries no labels of its
+ * own, so hovering it is how its colors get their names and numbers.
+ */
+/**
+ * Minimal mode's footer config. It ignores every SAVED preference (built from
+ * scratch rather than `normalizeStatusBar(channel.statusBar)`) and pins the
+ * DECORATION switches OFF — the shared defaults are free to change
+ * (`contextBar` became default-on in 2026-09) and minimal mode must not follow
+ * them into the footer.
+ *
+ * The metric fields keep their `DEFAULT_STATUS_BAR` values on purpose: minimal
+ * mode has ALWAYS shown the default-on metrics (thinking / contextUsage /
+ * cache / cost / goal) next to model + cwd — that predates the long-line fold
+ * and the context-bar flip, and trimming them further is a product decision,
+ * not a regression fix. Module scope: one frozen object, no per-render
+ * allocation.
+ */
+const MINIMAL_STATUS_BAR = Object.freeze({
+    ...DEFAULT_STATUS_BAR,
+    compact: true,
+    model: true,
+    cwd: true,
+    contextBar: false,
+    activity: false,
+    trajectory: false,
+    shortcutHint: false,
+});
+/**
+ * Render field parts as sibling shrinkable Boxes joined by the Byline
+ * separator (` · `). The Box-per-field layout is what makes individual
+ * fields hoverable — a Byline inside one Text cannot carry per-field mouse
+ * rects — at the cost of truncating each field on its own under pressure
+ * instead of truncating the joined string's tail.
+ */
+function FieldLine({ parts, hoverProps, }) {
+    const visible = parts.filter(part => part.node !== null && part.node !== undefined && part.node !== false);
+    return (_jsx(_Fragment, { children: visible.map((part, index) => (_jsxs(React.Fragment, { children: [index > 0 ? _jsx(Text, { dimColor: true, children: " \u00B7 " }) : null, _jsx(Box, { flexShrink: 1, ...(part.id === undefined ? {} : hoverProps(part.id)), children: part.tooltip === undefined || part.tooltip === '' ? (_jsx(Text, { wrap: "truncate", children: part.node })) : (_jsx(TooltipTarget, { content: part.tooltip, children: _jsx(Text, { wrap: "truncate", children: part.node }) })) })] }, part.key))) }));
+}
+export function StatusLine({ channel, selectionActive = false, helpOpen = false, wake, activity: projectedActivity, }) {
+    const { columns } = useTerminalSize();
+    const [themeName] = useTheme();
+    const [hover, setHover] = React.useState(null);
+    const hoverProps = React.useCallback((id) => ({
+        onMouseEnter: () => setHover(id),
+        // Guarded leave: a late leave from a field the pointer already left must
+        // not clobber the field it entered.
+        onMouseLeave: () => setHover(current => (current === id ? null : current)),
+    }), []);
+    const statusBar = channel.minimal
+        // Minimal mode overrides every field switch: model + cwd only, so the
+        // footer can never grow decorations regardless of saved preferences.
+        ? MINIMAL_STATUS_BAR
+        : normalizeStatusBar(channel.statusBar);
+    // Provider workspaces expose a remote display path alongside a host alias;
+    // only the local target has identical cwd/displayCwd values to fold.
+    const displayCwd = channel.displayCwd === channel.cwd
+        ? formatProject(channel.displayCwd, homeDir())
+        : channel.displayCwd;
+    const usage = channel.lastUsage;
+    const contextUsed = usage === undefined
+        ? undefined
+        : usage.input + usage.cacheRead + usage.cacheWrite;
+    const contextParts = [];
+    if (statusBar.thinking && channel.reasoningEffort !== undefined) {
+        contextParts.push({
+            key: 'effort',
+            node: _jsx(Text, { color: "inactiveShimmer", children: channel.reasoningEffort }),
+        });
+    }
+    const modeNeedsExplicitMarker = channel.mode.plan === true
+        || channel.mode.sandbox === 'danger-full-access'
+        || channel.mode.approval === 'never';
+    if (statusBar.mode && (channel.modeIndex > 0 || modeNeedsExplicitMarker)) {
+        contextParts.push({
+            key: 'mode',
+            node: (_jsx(Text, { color: channel.mode.plan === true ? 'planMode' : 'warning', children: modeDisplayName(channel.mode) })),
+        });
+    }
+    const formattedContext = statusBar.contextUsage
+        ? formatContextUsage(contextUsed, channel.contextWindow, statusBar.compact)
+        : undefined;
+    // The ctx field's two faces: the idle readout, and the hover state — an
+    // in-place pressure bar (the user-liked "text becomes a bar" morph).
+    //
+    // WIDTH-STABLE BY CONSTRUCTION: the idle variable part is
+    // `P + " (" + C + ")"` (either order; P = percent text, C = counts) —
+    // len(P)+len(C)+3 cells. The hover variant is `▕+bar+▏ + " " + P` —
+    // 3+barLen+len(P) cells. Sizing barLen = len(C) makes them equal, so the
+    // morph swaps glyphs in place and NO sibling field, separator, or the
+    // right-aligned group moves a single cell (the first attempt used a fixed
+    // 10-cell gauge and made the whole row jump).
+    const ctxParts = (() => {
+        if (formattedContext === undefined)
+            return undefined;
+        const open = formattedContext.indexOf(' (');
+        if (open < 0)
+            return undefined;
+        const first = formattedContext.slice(0, open);
+        const second = formattedContext.slice(open + 2, -1);
+        if (first.endsWith('%'))
+            return { percent: first, counts: second };
+        if (second.endsWith('%'))
+            return { percent: second, counts: first };
+        return undefined;
+    })();
+    const ctxHoverBarWidth = ctxParts?.counts.length ?? 0;
+    const ctxNode = formattedContext === undefined
+        ? undefined
+        : hover === 'ctx' &&
+            ctxParts !== undefined &&
+            ctxHoverBarWidth > 0 &&
+            contextUsed !== undefined &&
+            channel.contextWindow !== undefined
+            ? (_jsxs(Text, { color: "inactiveShimmer", children: [_jsx(Text, { dimColor: true, children: "ctx " }), renderMiniContextBar(contextUsed, channel.contextWindow, ctxHoverBarWidth), ' ', ctxParts.percent] }))
+            : (_jsxs(Text, { color: "inactiveShimmer", children: [_jsx(Text, { dimColor: true, children: "ctx " }), formattedContext] }));
+    if (statusBar.cache) {
+        const cacheRate = formatCacheHitRate(usage);
+        if (cacheRate !== undefined) {
+            contextParts.push({
+                key: 'cache',
+                id: 'cache',
+                node: (_jsxs(Text, { color: "inactiveShimmer", children: [_jsx(Text, { dimColor: true, children: t('status-cache-label') }), cacheRate] })),
+            });
+        }
+    }
+    let tpsPart;
+    if (statusBar.tps && channel.tps !== undefined) {
+        if (channel.working && channel.tpsSamples.length === 0) {
+            tpsPart = {
+                key: 'tps',
+                id: 'tps',
+                node: (_jsxs(Text, { children: [renderTpsGauge(channel.tps, channel.tps), ' ', _jsxs(Text, { dimColor: true, children: [Math.round(channel.tps), " tps"] })] })),
+            };
+        }
+        else if (channel.tpsSamples.length > 0) {
+            const peak = Math.max(...channel.tpsSamples.map(sample => sample.tps), channel.tps);
+            tpsPart = {
+                key: 'tps',
+                id: 'tps',
+                node: (_jsxs(Text, { children: [channel.working
+                            ? renderTpsGauge(channel.tps, peak)
+                            : renderTpsSparkline(channel.tpsSamples), ' ', speedColor(channel.tps, `${Math.round(channel.tps)}`), " tps"] })),
+            };
+        }
+        else {
+            tpsPart = {
+                key: 'tps',
+                id: 'tps',
+                node: _jsxs(Text, { dimColor: true, children: [Math.round(channel.tps), " t/s"] }),
+            };
+        }
+    }
+    const selectionBadge = formatSelectionBadge(channel.selection);
+    // Background-job chip (ctx.jobs; /jobs): live count of running/stopping
+    // jobs, shown only while non-zero — a silent zero is not information.
+    // Not preference-gated: it is transient situational state like the goal
+    // chip, not chrome. Hover lists the live jobs with elapsed times.
+    // Marker is ●, NOT ⚙ (U+2699 is EA-ambiguous: ink measures 1 cell, CJK
+    // terminal fonts paint 2 → the count overlaps the glyph).
+    const liveJobs = (channel.backgroundJobs ?? NO_BACKGROUND_JOBS).filter(job => job.status === 'running' || job.status === 'stopping');
+    const jobsPart = liveJobs.length === 0
+        ? undefined
+        : {
+            key: 'jobs',
+            id: 'jobs',
+            node: (_jsxs(Text, { color: "toolDotTask", children: ['● ', liveJobs.length] })),
+        };
+    const leftFields = [
+        ...(statusBar.model
+            ? [{ key: 'model', id: 'model', node: _jsx(Text, { color: "inactiveShimmer", children: channel.model }) }]
+            : []),
+        ...(tpsPart !== undefined ? [tpsPart] : []),
+        ...(jobsPart !== undefined ? [jobsPart] : []),
+        ...contextParts,
+        ...(statusBar.tokens
+            ? [{
+                    key: 'tokens',
+                    id: 'tokens',
+                    node: (_jsxs(Text, { color: "inactiveShimmer", children: [formatTokens(channel.tokens.input), "\u2192", formatTokens(channel.tokens.output)] })),
+                }]
+            : []),
+        // Estimated session spend (≈¥): only for official DeepSeek providers
+        // whose model has a known price, and only once the estimate is non-zero
+        // (a fresh session showing ¥0.00 is noise). The trailing 峰/谷 marker
+        // shows the current billing window. Hover shows the breakdown.
+        ...(statusBar.cost && isDeepSeekOfficialProvider(channel.provider)
+            ? (() => {
+                const estimate = estimateSessionCostCny(channel.tokens, channel.model);
+                return estimate === undefined || estimate <= 0
+                    ? []
+                    : [{
+                            key: 'cost',
+                            id: 'cost',
+                            node: (_jsxs(Text, { color: "inactiveShimmer", children: [t('status-cost-label'), "\u00A5", estimate.toFixed(2), " ", t(isPeakHour() ? 'cost-now-peak' : 'cost-now-idle')] })),
+                        }];
+            })()
+            : []),
+    ];
+    const rightFields = [
+        // Live IDE-selection badge first: it tracks the user's in-editor gesture,
+        // the freshest signal in the footer (T-FIX-02). Absent without an IDE —
+        // no placeholder, matching the official Claude Code footer.
+        ...(selectionBadge !== undefined
+            ? [{
+                    key: 'ideSelection',
+                    node: (_jsx(Text, { color: "ide", wrap: "truncate", children: selectionBadge })),
+                }]
+            : []),
+        // Goal chip first: session-level state outranks repo/location details.
+        ...(statusBar.goal && channel.goal !== undefined
+            ? [{
+                    key: 'goal',
+                    id: 'goal',
+                    node: _jsx(GoalStatusChip, { goal: channel.goal, minimal: channel.minimal }),
+                }]
+            : []),
+        ...(statusBar.gitBranch && channel.gitBranch
+            ? [
+                {
+                    key: 'git',
+                    id: 'git',
+                    node: _jsx(Text, { color: "professionalBlue", children: channel.gitBranch }),
+                },
+            ]
+            : []),
+        ...(statusBar.cwd
+            ? [{
+                    key: 'cwd',
+                    id: 'cwd',
+                    node: (_jsx(Text, { color: "inactiveShimmer", children: statusBar.compact ? basename(displayCwd) : displayCwd })),
+                }]
+            : []),
+        ...(statusBar.sessionTitle && channel.sessionTitle
+            ? [{
+                    key: 'title',
+                    id: 'title',
+                    // The title truncates mid-word when the right-aligned group
+                    // overflows; the tooltip carries the full string.
+                    tooltip: channel.sessionTitle,
+                    node: _jsx(Text, { dimColor: true, children: channel.sessionTitle }),
+                }]
+            : []),
+        // Short id last: a provenance tag trails the content it identifies, and
+        // the 8-char form is what the session log filename starts with, so a
+        // truncated rendering still names the right log for --resume.
+        ...(statusBar.sessionId && channel.agentId
+            ? [{
+                    key: 'sessionId',
+                    id: 'sessionId',
+                    node: _jsx(Text, { dimColor: true, children: `#${channel.agentId.slice(0, 8)}` }),
+                }]
+            : []),
+    ];
+    const hint = selectionActive
+        ? t('statusline-hint-select')
+        : channel.working
+            ? t('statusline-hint-working')
+            : statusBar.shortcutHint && !helpOpen
+                ? t('statusline-hint-shortcuts')
+                : '';
+    const activity = projectedActivity;
+    const showActivity = statusBar.activity &&
+        !channel.working &&
+        activity !== undefined &&
+        activity.line !== '' &&
+        activity.phase !== 'idle';
+    const showTrajectory = statusBar.trajectory && wake !== undefined;
+    const barWidth = columns - 4;
+    const barColors = themeName === 'light'
+        ? undefined
+        : { freeFill: '#2E3440', freeText: '#8D95A6' };
+    const barVisible = statusBar.contextBar &&
+        channel.contextBarEnabled &&
+        barWidth >= 14 &&
+        usage !== undefined &&
+        channel.contextWindow !== undefined;
+    // The supplemental-row readout for the hovered field: replaces the idle
+    // hint (never the activity line) while the pointer dwells on a field.
+    const detail = buildHoverDetail(hover, channel, usage, contextUsed, columns, barColors);
+    const trailer = detail !== null
+        ? detail
+        : hint !== ''
+            ? _jsx(Text, { color: "inactiveShimmer", children: hint })
+            : null;
+    const compactFields = [...leftFields, ...rightFields];
+    const fullLeftFields = [
+        ...leftFields,
+        ...(ctxNode !== undefined ? [{ key: 'context', id: 'ctx', node: ctxNode }] : []),
+    ];
+    const hasStatusFields = compactFields.length > 0 || ctxNode !== undefined;
+    // The supplemental row is PERMANENTLY mounted (height pinned to 1)
+    // whenever the footer carries hoverable chrome — mounting it from nothing
+    // on hover is what made the footer grow mid-gesture and shoved the
+    // transcript up (user feedback). Idle it may sit blank: a stable footer
+    // outranks a reclaimable row, and hovering only ever swaps this line's
+    // content. Minimal mode keeps the old contract — no hover details, the
+    // row appears only for real content (which its defaults never produce).
+    const showSupplementalRow = (!channel.minimal && (hasStatusFields || barVisible)) ||
+        showActivity ||
+        showTrajectory ||
+        hint !== '';
+    return (_jsx(Box, { paddingX: 1, width: columns, flexShrink: 0, children: _jsxs(Box, { flexDirection: "column", width: "100%", children: [barVisible ? (_jsx(ContextBarView, { segments: channel.contextSegments, usedTokens: contextUsed ?? 0, contextWindow: channel.contextWindow ?? 0, width: barWidth, colors: barColors, onHover: hovered => setHover(current => hovered ? 'bar' : current === 'bar' ? null : current) })) : null, hasStatusFields ? statusBar.compact ? (_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", gap: 2, children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, flexDirection: "row", overflow: "hidden", children: _jsx(FieldLine, { parts: compactFields, hoverProps: hoverProps }) }), ctxNode !== undefined ? (_jsx(Box, { flexShrink: 0, ...hoverProps('ctx'), children: _jsx(Text, { wrap: "truncate", children: ctxNode }) })) : null] })) : (_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", gap: 2, children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, flexDirection: "row", overflow: "hidden", children: _jsx(FieldLine, { parts: fullLeftFields, hoverProps: hoverProps }) }), _jsx(Box, { justifyContent: "flex-end", flexShrink: 2, flexDirection: "row", overflow: "hidden", children: _jsx(FieldLine, { parts: rightFields, hoverProps: hoverProps }) })] })) : null, showSupplementalRow ? _jsxs(Box, { height: 1, overflow: "hidden", flexDirection: "row", justifyContent: "space-between", gap: 2, children: [_jsxs(Box, { flexDirection: "row", flexGrow: 1, justifyContent: showActivity && trailer !== null ? 'space-between' : 'flex-start', gap: 2, children: [showActivity && activity !== undefined ? (_jsx(ActivityLine, { activity: activity, activityFrames: channel.activityFrames, warnPct: contextPressurePct(usage, channel.contextWindow), warnDanger: (contextPressurePct(usage, channel.contextWindow) ?? 0) >= 95 })) : trailer, showActivity ? trailer : null] }), showTrajectory && wake !== undefined ? (_jsx(MiniWake, { band: wake.band, hint: wake.hint, tick: wake.tick })) : null] }) : null] }) }));
+}
+/**
+ * The supplemental-row readout for a hovered footer field. Technical label
+ * tokens (ctx, free, read, sys…) stay unlocalized like the footer fields
+ * themselves; sentences go through t(). Returns null when nothing is
+ * hovered (or the hover outlived its data, which the field gating makes
+ * near-impossible).
+ */
+function buildHoverDetail(hover, channel, usage, contextUsed, columns, barColors) {
+    if (hover === null)
+        return null;
+    const window = channel.contextWindow;
+    const dim = (label) => _jsx(Text, { dimColor: true, children: label });
+    if (hover === 'bar') {
+        if (window === undefined || window <= 0 || contextUsed === undefined)
+            return null;
+        // The bar's text-free design pays off here: this line is its legend, so
+        // every entry leads with a chip of the very color it names.
+        const { entries, separator } = contextBarBreakdown(channel.contextSegments, contextUsed, window, columns, barColors?.freeFill ?? FREE_SEGMENT_FILL);
+        if (entries.length === 0)
+            return null;
+        return (_jsx(Text, { wrap: "truncate", children: entries.map((entry, index) => (_jsxs(React.Fragment, { children: [index > 0 ? dim(separator) : null, _jsx(Text, { backgroundColor: entry.color, children: " " }), entry.label] }, entry.key))) }));
+    }
+    switch (hover) {
+        case 'ctx': {
+            if (contextUsed === undefined || window === undefined || window <= 0)
+                return null;
+            const free = Math.max(0, window - contextUsed);
+            // The hover payoff for the ctx ask: percent + counts + free, then the
+            // segment breakdown as the truncate-able tail (no bar — the row's
+            // in-place morph and the segment bar above already carry the gauge).
+            const segments = USED_SEGMENTS.map(segment => `${segment.labels[1] ?? segment.key} ${formatTokens(channel.contextSegments[segment.key])}`).join(' · ');
+            return (_jsxs(Text, { wrap: "truncate", children: [((contextUsed / window) * 100).toFixed(1), "% \u00B7", ' ', formatTokens(contextUsed), "/", formatTokens(window), " \u00B7 ", dim('free '), formatTokens(free), ' · ', segments] }));
+        }
+        case 'cache': {
+            const rate = formatCacheHitRate(usage);
+            if (usage === undefined || rate === undefined)
+                return null;
+            return (_jsxs(Text, { wrap: "truncate", children: [dim('cache '), rate, " \u00B7 ", dim('read '), formatTokens(usage.cacheRead), " \u00B7", ' ', dim('write '), formatTokens(usage.cacheWrite), " \u00B7 ", dim('input '), formatTokens(usage.input)] }));
+        }
+        case 'tps': {
+            if (channel.tps === undefined)
+                return null;
+            const stats = tpsStats(channel.tpsSamples, Date.now());
+            return (_jsxs(Text, { wrap: "truncate", children: [dim('tps '), Math.round(channel.tps), " \u00B7 ", dim('avg60 '), stats.avg.toFixed(1), " \u00B7", ' ', dim('mean '), stats.mean.toFixed(1), " \u00B7 ", dim('p95 '), stats.p95.toFixed(1)] }));
+        }
+        case 'tokens': {
+            const { input, output } = channel.tokens;
+            return (_jsxs(Text, { wrap: "truncate", children: [dim('in '), input.toLocaleString(), " \u00B7 ", dim('out '), output.toLocaleString(), " \u00B7", ' ', dim('total '), (input + output).toLocaleString()] }));
+        }
+        case 'cost': {
+            const split = estimateSessionCostSplitCny(channel.tokens, channel.model);
+            if (split === undefined)
+                return null;
+            const { input, output, cacheRead } = channel.tokens;
+            return (_jsxs(Text, { wrap: "truncate", children: [dim('≈¥'), split.total.toFixed(2), " \u00B7 ", dim('peak '), "\u00A5", split.peak.toFixed(2), ' · ', dim('idle '), "\u00A5", split.idle.toFixed(2), " \u00B7 ", dim('in '), formatTokens(input), ' · ', dim('out '), formatTokens(output), " \u00B7 ", dim('cache '), formatTokens(cacheRead), ' · ', t('status-cost-note')] }));
+        }
+        case 'goal': {
+            const goal = channel.goal;
+            if (goal === undefined)
+                return null;
+            return (_jsxs(Text, { wrap: "truncate", children: [dim('goal '), goal.phase, " \u00B7 ", dim('r'), goal.roundsStarted, "/", goal.maxGoalRounds, " \u00B7", ' ', goal.objective] }));
+        }
+        case 'jobs': {
+            const live = (channel.backgroundJobs ?? NO_BACKGROUND_JOBS).filter(job => job.status === 'running' || job.status === 'stopping');
+            if (live.length === 0)
+                return null;
+            const shown = live.slice(0, 3);
+            const rest = live.length - shown.length;
+            return (_jsxs(Text, { wrap: "truncate", children: [dim('jobs '), shown.map(job => `${job.id} ${job.label} (${formatJobDuration(job)})`).join(' · '), rest > 0 ? ` · +${rest}` : ''] }));
+        }
+        case 'model': {
+            return (_jsxs(Text, { wrap: "truncate", children: [dim('model '), channel.model, " \u00B7 ", dim('provider '), channel.provider, channel.contextWindow !== undefined
+                        ? _jsxs(_Fragment, { children: [" \u00B7 ", dim('ctx '), formatTokens(channel.contextWindow)] })
+                        : null] }));
+        }
+        case 'git': {
+            if (channel.gitBranch === undefined)
+                return null;
+            return (_jsxs(Text, { wrap: "truncate", children: [dim('git '), channel.gitBranch] }));
+        }
+        case 'sessionId':
+            return (_jsxs(Text, { wrap: "truncate", children: [dim('# '), channel.agentId, " \u00B7 ", t('status-detail-session-id')] }));
+        case 'cwd':
+            return (_jsxs(Text, { wrap: "truncate", children: [dim('cwd '), channel.displayCwd] }));
+        case 'title':
+            return (_jsxs(Text, { wrap: "truncate", children: [dim('title '), channel.sessionTitle] }));
+        default:
+            return null;
+    }
+}
+/** Return the prompt-cache hit rate, or nothing when usage is unavailable. */
+export function formatCacheHitRate(usage) {
+    if (usage === undefined)
+        return undefined;
+    const total = usage.input + usage.cacheRead + usage.cacheWrite;
+    if (!Number.isFinite(total) || total <= 0)
+        return undefined;
+    return `${((usage.cacheRead / total) * 100).toFixed(1)}%`;
+}
+/**
+ * The prompt footer's live IDE-selection badge (T-FIX-02), mirroring Claude
+ * Code's `⧉ N lines selected`: English only (like every other footer field),
+ * singular/plural aware, line count from the snapshot's 0-based inclusive
+ * range. `undefined` (no IDE yet / cleared by an isEmpty notification)
+ * renders no field at all — a manually launched session never shows a
+ * placeholder. Exported for scripts/verify-ide-channel.tsx.
+ */
+export function formatSelectionBadge(selection) {
+    if (selection === undefined || selection.isEmpty === true)
+        return undefined;
+    const lines = selection.endLine - selection.startLine + 1;
+    return `⧉ ${lines} ${lines === 1 ? 'line' : 'lines'} selected`;
+}
+function basename(path) {
+    const parts = path.split(/[\\/]/);
+    return parts[parts.length - 1] ?? path;
+}

package/lib/types/screens/StatusMetrics.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Status-line metric renderers, ported from two pi extensions:
+ *  - `pi-nano-context`: segmented context progress bar (morandi pastel
+ *    segments by content type, free space right-aligned with the usage
+ *    readout, largest-remainder column allocation).
+ *  - `pi-tps-meter`: live 1/8-cell gauge while streaming and a min-max
+ *    normalized sparkline after each completed turn; colors green ≥ 50 tps,
+ *    yellow ≥ 20, red below.
+ */
+import type { Color } from '../ink/styles.js';
+/** Context bar segments — DeepSeek blue family (dark-theme friendly: deep
+ *  navy → brand blue, neutral grey free segment).
+ *
+ *  The bar draws NO text inside a used segment: the fill color is the whole
+ *  signal (community feedback — the old `s`/`p`/`t` letters read as noise on
+ *  a row that is already decorative). `labels` therefore belongs to the hover
+ *  breakdown only: index 0 is the readable name, index 1 the short form the
+ *  supplemental row falls back to on a narrow terminal. Exported for the
+ *  hoverable JSX bar (ContextBarView), which re-derives the same column split
+ *  this module's ANSI path renders. */
+export declare const USED_SEGMENTS: readonly [{
+    readonly key: "system";
+    readonly color: "#22305F";
+    readonly labels: readonly ["system", "sys"];
+}, {
+    readonly key: "prompt";
+    readonly color: "#2B3D78";
+    readonly labels: readonly ["prompt", "pr"];
+}, {
+    readonly key: "assistant";
+    readonly color: "#344A92";
+    readonly labels: readonly ["assistant", "ast"];
+}, {
+    readonly key: "thinking";
+    readonly color: "#4D6BFE";
+    readonly labels: readonly ["thinking", "th"];
+}, {
+    readonly key: "tools";
+    readonly color: "#5A7CFF";
+    readonly labels: readonly ["tools", "tl"];
+}];
+/** Used tokens per context content type (system, prompt, assistant, thinking, tools). */
+export type ContextSegments = Record<(typeof USED_SEGMENTS)[number]['key'], number>;
+/** Free-segment colors: light grey fill, dark grey readout. Exported so the
+ *  JSX bar (ContextBarView) and the hover chip paint the same free color the
+ *  ANSI path does instead of re-declaring the hex. */
+export declare const FREE_SEGMENT_FILL = "#E8E8E8";
+export declare const FREE_SEGMENT_TEXT = "#4A4A4A";
+/** Compact token count like pi's: `988`, `3.4k`, `12k`, `1.0M`.
+ * @param count - The raw token count; negative values clamp to zero.
+ * @returns The compact count string.
+ */
+export declare function formatTokens(count: number): string;
+/** Which pressure step a context occupancy falls in: undefined while the
+ *  context is comfortable, then the shared `warning` / `error` theme colors.
+ * @param pct - Context occupancy percent (0–100+).
+ * @returns The theme color key, or undefined below the amber threshold.
+ */
+export declare function contextPressureStep(pct: number): 'warning' | 'error' | undefined;
+/**
+ * The bar's right-aligned usage readout, longest form first: token counts and
+ * percent (`13k/64k 19.5%`), then the percent alone once the free segment is
+ * too narrow to carry the counts.
+ * @param usedTokens - Total context tokens in use.
+ * @param contextWindow - The context window size in tokens.
+ * @returns The readout ladder, widest option first.
+ */
+export declare function contextBarReadout(usedTokens: number, contextWindow: number): readonly string[];
+/**
+ * Blank-pad to `width` cells and right-align the first readout option that
+ * fits. Shared by the ANSI string path (renderContextBar) and the hoverable
+ * JSX bar (ContextBarView) so both render identical readouts.
+ */
+export declare function rightAlignBarText(options: readonly string[], width: number): string;
+/** One entry of the context bar's hover breakdown: the fill color, the name
+ *  to put next to a swatch of it, and the token count already folded into
+ *  `label` (`system 1.2k`). */
+export type ContextBarBreakdownEntry = {
+    /** `system` … `tools`, or `free`. */
+    key: string;
+    /** The chip label, e.g. `thinking 5.0k`. */
+    label: string;
+    /** The segment's fill color — the hover chip paints with it, which is what
+     *  ties each number back to a slice of the bar. */
+    color: Color;
+};
+/** Separator between breakdown entries, chosen by the width ladder below. */
+export type ContextBarBreakdown = {
+    readonly entries: readonly ContextBarBreakdownEntry[];
+    readonly separator: string;
+};
+/**
+ * The context bar's hover breakdown — the legend the bar no longer carries
+ * itself. One entry per segment the bar actually paints (a zero-token content
+ * type gets no columns, so it gets no entry either), in bar order, free last.
+ *
+ * `columns` picks the label form: readable names with a ` · ` separator while
+ * the line fits, then the short forms, then a bare space separator (the color
+ * chip already separates the entries). The caller renders each entry as
+ * `chip + space + label`, which is what the fit test measures.
+ *
+ * @param segments - Used tokens per content type.
+ * @param usedTokens - Total used tokens; the remainder is the free entry.
+ * @param contextWindow - The context window size in tokens.
+ * @param columns - Terminal width; the footer's own padding is subtracted here.
+ * @param freeFill - The free segment's fill color (callers pass a theme override).
+ * @returns The breakdown entries and the separator to join them with.
+ */
+export declare function contextBarBreakdown(segments: ContextSegments, usedTokens: number, contextWindow: number, columns: number, freeFill?: Color): ContextBarBreakdown;
+/** Give every visible used segment at least one column before sharing the
+ *  rest. Exported for ContextBarView (hoverable JSX twin of the bar). */
+export declare function allocateBarColumns(values: readonly number[], width: number): number[];
+/**
+ * The segmented context bar: used segments by content type, then the
+ * remainder as a light free segment whose right edge carries the usage
+ * readout (`13k/64k 19.5%`). No other text — the bar is read by color, and
+ * the pointer supplies the names and numbers (contextBarBreakdown). The
+ * readout tints amber / red as the context fills (contextPressureStep).
+ * @param segments - Used tokens per content type.
+ * @param usedTokens - Total used tokens, driving the usage readout.
+ * @param contextWindow - The context window size in tokens.
+ * @param width - Total bar width in terminal columns.
+ * @returns The ANSI-styled segmented bar, or '' when `width` or `contextWindow` is non-positive.
+ */
+export declare function renderContextBar(segments: ContextSegments, usedTokens: number, contextWindow: number, width: number, colors?: {
+    freeFill: string;
+    freeText: string;
+}): string;
+/** Pressure-colored text: green below 80%, amber ≥ 80, red ≥ 95.
+ * @param pct - Context occupancy percent (0–100+).
+ * @param text - Text to color.
+ * @returns The ANSI 24-bit color-wrapped text.
+ */
+export declare function pressureColor(pct: number, text: string): string;
+/** Compact 1/8-cell context gauge for the footer's ctx field on hover:
+ *  `▕██████▋···▏`, fill proportional to context occupancy, colored by the
+ *  amber/red pressure thresholds. Same block ramp as the TPS gauge.
+ * @param usedTokens - Total context tokens in use.
+ * @param contextWindow - Context window size in tokens.
+ * @param width - Gauge width in terminal columns (fill cells, brackets excluded).
+ * @returns The ANSI gauge string, or '' for a non-positive window.
+ */
+export declare function renderMiniContextBar(usedTokens: number, contextWindow: number, width?: number): string;
+/** Speed color: green ≥ 50, yellow ≥ 20, red below (pi-tps-meter).
+ * @param tps - Tokens per second; selects the color threshold.
+ * @param text - Text to color.
+ * @returns The ANSI 24-bit color-wrapped text.
+ */
+export declare function speedColor(tps: number, text: string): string;
+/** Live 1/8-cell horizontal gauge: `▕███████▋···▏`.
+ * @param tps - Current tokens per second.
+ * @param peak - Scaling peak; values below 40 scale against the floor instead.
+ * @returns The ANSI gauge string.
+ */
+export declare function renderTpsGauge(tps: number, peak: number): string;
+/** Min-max normalized 12-sample sparkline: `▁▄▇▅▂▁▇█▅▃▆▇`.
+ * @param samples - Turn TPS samples; only the last 12 are rendered.
+ * @returns The ANSI sparkline string.
+ */
+export declare function renderTpsSparkline(samples: readonly {
+    tps: number;
+}[]): string;
+/** Rolling stats: 60s average, all-time mean and p95.
+ * @param samples - Turn TPS samples with their timestamps in milliseconds.
+ * @param nowMs - Current time in milliseconds; the 60s rolling window keeps samples with `nowMs - at <= 60_000`.
+ * @returns The 60s average, all-time mean, and all-time p95 (all zero for an empty sample list).
+ */
+export declare function tpsStats(samples: readonly {
+    tps: number;
+    at: number;
+}[], nowMs: number): {
+    avg: number;
+    mean: number;
+    p95: number;
+};
+//# sourceMappingURL=StatusMetrics.d.ts.map

package/lib/types/screens/StatusMetrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StatusMetrics.d.ts","sourceRoot":"","sources":["../../../src/screens/StatusMetrics.ts"],"names":[],"mappings":"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"}