@deepseek-harness-tui/dsh-tui 0.5.0

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

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { Channel } from '../channel.js';
+/**
+ * The footer under the prompt input, in Claude Code's PromptInputFooter
+ * layout: 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, 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 — CC style).
+ */
+export declare function StatusLine({ channel, selectionActive, helpOpen, }: {
+    channel: Channel;
+    selectionActive?: boolean;
+    helpOpen?: boolean;
+}): React.JSX.Element;
+//# sourceMappingURL=StatusLine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StatusLine.d.ts","sourceRoot":"","sources":["../../../src/screens/StatusLine.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAMzB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAQ5C;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,eAAuB,EACvB,QAAgB,GACjB,EAAE;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,qBAkLA"}

package/lib/types/screens/StatusLine.js

@@ -0,0 +1,105 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useTerminalSize, useTheme } from '../ui.js';
+import { formatTokens } from '../cc/format.js';
+import { Byline } from '../components/design-system/Byline.js';
+import { ActivityLine, contextPressurePct } from '../components/ActivityLine.js';
+import { renderContextBar, renderTpsGauge, renderTpsSparkline, speedColor, } from './StatusMetrics.js';
+/**
+ * The footer under the prompt input, in Claude Code's PromptInputFooter
+ * layout: 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, 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 — CC style).
+ */
+export function StatusLine({ channel, selectionActive = false, helpOpen = false, }) {
+    const { columns } = useTerminalSize();
+    const [themeName] = useTheme();
+    const usage = channel.lastUsage;
+    const contextParts = [];
+    if (channel.reasoningEffort !== undefined) {
+        contextParts.push(_jsx(Text, { color: "inactiveShimmer", children: channel.reasoningEffort }, "effort"));
+    }
+    if (usage !== undefined && usage.cacheRead > 0) {
+        // Cache hit rate of the context fed to the model (read / total), one
+        // decimal — the absolute read count lives in the context bar's system
+        // segment, the rate is the glanceable health signal.
+        const total = usage.input + usage.cacheRead + usage.cacheWrite;
+        const rate = total > 0 ? (usage.cacheRead / total) * 100 : 0;
+        contextParts.push(_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "cache " }), _jsxs(Text, { color: "inactiveShimmer", children: [rate.toFixed(1), "%"] })] }, "cache"));
+    }
+    // TPS readout sits right after the model so a crowded footer truncates
+    // the trailing fields (tokens/think/cache), never the speedometer. One
+    // number only: the live value (gauge while streaming, sparkline of past
+    // turns once samples exist) — no μ/p95 clutter.
+    const tpsParts = [];
+    if (channel.tps !== undefined) {
+        if (channel.working && channel.tpsSamples.length === 0) {
+            tpsParts.push(_jsxs(Text, { children: [renderTpsGauge(channel.tps, channel.tps), ' ', _jsxs(Text, { dimColor: true, children: [Math.round(channel.tps), " tps"] })] }, "tps"));
+        }
+        else if (channel.tpsSamples.length > 0) {
+            const peak = Math.max(...channel.tpsSamples.map(sample => sample.tps), channel.tps);
+            tpsParts.push(_jsxs(Text, { children: [channel.working
+                        ? renderTpsGauge(channel.tps, peak)
+                        : renderTpsSparkline(channel.tpsSamples), ' ', speedColor(channel.tps, `${Math.round(channel.tps)}`), " tps"] }, "tps"));
+        }
+        else {
+            tpsParts.push(_jsxs(Text, { dimColor: true, children: [Math.round(channel.tps), " t/s"] }, "tps"));
+        }
+    }
+    // Left group: every field sits at soft white (inactiveShimmer) instead of
+    // the previous uniform dim grey — readable against dark terminals.
+    const leftParts = [
+        _jsx(Text, { color: "inactiveShimmer", children: channel.model }, "model"),
+        ...tpsParts,
+        ...contextParts,
+        _jsxs(Text, { color: "inactiveShimmer", children: [formatTokens(channel.tokens.input), "\u2192", formatTokens(channel.tokens.output)] }, "tokens"),
+    ];
+    // Right group: git branch in muted steel blue, cwd a soft white, the
+    // session title dimmest (it truncates first anyway).
+    const rightParts = [
+        ...(channel.gitBranch
+            ? [
+                _jsx(Text, { color: "professionalBlue", children: channel.gitBranch }, "git"),
+            ]
+            : []),
+        _jsx(Text, { color: "inactiveShimmer", children: basename(channel.cwd) }, "cwd"),
+        ...(channel.sessionTitle
+            ? [
+                _jsx(Text, { dimColor: true, children: channel.sessionTitle }, "title"),
+            ]
+            : []),
+    ];
+    // Row 3: the mode hint — and, while idle, the working-activity turn
+    // summary (the live working line itself moves to the spinner slot above
+    // the input while a turn runs, so the two never duplicate).
+    const hint = selectionActive
+        ? 'esc to return to input'
+        : channel.working
+            ? 'esc to interrupt'
+            : !helpOpen
+                ? '? for shortcuts'
+                : '';
+    const activity = channel.workingActivity;
+    const showActivity = !channel.working &&
+        activity !== undefined &&
+        activity.line !== '' &&
+        activity.phase !== 'idle';
+    const barWidth = columns - 4;
+    let bar = null;
+    // Theme-aware free segment: the light palette's near-white fill (#E8E8E8)
+    // reads as a glaring white band on dark terminals — swap it for a deep
+    // blue-gray there while keeping the light palette as-is (dark-ansi carries
+    // `ansi:` color names, so map by theme name rather than palette tokens).
+    const barColors = themeName === 'light'
+        ? undefined
+        : { freeFill: '#2E3440', freeText: '#8D95A6' };
+    if (channel.contextBarEnabled && barWidth >= 14 && channel.contextWindow !== undefined) {
+        bar = renderContextBar(channel.contextSegments, usage !== undefined ? usage.input + usage.cacheRead + usage.cacheWrite : 0, channel.contextWindow, barWidth, barColors);
+    }
+    return (_jsx(Box, { paddingX: 2, children: _jsxs(Box, { flexDirection: "column", width: "100%", children: [bar ? _jsx(Text, { children: bar }) : null, _jsxs(Box, { flexDirection: "row", justifyContent: "space-between", gap: 2, children: [_jsx(Text, { wrap: "truncate", children: _jsx(Byline, { children: leftParts }) }), _jsx(Box, { justifyContent: "flex-end", flexShrink: 2, children: _jsx(Text, { wrap: "truncate", children: _jsx(Byline, { children: rightParts }) }) })] }), _jsxs(Box, { height: 1, overflow: "hidden", flexDirection: "row", justifyContent: "space-between", 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 })) : hint ? (_jsx(Text, { color: "inactiveShimmer", children: hint })) : null, showActivity && hint ? (_jsx(Text, { color: "inactiveShimmer", wrap: "truncate", children: hint })) : null] })] }) }));
+}
+function basename(path) {
+    const parts = path.split(/[\\/]/);
+    return parts[parts.length - 1] ?? path;
+}

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

@@ -0,0 +1,87 @@
+/**
+ * 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.
+ */
+/** Context bar segments — DeepSeek blue family (dark-theme friendly: deep
+ *  navy → brand blue, neutral grey free segment; labels adapt to width). */
+declare const USED_SEGMENTS: readonly [{
+    readonly key: "system";
+    readonly color: "#22305F";
+    readonly labels: readonly ["system", "sys", "s"];
+}, {
+    readonly key: "prompt";
+    readonly color: "#2B3D78";
+    readonly labels: readonly ["prompt", "pr", "p"];
+}, {
+    readonly key: "assistant";
+    readonly color: "#344A92";
+    readonly labels: readonly ["assistant", "ast", "a"];
+}, {
+    readonly key: "thinking";
+    readonly color: "#4D6BFE";
+    readonly labels: readonly ["think", "th", "t"];
+}, {
+    readonly key: "tools";
+    readonly color: "#5A7CFF";
+    readonly labels: readonly ["tools", "tl", "x"];
+}];
+/** Used tokens per context content type (system, prompt, assistant, thinking, tools). */
+export type ContextSegments = Record<(typeof USED_SEGMENTS)[number]['key'], number>;
+/** 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;
+/**
+ * The segmented context bar: used segments by content type, the remainder as
+ * a light free segment whose right edge carries the usage readout
+ * (`ctx 12.3k/1.0M 1.2% 988.9k`, shrinking as width allows).
+ * @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;
+/** 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;
+};
+export {};
+//# 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":"AAAA;;;;;;;;GAQG;AAEH;4EAC4E;AAC5E,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;EAMT,CAAA;AAEV,yFAAyF;AACzF,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,CAAA;AAsBnF;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOlD;AA+GD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,eAAe,EACzB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC9C,MAAM,CAkBR;AAYD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAG5D;AAYD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAYhE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,SAAS;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,MAAM,CAqB9E;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,SAAS;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG;IACxF,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ,CAUA"}

package/lib/types/screens/StatusMetrics.js

@@ -0,0 +1,252 @@
+/**
+ * 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.
+ */
+/** Context bar segments — DeepSeek blue family (dark-theme friendly: deep
+ *  navy → brand blue, neutral grey free segment; labels adapt to width). */
+const USED_SEGMENTS = [
+    { key: 'system', color: '#22305F', labels: ['system', 'sys', 's'] }, // deep navy
+    { key: 'prompt', color: '#2B3D78', labels: ['prompt', 'pr', 'p'] }, // navy
+    { key: 'assistant', color: '#344A92', labels: ['assistant', 'ast', 'a'] }, // indigo
+    { key: 'thinking', color: '#4D6BFE', labels: ['think', 'th', 't'] }, // DeepSeek brand blue
+    { key: 'tools', color: '#5A7CFF', labels: ['tools', 'tl', 'x'] }, // lighter blue
+];
+const USED_SEGMENT_TEXT = '#FFFFFF';
+const FREE_SEGMENT_FILL = '#E8E8E8';
+const FREE_SEGMENT_TEXT = '#4A4A4A';
+const FREE_SEGMENT_LABELS = ['free', 'fr', 'f'];
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+const stripAnsi = (text) => text.replace(ANSI_RE, '');
+const plainWidth = (text) => Array.from(stripAnsi(text)).length;
+function ansiColor(mode, hex, text) {
+    const value = Number.parseInt(hex.replace(/^#/, ''), 16);
+    const red = (value >> 16) & 0xff;
+    const green = (value >> 8) & 0xff;
+    const blue = value & 0xff;
+    return `\x1b[${mode};2;${red};${green};${blue}m${text}\x1b[${mode === 38 ? 39 : 49}m`;
+}
+const foreground = (hex, text) => ansiColor(38, hex, text);
+const background = (hex, text) => ansiColor(48, hex, text);
+/** 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 function formatTokens(count) {
+    const value = Math.max(0, Math.round(count));
+    if (value < 1000)
+        return String(value);
+    if (value < 10000)
+        return `${(value / 1000).toFixed(1)}k`;
+    if (value < 1000000)
+        return `${Math.round(value / 1000)}k`;
+    if (value < 10000000)
+        return `${(value / 1000000).toFixed(1)}M`;
+    return `${Math.round(value / 1000000)}M`;
+}
+// --- Context bar (pi-nano-context) ---
+function centeredText(text, width) {
+    const textWidth = plainWidth(text);
+    if (textWidth > width)
+        return ' '.repeat(width);
+    const left = Math.floor((width - textWidth) / 2);
+    const right = width - textWidth - left;
+    return `${' '.repeat(left)}${text}${' '.repeat(right)}`;
+}
+function chooseLabel(labels, width) {
+    for (const label of labels) {
+        if (plainWidth(label) <= width)
+            return label;
+    }
+    return '';
+}
+function renderUsedSegment(labels, color, width) {
+    if (width <= 0)
+        return '';
+    const label = chooseLabel(labels, width);
+    const text = label.length > 0
+        ? foreground(USED_SEGMENT_TEXT, centeredText(label, width))
+        : ' '.repeat(width);
+    return background(color, text);
+}
+function chooseRightAlignedText(options, width, blockedUntil) {
+    for (const option of options) {
+        const start = width - plainWidth(option);
+        if (start > blockedUntil)
+            return option;
+    }
+    return '';
+}
+function renderFreeSegment(options, width, fill, text) {
+    if (width <= 0)
+        return '';
+    const content = Array.from({ length: width }, () => ' ');
+    const label = chooseLabel(FREE_SEGMENT_LABELS, width);
+    const labelStart = Math.max(0, Math.floor((width - plainWidth(label)) / 2));
+    const labelEnd = label.length > 0 ? labelStart + plainWidth(label) : -1;
+    const rightText = chooseRightAlignedText(options, width, labelEnd);
+    if (rightText) {
+        const start = width - plainWidth(rightText);
+        for (const [offset, char] of Array.from(rightText).entries()) {
+            content[start + offset] = char;
+        }
+    }
+    if (label) {
+        for (const [offset, char] of Array.from(label).entries()) {
+            content[labelStart + offset] = char;
+        }
+    }
+    return background(fill, foreground(text, content.join('')));
+}
+/** Largest-remainder column allocation (pi-nano-context). */
+function allocateProportionally(values, columns) {
+    if (columns <= 0)
+        return values.map(() => 0);
+    const total = values.reduce((sum, value) => sum + value, 0);
+    if (total <= 0)
+        return values.map(() => 0);
+    const rawColumns = values.map(value => (value / total) * columns);
+    const allocatedColumns = rawColumns.map(Math.floor);
+    let remaining = columns - allocatedColumns.reduce((sum, value) => sum + value, 0);
+    const largestRemainders = rawColumns
+        .map((value, index) => ({ index, remainder: value - Math.floor(value) }))
+        .sort((left, right) => right.remainder - left.remainder);
+    for (const slot of largestRemainders) {
+        if (remaining <= 0)
+            break;
+        allocatedColumns[slot.index] = (allocatedColumns[slot.index] ?? 0) + 1;
+        remaining--;
+    }
+    return allocatedColumns;
+}
+/** Give every visible used segment at least one column before sharing the rest. */
+function allocateBarColumns(values, width) {
+    const visibleUsedSegments = USED_SEGMENTS
+        .map((_, index) => index)
+        .filter(index => (values[index] ?? 0) > 0);
+    if (visibleUsedSegments.length === 0 || visibleUsedSegments.length >= width) {
+        return allocateProportionally(values, width);
+    }
+    const minimumColumns = Array.from({ length: values.length }, () => 0);
+    for (const index of visibleUsedSegments) {
+        minimumColumns[index] = 1;
+    }
+    const remainingColumns = allocateProportionally(values, width - visibleUsedSegments.length);
+    return minimumColumns.map((minimum, index) => minimum + (remainingColumns[index] ?? 0));
+}
+/**
+ * The segmented context bar: used segments by content type, the remainder as
+ * a light free segment whose right edge carries the usage readout
+ * (`ctx 12.3k/1.0M 1.2% 988.9k`, shrinking as width allows).
+ * @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 function renderContextBar(segments, usedTokens, contextWindow, width, colors) {
+    if (width <= 0 || contextWindow <= 0)
+        return '';
+    const freeTokens = Math.max(0, contextWindow - usedTokens);
+    const values = [...USED_SEGMENTS.map(segment => segments[segment.key]), freeTokens];
+    const columns = allocateBarColumns(values, width);
+    const used = USED_SEGMENTS.map((segment, index) => renderUsedSegment(segment.labels, segment.color, columns[index] ?? 0)).join('');
+    const freeWidth = columns[USED_SEGMENTS.length] ?? 0;
+    const percent = `${((usedTokens / contextWindow) * 100).toFixed(1)}%`;
+    const total = `${formatTokens(usedTokens)}/${formatTokens(contextWindow)}`;
+    const free = formatTokens(contextWindow - usedTokens);
+    return `${used}${renderFreeSegment([`ctx ${total} ${percent} ${free}`, `${total} ${percent} ${free}`, `${total} ${percent}`, percent], freeWidth, colors?.freeFill ?? FREE_SEGMENT_FILL, colors?.freeText ?? FREE_SEGMENT_TEXT)}`;
+}
+// --- TPS gauge + sparkline (pi-tps-meter) ---
+const BLOCKS = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+const HBLOCKS = [' ', '▏', '▎', '▍', '▌', '▋', '▊', '▉'];
+const GAUGE_LEN = 11;
+const GAUGE_FLOOR = 40;
+const TRACK = '·';
+const FAST = 50;
+const MED = 20;
+/** 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 function speedColor(tps, text) {
+    const color = tps >= FAST ? 'success' : tps >= MED ? 'warning' : 'error';
+    return `\x1b[38;2;${colorHex(color)}m${text}\x1b[39m`;
+}
+function colorHex(key) {
+    // dsh-tui dark theme values (theme.ts), semicolon-separated for raw ANSI.
+    const palette = {
+        success: '78;186;101',
+        warning: '202;138;4',
+        error: '255;107;128',
+    };
+    return palette[key] ?? '255;255;255';
+}
+/** 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 function renderTpsGauge(tps, peak) {
+    const scale = Math.max(peak, GAUGE_FLOOR);
+    const frac = Math.min(1, Math.max(0, scale > 0 ? tps / scale : 0));
+    const eighths = Math.round(frac * GAUGE_LEN * 8);
+    const full = Math.floor(eighths / 8);
+    const rem = eighths % 8;
+    let fill = '█'.repeat(full);
+    if (full < GAUGE_LEN && rem > 0) {
+        fill += HBLOCKS[rem];
+    }
+    const track = TRACK.repeat(Math.max(0, GAUGE_LEN - fill.length));
+    return `▕${speedColor(tps, fill)}${`\x1b[2m${track}\x1b[22m`}▏`;
+}
+/** Min-max normalized 12-sample sparkline: `▁▄▇▅▂▁▇█▅▃▆▇`.
+ * @param samples - Turn TPS samples; only the last 12 are rendered.
+ * @returns The ANSI sparkline string.
+ */
+export function renderTpsSparkline(samples) {
+    const vals = samples.slice(-12);
+    if (vals.length === 0)
+        return '\x1b[2m' + TRACK.repeat(12) + '\x1b[22m';
+    let min = Infinity;
+    let max = 0;
+    for (const { tps } of vals) {
+        if (tps < min)
+            min = tps;
+        if (tps > max)
+            max = tps;
+    }
+    const range = max - min;
+    return vals
+        .map(({ tps }) => {
+        const norm = range < 1e-6
+            ? max > 0
+                ? 4
+                : 0
+            : Math.min(7, Math.max(0, Math.round(((tps - min) / range) * 7)));
+        return speedColor(tps, BLOCKS[norm] ?? '▁');
+    })
+        .join('');
+}
+/** 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 function tpsStats(samples, nowMs) {
+    if (samples.length === 0)
+        return { avg: 0, mean: 0, p95: 0 };
+    const window = samples.filter(sample => nowMs - sample.at <= 60_000);
+    const avg = window.length > 0
+        ? window.reduce((sum, sample) => sum + sample.tps, 0) / window.length
+        : 0;
+    const mean = samples.reduce((sum, sample) => sum + sample.tps, 0) / samples.length;
+    const sorted = [...samples].map(sample => sample.tps).sort((a, b) => a - b);
+    const p95 = sorted[Math.min(sorted.length - 1, Math.ceil(sorted.length * 0.95) - 1)] ?? 0;
+    return { avg, mean, p95 };
+}

package/lib/types/sessionHistory.d.ts

@@ -0,0 +1,32 @@
+/** One persisted session as the `/resume` picker lists it. */
+export interface SessionRecord {
+    id: string;
+    title: string;
+    cwd: string;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * Store the session to resume and report the launcher invocation.
+ * @param sessionId - Session id for `dsh-tui --resume` on the next launch.
+ */
+export declare function writeResumeTarget(sessionId: string): void;
+/** Forget the resume marker (`/new` starts a fresh conversation). */
+export declare function clearResumeTarget(): void;
+/**
+ * The session id requested by `dsh-tui --resume`, if any.
+ * @returns The stored session id, or undefined when none is set.
+ */
+export declare function readResumeTarget(): string | undefined;
+/**
+ * Session-id → last-used epoch ms map for MRU ordering.
+ * @returns The parsed map; best effort, an unreadable file yields {}.
+ */
+export declare function readLastUsed(): Readonly<Record<string, number>>;
+/**
+ * Record that a session was just used (resumed or written to) so `/resume`
+ * can sort most-recently-used first. Best effort — never throws.
+ * @param sessionId - Session id to touch.
+ */
+export declare function touchSession(sessionId: string): void;
+//# sourceMappingURL=sessionHistory.d.ts.map

package/lib/types/sessionHistory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionHistory.d.ts","sourceRoot":"","sources":["../../src/sessionHistory.ts"],"names":[],"mappings":"AAcA,8DAA8D;AAC9D,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB;AAUD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAGzD;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,IAAI,IAAI,CAMxC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAOrD;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiB/D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAQpD"}

package/lib/types/sessionHistory.js

@@ -0,0 +1,87 @@
+/**
+ * Launcher contract for `dsh-tui --resume`: the TUI writes the chosen session
+ * id to `~/.dsh-cc/resume.txt`, and the launcher feeds it back as
+ * `DSH_CC_RESUME_SESSION`. Session *records* live in DSH's own persistence
+ * backend (dsh-session-persistence-jsonl) — `/resume` lists those via
+ * `sessionPersistence.list()`, this file only carries the id across
+ * processes. It also keeps a small `last-used.json` of session-id → epoch-ms
+ * touches so `/resume` can sort most-recently-used first (DSH session
+ * headers carry only `createdAt`).
+ */
+import { homedir } from 'node:os';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const DIR = join(homedir(), '.dsh-cc');
+const RESUME_FILE = join(DIR, 'resume.txt');
+const LAST_USED_FILE = join(DIR, 'last-used.json');
+function ensureDir() {
+    mkdirSync(DIR, { recursive: true });
+}
+/**
+ * Store the session to resume and report the launcher invocation.
+ * @param sessionId - Session id for `dsh-tui --resume` on the next launch.
+ */
+export function writeResumeTarget(sessionId) {
+    ensureDir();
+    writeFileSync(RESUME_FILE, sessionId);
+}
+/** Forget the resume marker (`/new` starts a fresh conversation). */
+export function clearResumeTarget() {
+    try {
+        writeFileSync(RESUME_FILE, '');
+    }
+    catch {
+        // Best effort — the marker is a launcher nicety.
+    }
+}
+/**
+ * The session id requested by `dsh-tui --resume`, if any.
+ * @returns The stored session id, or undefined when none is set.
+ */
+export function readResumeTarget() {
+    try {
+        const value = readFileSync(RESUME_FILE, 'utf8').trim();
+        return value || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Session-id → last-used epoch ms map for MRU ordering.
+ * @returns The parsed map; best effort, an unreadable file yields {}.
+ */
+export function readLastUsed() {
+    try {
+        const parsed = JSON.parse(readFileSync(LAST_USED_FILE, 'utf8'));
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return {};
+        }
+        const record = parsed;
+        const result = {};
+        for (const [id, value] of Object.entries(record)) {
+            if (typeof value === 'number' && Number.isFinite(value)) {
+                result[id] = value;
+            }
+        }
+        return result;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Record that a session was just used (resumed or written to) so `/resume`
+ * can sort most-recently-used first. Best effort — never throws.
+ * @param sessionId - Session id to touch.
+ */
+export function touchSession(sessionId) {
+    try {
+        ensureDir();
+        const lastUsed = { ...readLastUsed(), [sessionId]: Date.now() };
+        writeFileSync(LAST_USED_FILE, JSON.stringify(lastUsed));
+    }
+    catch {
+        // Best effort — MRU ordering is a nicety.
+    }
+}