@deepseek-harness-tui/dsh-tui 0.6.1 → 0.7.1

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

@@ -1,5 +1,6 @@
 import React from 'react';
-import type { Channel } from '../channel.js';
+import type { Channel } from '../dsh-adapter/channel.js';
+import type { WaveBand } from '../dsh-adapter/types.js';
 /**
  * The footer under the prompt input, in Claude Code's PromptInputFooter
  * layout: the segmented context progress bar on its own first line, the
@@ -8,9 +9,23 @@ import type { Channel } from '../channel.js';
  * 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, }: {
+export declare function StatusLine({ channel, selectionActive, helpOpen, wake, }: {
     channel: Channel;
     selectionActive?: boolean;
     helpOpen?: boolean;
+    /**
+     * The session projected onto the status line's few columns, plus the
+     * animation tick and the self-retiring key hint.
+     *
+     * A strip that shows the session's shape keeps earning its space in a way a
+     * static label cannot, and it carries the failure signal in position rather
+     * than as a count in the corner. Absent in headless embeds, where nothing
+     * folds the event log.
+     */
+    wake?: {
+        band: WaveBand;
+        hint?: string;
+        tick: number;
+    };
 }): React.JSX.Element;
 //# sourceMappingURL=StatusLine.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"StatusLine.d.ts","sourceRoot":"","sources":["../../../src/screens/StatusLine.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAOzB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAGxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAQvD;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,eAAuB,EACvB,QAAgB,EAChB,IAAI,GACL,EAAE;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CACvD,qBA2MA"}

package/lib/types/screens/StatusLine.js

@@ -1,8 +1,11 @@
 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 { t } from '../i18n.js';
 import { Byline } from '../components/design-system/Byline.js';
 import { ActivityLine, contextPressurePct } from '../components/ActivityLine.js';
+import { modeDisplayName } from '../sessionModes.js';
+import { MiniWake } from '../components/trajectory/MiniWake.js';
 import { renderContextBar, renderTpsGauge, renderTpsSparkline, speedColor, } from './StatusMetrics.js';
 /**
  * The footer under the prompt input, in Claude Code's PromptInputFooter
@@ -12,11 +15,16 @@ import { renderContextBar, renderTpsGauge, renderTpsSparkline, speedColor, } fro
  * 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, }) {
+export function StatusLine({ channel, selectionActive = false, helpOpen = false, wake, }) {
     const { columns } = useTerminalSize();
     const [themeName] = useTheme();
     const usage = channel.lastUsage;
     const contextParts = [];
+    // Session-mode marker (Shift+Tab cycle): hidden on the unmarked base
+    // mode (index 0); sage while a plan-declaring mode is in force.
+    if (channel.modeIndex > 0) {
+        contextParts.push(_jsx(Text, { color: channel.mode.plan === true ? 'planMode' : 'warning', children: modeDisplayName(channel.mode) }, "mode"));
+    }
     if (channel.reasoningEffort !== undefined) {
         contextParts.push(_jsx(Text, { color: "inactiveShimmer", children: channel.reasoningEffort }, "effort"));
     }
@@ -26,7 +34,7 @@ export function StatusLine({ channel, selectionActive = false, helpOpen = false,
         // 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"));
+        contextParts.push(_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: t('status-cache-label') }), _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
@@ -63,7 +71,7 @@ export function StatusLine({ channel, selectionActive = false, helpOpen = false,
                 _jsx(Text, { color: "professionalBlue", children: channel.gitBranch }, "git"),
             ]
             : []),
-        _jsx(Text, { color: "inactiveShimmer", children: basename(channel.cwd) }, "cwd"),
+        _jsx(Text, { color: "inactiveShimmer", children: basename(channel.displayCwd) }, "cwd"),
         ...(channel.sessionTitle
             ? [
                 _jsx(Text, { dimColor: true, children: channel.sessionTitle }, "title"),
@@ -97,7 +105,7 @@ export function StatusLine({ channel, selectionActive = false, helpOpen = false,
     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] })] }) }));
+    return (_jsx(Box, { paddingX: 2, width: columns, flexShrink: 0, 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, wake !== undefined ? (_jsx(MiniWake, { band: wake.band, hint: wake.hint, tick: wake.tick })) : null] })] }) }));
 }
 function basename(path) {
     const parts = path.split(/[\\/]/);

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

@@ -0,0 +1,16 @@
+import React from 'react';
+import { type TrajBuild } from '../dsh-adapter/trajectory/index.js';
+import type { Channel } from '../dsh-adapter/channel.js';
+export type TrajectoryView = 'timeline' | 'hotspot';
+export declare function TrajectoryScene({ channel, build, onClose, }: {
+    channel: Channel;
+    /**
+     * The session projection, folded by the host. Passing it in rather than
+     * folding here means the chat chrome and the scene share one build, so
+     * opening the scene costs no work at all.
+     */
+    build: TrajBuild;
+    /** Leave the scene and return to the conversation. */
+    onClose: () => void;
+}): React.ReactNode;
+//# sourceMappingURL=TrajectoryScene.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TrajectoryScene.d.ts","sourceRoot":"","sources":["../../../src/screens/TrajectoryScene.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAczB,OAAO,EAML,KAAK,SAAS,EACf,MAAM,oCAAoC,CAAA;AAE3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AA+BxD,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,SAAS,CAAA;AAEnD,wBAAgB,eAAe,CAAC,EAC9B,OAAO,EACP,KAAK,EACL,OAAO,GACR,EAAE;IACD,OAAO,EAAE,OAAO,CAAA;IAChB;;;;OAIG;IACH,KAAK,EAAE,SAAS,CAAA;IAChB,sDAAsD;IACtD,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB,GAAG,KAAK,CAAC,SAAS,CAuYlB"}

package/lib/types/screens/TrajectoryScene.js

@@ -0,0 +1,305 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text, useInput, useTerminalSize } from '../ui.js';
+import { useAnimationFrame } from '../ink/hooks/use-animation-frame.js';
+import { Divider } from '../components/design-system/Divider.js';
+import { HintLine } from '../components/design-system/HintLine.js';
+import { WaveBand } from '../components/trajectory/WaveBand.js';
+import { Ledger } from '../components/trajectory/Ledger.js';
+import { Inspector } from '../components/trajectory/Inspector.js';
+import { HotspotView, hotspotRows } from '../components/trajectory/HotspotView.js';
+import { applyQuery, parseQuery } from '../trajectory/query.js';
+import { MOTION_TICK_MS } from '../trajectory/motion.js';
+import { formatDuration, formatTokens, truncateWidth } from '../trajectory/format.js';
+import { stringWidth } from '../ink/stringWidth.js';
+import { t } from '../i18n.js';
+import { aggregate, burstErrors, columnOfIndex, inspectNode, projectWave, } from '../dsh-adapter/trajectory/index.js';
+import { HOTSPOT_SORTS, WAVE_PROJECTIONS } from '../dsh-adapter/trajectory/index.js';
+/**
+ * The trajectory scene — the session's own screen.
+ *
+ * Rather than carving a panel out of the conversation, the trajectory takes
+ * the whole terminal the way `less`, `fzf` and `lazygit` do, and gives it back
+ * untouched on exit. That is not only a layout choice: the alternate screen
+ * has no scrollback, so none of the frame churn this view generates can reach
+ * the transcript — the inline shrink-frame path that once deposited UI copies
+ * into scrollback (issues #38/#39/#19/#10) is structurally out of reach here.
+ *
+ * Four regions, top to bottom: the header, the wake (whole session as one
+ * band), the ledger, and the inspector. Every region except the ledger has a
+ * fixed height, so moving the cursor never resizes the frame.
+ */
+/** Inspector height in the default (unexpanded) layout. */
+const INSPECTOR_ROWS = 6;
+/**
+ * Rows the ledger does not get: header, tabs, the wake's two rows, one blank
+ * line under the wake, the hint line, and one blank line above it.
+ *
+ * The two blank lines are deliberate. A view that fills every row edge to edge
+ * reads as pressure regardless of how good the individual rows are; giving the
+ * chrome and the content a line of ground between them costs two rows out of
+ * thirty and buys the whole screen room to breathe.
+ */
+const CHROME_ROWS = 2 + 2 + 1 + 1 + 1;
+export function TrajectoryScene({ channel, build, onClose, }) {
+    const { columns, rows } = useTerminalSize();
+    const [ref, time] = useAnimationFrame(MOTION_TICK_MS);
+    const tick = Math.floor(time / MOTION_TICK_MS);
+    const [view, setView] = React.useState('timeline');
+    const [cursor, setCursor] = React.useState(0);
+    const [hotCursor, setHotCursor] = React.useState(0);
+    const [queryOpen, setQueryOpen] = React.useState(false);
+    const [queryText, setQueryText] = React.useState('');
+    // Compressed wall-clock is the default: it reads as a session profile — busy
+    // stretches are wide AND tall, idle gaps collapse to a thin flat run — while
+    // the pure sequence axis is the specialist view for scanning what happened.
+    const [projection, setProjection] = React.useState('compressed');
+    const [sort, setSort] = React.useState('duration');
+    const [expanded, setExpanded] = React.useState(false);
+    const [inspectScroll, setInspectScroll] = React.useState(0);
+    /** Ticks at which one-shot motion verbs were triggered. */
+    const [switchTick, setSwitchTick] = React.useState(0);
+    const [alertTick, setAlertTick] = React.useState(0);
+    const [arrivalTick, setArrivalTick] = React.useState(0);
+    const [arrivalFrom, setArrivalFrom] = React.useState(Number.MAX_SAFE_INTEGER);
+    /** Cursor pinned to the tail until the user scrolls away from it. */
+    const [follow, setFollow] = React.useState(true);
+    // ── projection ───────────────────────────────────────────────────────────
+    const nodes = build.nodes;
+    const query = React.useMemo(() => parseQuery(queryText), [queryText]);
+    const { rows: filtered, indexes } = React.useMemo(() => applyQuery(nodes, query), 
+    // `nodes` is mutated in place by the incremental fold, so its length is
+    // the honest dependency — the array identity never changes.
+    // oxlint-disable-next-line react-hooks/exhaustive-deps
+    [nodes, nodes.length, query]);
+    const agg = React.useMemo(
+    // oxlint-disable-next-line react-hooks/exhaustive-deps
+    () => aggregate(build, sort), [build, nodes.length, sort]);
+    // ── arrival + alert detection ────────────────────────────────────────────
+    const seenRef = React.useRef(0);
+    const errorsRef = React.useRef(0);
+    React.useEffect(() => {
+        if (nodes.length > seenRef.current) {
+            setArrivalFrom(seenRef.current);
+            setArrivalTick(tick);
+            seenRef.current = nodes.length;
+            if (follow)
+                setCursor(Math.max(0, filtered.length - 1));
+        }
+        if (agg.totals.errors > errorsRef.current) {
+            errorsRef.current = agg.totals.errors;
+            setAlertTick(tick);
+        }
+    }, [nodes.length, agg.totals.errors, tick, follow, filtered.length]);
+    // ── geometry ─────────────────────────────────────────────────────────────
+    const inspectorRows = expanded ? Math.max(4, rows - CHROME_ROWS - 3) : INSPECTOR_ROWS;
+    const ledgerRows = Math.max(1, rows - CHROME_ROWS - inspectorRows - 1);
+    const bandWidth = Math.max(1, columns - 4);
+    const clampedCursor = filtered.length === 0 ? 0 : Math.min(cursor, filtered.length - 1);
+    const windowStart = Math.max(0, Math.min(clampedCursor - Math.floor(ledgerRows / 2), filtered.length - ledgerRows));
+    const band = React.useMemo(
+    // oxlint-disable-next-line react-hooks/exhaustive-deps
+    () => projectWave(nodes, bandWidth, projection), [nodes, nodes.length, bandWidth, projection]);
+    const matchColumns = React.useMemo(() => {
+        if (query.empty)
+            return undefined;
+        const set = new Set();
+        for (const index of indexes)
+            set.add(columnOfIndex(band, index));
+        return set;
+    }, [band, indexes, query.empty]);
+    const focused = filtered[clampedCursor];
+    const detail = React.useMemo(() => (focused === undefined ? undefined : inspectNode(focused, channel.traceEvents())), [focused, channel]);
+    // ── navigation helpers ───────────────────────────────────────────────────
+    const move = React.useCallback((delta) => {
+        setExpanded(false);
+        setInspectScroll(0);
+        setCursor(previous => {
+            const next = Math.max(0, Math.min(filtered.length - 1, previous + delta));
+            setFollow(next >= filtered.length - 1);
+            return next;
+        });
+    }, [filtered.length]);
+    const seek = React.useCallback((predicate, forward) => {
+        const from = clampedCursor;
+        const limit = filtered.length;
+        for (let step = 1; step <= limit; step++) {
+            const index = forward ? from + step : from - step;
+            if (index < 0 || index >= limit)
+                continue;
+            if (predicate(index)) {
+                setExpanded(false);
+                setInspectScroll(0);
+                setCursor(index);
+                setFollow(index >= limit - 1);
+                return;
+            }
+        }
+    }, [clampedCursor, filtered.length]);
+    const isFailure = React.useCallback((index) => {
+        const node = filtered[index];
+        return (node !== undefined &&
+            (node.status === 'error' || node.kind === 'retry' || (node.burst !== undefined && burstErrors(node.burst) > 0)));
+    }, [filtered]);
+    const switchView = React.useCallback((next) => {
+        setView(next);
+        setSwitchTick(tick);
+        setExpanded(false);
+        setInspectScroll(0);
+    }, [tick]);
+    // ── keys ─────────────────────────────────────────────────────────────────
+    useInput((input, key) => {
+        // The query line owns the keyboard while open, so a `q` typed into a
+        // search does not close the scene.
+        if (queryOpen) {
+            if (key.escape) {
+                setQueryOpen(false);
+                setQueryText('');
+                return;
+            }
+            if (key.return) {
+                setQueryOpen(false);
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setQueryText(previous => previous.slice(0, -1));
+                setCursor(0);
+                return;
+            }
+            if (input && !key.ctrl && !key.meta) {
+                setQueryText(previous => previous + input);
+                setCursor(0);
+            }
+            return;
+        }
+        if (key.escape || input === 'q') {
+            if (expanded) {
+                setExpanded(false);
+                setInspectScroll(0);
+                return;
+            }
+            if (!query.empty) {
+                setQueryText('');
+                return;
+            }
+            onClose();
+            return;
+        }
+        if (key.leftArrow)
+            return switchView('timeline');
+        if (key.rightArrow)
+            return switchView('hotspot');
+        if (input === 'h')
+            return switchView(view === 'hotspot' ? 'timeline' : 'hotspot');
+        if (input === '/') {
+            setQueryOpen(true);
+            return;
+        }
+        if (view === 'hotspot') {
+            const total = hotspotRows(agg).length;
+            if (key.upArrow)
+                return setHotCursor(previous => Math.max(0, previous - 1));
+            if (key.downArrow)
+                return setHotCursor(previous => Math.min(total - 1, previous + 1));
+            if (input === 't') {
+                setSort(previous => HOTSPOT_SORTS[(HOTSPOT_SORTS.indexOf(previous) + 1) % HOTSPOT_SORTS.length]);
+                setSwitchTick(tick);
+                return;
+            }
+            if (key.return) {
+                // Jump back to the timeline, positioned on the group's first member.
+                const row = hotspotRows(agg)[hotCursor];
+                switchView('timeline');
+                if (row !== undefined) {
+                    const target = indexes.indexOf(row.firstIndex);
+                    setCursor(target >= 0 ? target : 0);
+                    setFollow(false);
+                }
+                return;
+            }
+            return;
+        }
+        if (key.upArrow)
+            return move(-1);
+        if (key.downArrow)
+            return move(1);
+        if (key.pageUp)
+            return move(-ledgerRows);
+        if (key.pageDown)
+            return move(ledgerRows);
+        if (input === 'g') {
+            setCursor(0);
+            setFollow(false);
+            return;
+        }
+        if (input === 'G') {
+            setCursor(Math.max(0, filtered.length - 1));
+            setFollow(true);
+            return;
+        }
+        if (input === '[')
+            return seek(isFailure, false);
+        if (input === ']')
+            return seek(isFailure, true);
+        if (input === '{')
+            return seek(index => filtered[index]?.kind === 'turn', false);
+        if (input === '}')
+            return seek(index => filtered[index]?.kind === 'turn', true);
+        if (input === 'm') {
+            setProjection(previous => WAVE_PROJECTIONS[(WAVE_PROJECTIONS.indexOf(previous) + 1) % WAVE_PROJECTIONS.length]);
+            setSwitchTick(tick);
+            return;
+        }
+        if (key.return) {
+            setExpanded(previous => !previous);
+            setInspectScroll(0);
+            return;
+        }
+        if (expanded && (input === 'j' || input === 'k')) {
+            setInspectScroll(previous => Math.max(0, previous + (input === 'j' ? inspectorRows - 2 : -(inspectorRows - 2))));
+        }
+    });
+    // ── header ───────────────────────────────────────────────────────────────
+    //
+    // Both chrome rows are composed as ONE pre-measured line each rather than as
+    // a flex row of groups. Flex plus `wrap="truncate"` proved unreliable here:
+    // a right-hand group laid out at its natural width lost its last character,
+    // and under other splits the overflow reflowed onto the row below — which
+    // pushes every region beneath it down and breaks the fixed geometry the
+    // whole scene depends on. Padding to an exact column count is deterministic,
+    // CJK-aware, and cheap (two strings per frame).
+    const { totals } = agg;
+    /** Left text, a computed gap, right text — clipped to `width` columns. */
+    const spread = (left, right, width) => {
+        const rightText = truncateWidth(right, Math.max(0, width - 4));
+        const room = width - stringWidth(rightText);
+        const leftText = truncateWidth(left, Math.max(0, room - 1));
+        return {
+            left: leftText,
+            gap: ' '.repeat(Math.max(1, room - stringWidth(leftText))),
+            right: rightText,
+        };
+    };
+    const totalsText = t('traj-totals', { turns: totals.turns, steps: totals.rows }) +
+        (totals.errors > 0 ? ` \u00b7 ${t('traj-errors', { n: totals.errors })}` : '') +
+        (totals.retries > 0 ? ` \u00b7 ${t('traj-retries', { n: totals.retries })}` : '') +
+        ` \u00b7 ${formatDuration(totals.spanMs)}`;
+    const headerLine = spread(`\u2726 ${t('traj-title')}  ${channel.sessionTitle ?? channel.cwd}`, totalsText, bandWidth);
+    const header = (_jsx(Box, { width: "100%", height: 1, flexShrink: 0, children: _jsxs(Text, { children: [_jsx(Text, { color: "claude", bold: true, children: `\u2726 ${t('traj-title')}` }), _jsx(Text, { color: "subtle", children: headerLine.left.slice((`\u2726 ${t('traj-title')}`).length) }), _jsx(Text, { children: headerLine.gap }), _jsx(Text, { color: totals.errors > 0 ? 'error' : 'subtle', children: headerLine.right })] }) }));
+    const axisLabel = view === 'hotspot' ? t(`traj-sort-${sort}`) : t(`traj-proj-${projection}`);
+    const tabsLeft = `${view === 'timeline' ? '\u25cf' : '\u25cb'} ${t('traj-tab-timeline')}  ` +
+        `${view === 'hotspot' ? '\u25cf' : '\u25cb'} ${t('traj-tab-hotspot')}`;
+    const queryText_ = queryOpen || !query.empty
+        ? `   / ${queryText}${queryOpen ? '\u258c' : ''}  ${t('traj-matches', { n: filtered.length, total: nodes.length })}`
+        : '';
+    const tabsLine = spread(tabsLeft + queryText_, axisLabel, bandWidth);
+    const tabs = (_jsx(Box, { width: "100%", height: 1, flexShrink: 0, children: _jsxs(Text, { children: [_jsx(Text, { color: view === 'timeline' ? 'permission' : 'subtle', bold: view === 'timeline', children: tabsLine.left.slice(0, tabsLeft.length) }), _jsx(Text, { color: "suggestion", children: tabsLine.left.slice(tabsLeft.length) }), _jsx(Text, { children: tabsLine.gap }), _jsx(Text, { color: "subtle", children: tabsLine.right })] }) }));
+    const hints = view === 'hotspot'
+        ? t('traj-hint-hotspot')
+        : queryOpen
+            ? t('traj-hint-query')
+            : expanded
+                ? t('traj-hint-expanded')
+                : t('traj-hint-timeline');
+    return (_jsxs(Box, { ref: ref, flexDirection: "column", width: "100%", paddingX: 1, children: [header, tabs, _jsx(WaveBand, { band: band, width: bandWidth, cursorColumn: columnOfIndex(band, indexes[clampedCursor] ?? 0), viewportStart: columnOfIndex(band, indexes[windowStart] ?? 0), viewportEnd: columnOfIndex(band, indexes[Math.min(filtered.length - 1, windowStart + ledgerRows - 1)] ?? 0), matches: matchColumns, tick: tick, alertTick: alertTick }), _jsx(Box, { height: 1, flexShrink: 0, children: _jsx(Text, { children: " " }) }), view === 'timeline' ? (_jsxs(_Fragment, { children: [_jsx(Ledger, { rows: filtered, start: windowStart, height: ledgerRows, cursor: clampedCursor, width: columns - 4, tick: tick, arrivalTick: arrivalTick, arrivalFrom: arrivalFrom }), _jsx(Divider, { color: "permission", width: bandWidth }), _jsx(Inspector, { node: focused, detail: detail, height: inspectorRows, width: columns - 4, expanded: expanded, scroll: inspectScroll })] })) : (_jsx(HotspotView, { agg: agg, sort: sort, width: columns - 4, height: ledgerRows + inspectorRows + 1, cursor: hotCursor, tick: tick, switchTick: switchTick })), _jsx(Box, { height: 1, flexShrink: 0, children: _jsx(Text, { children: " " }) }), _jsx(Box, { width: "100%", height: 1, flexShrink: 0, children: _jsxs(Text, { dimColor: true, italic: true, wrap: "truncate", children: [_jsx(HintLine, { text: hints }), totals.tokens.input > 0 ? (_jsx(Text, { color: "subtle", children: `   ${formatTokens(totals.tokens.input)}→${formatTokens(totals.tokens.output)}` })) : ('')] }) })] }));
+}

package/lib/types/sessionHistory.d.ts

@@ -8,13 +8,15 @@ export interface SessionRecord {
 }
 /**
  * Store the session to resume and report the launcher invocation.
+ * Dual-writes the legacy path for pre-rename launchers (see header).
  * @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.
+ * The session id requested by `dsh-tui --resume`, if any. The new path
+ * wins; the legacy path is the fallback for pre-rename launchers.
  * @returns The stored session id, or undefined when none is set.
  */
 export declare function readResumeTarget(): string | undefined;
@@ -29,4 +31,10 @@ export declare function readLastUsed(): Readonly<Record<string, number>>;
  * @param sessionId - Session id to touch.
  */
 export declare function touchSession(sessionId: string): void;
+/**
+ * Drop a session's last-used entry (`/resume` picker delete) so the MRU map
+ * never accumulates ids whose logs are gone. Best effort — never throws.
+ * @param sessionId - Session id to forget.
+ */
+export declare function forgetSession(sessionId: string): void;
 //# sourceMappingURL=sessionHistory.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"sessionHistory.d.ts","sourceRoot":"","sources":["../../src/sessionHistory.ts"],"names":[],"mappings":"AAoBA,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;AAWD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CASzD;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,IAAI,IAAI,CAQxC;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAUrD;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;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAUrD"}

package/lib/types/sessionHistory.js

@@ -1,51 +1,73 @@
 /**
  * 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
+ * id to `~/.dsh-tui/resume.txt`, and the launcher feeds it back as
+ * `DSH_TUI_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`).
+ *
+ * Rename transition (issue #120): the global bin and the profile's TUI
+ * package may run different versions, so `resume.txt` is DUAL-WRITTEN to the
+ * legacy `~/.dsh-cc/resume.txt` as well (old launchers read only that path)
+ * and reads fall back to it. TODO: drop the legacy path once pre-rename
+ * launchers have aged out.
  */
-import { homedir } from 'node:os';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-const DIR = join(homedir(), '.dsh-cc');
+import { DATA_DIR, LEGACY_DATA_DIR } from './utils/paths.js';
+const DIR = DATA_DIR;
 const RESUME_FILE = join(DIR, 'resume.txt');
+const LEGACY_RESUME_FILE = join(LEGACY_DATA_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.
+ * Dual-writes the legacy path for pre-rename launchers (see header).
  * @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, '');
+        mkdirSync(LEGACY_DATA_DIR, { recursive: true });
+        writeFileSync(LEGACY_RESUME_FILE, sessionId);
     }
     catch {
-        // Best effort — the marker is a launcher nicety.
+        // Best effort — the legacy mirror only serves old launchers.
+    }
+}
+/** Forget the resume marker (`/new` starts a fresh conversation). */
+export function clearResumeTarget() {
+    for (const file of [RESUME_FILE, LEGACY_RESUME_FILE]) {
+        try {
+            writeFileSync(file, '');
+        }
+        catch {
+            // Best effort — the marker is a launcher nicety.
+        }
     }
 }
 /**
- * The session id requested by `dsh-tui --resume`, if any.
+ * The session id requested by `dsh-tui --resume`, if any. The new path
+ * wins; the legacy path is the fallback for pre-rename launchers.
  * @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;
+    for (const file of [RESUME_FILE, LEGACY_RESUME_FILE]) {
+        try {
+            const value = readFileSync(file, 'utf8').trim();
+            if (value)
+                return value;
+        }
+        catch {
+            // Try the next candidate.
+        }
     }
+    return undefined;
 }
 /**
  * Session-id → last-used epoch ms map for MRU ordering.
@@ -85,3 +107,21 @@ export function touchSession(sessionId) {
         // Best effort — MRU ordering is a nicety.
     }
 }
+/**
+ * Drop a session's last-used entry (`/resume` picker delete) so the MRU map
+ * never accumulates ids whose logs are gone. Best effort — never throws.
+ * @param sessionId - Session id to forget.
+ */
+export function forgetSession(sessionId) {
+    try {
+        const lastUsed = { ...readLastUsed() };
+        if (!(sessionId in lastUsed))
+            return;
+        delete lastUsed[sessionId];
+        ensureDir();
+        writeFileSync(LAST_USED_FILE, JSON.stringify(lastUsed));
+    }
+    catch {
+        // Best effort — a stale entry only skews sort order.
+    }
+}

package/lib/types/sessionModes.d.ts

@@ -0,0 +1,29 @@
+export interface SessionModeSpec {
+    /** Stable id; also the display name unless `label` is set or the id is a
+     *  localized built-in (`default`/`plan`/`full`). */
+    id: string;
+    /** Optional display label; wins over the built-in i18n name. */
+    label?: string;
+    /** Plan mode on/off (dsh-plan-mode `/plan`). */
+    plan?: boolean;
+    /** Sandbox mode override (dsh-sandbox-policy `sandbox/mode`). */
+    sandbox?: 'read-only' | 'workspace-write' | 'danger-full-access';
+    /** Approval policy override (dsh-user-approval `approval/policy`). */
+    approval?: 'ask' | 'never';
+}
+/** The shipped cycle when cordis.yml pins no `modes` — array order IS the
+ *  Shift+Tab cycle order; index 0 is the unmarked base mode. */
+export declare const DEFAULT_SESSION_MODES: readonly SessionModeSpec[];
+/** Config → cycle list: undefined/empty → DEFAULT_SESSION_MODES; entries
+ *  declaring no atom at all are dropped (their ids are returned for the
+ *  caller to warn about); if nothing survives, DEFAULT_SESSION_MODES. Atom
+ *  vocabularies are already enforced by the plugin Schema at load, so no
+ *  value validation happens here. */
+export declare function resolveSessionModes(raw: readonly SessionModeSpec[] | undefined): {
+    modes: readonly SessionModeSpec[];
+    dropped: readonly string[];
+};
+/** Display name: explicit `label` > built-in i18n (`mode-default`/
+ *  `mode-plan`/`mode-full` for those ids) > the raw id. */
+export declare function modeDisplayName(spec: SessionModeSpec): string;
+//# sourceMappingURL=sessionModes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sessionModes.d.ts","sourceRoot":"","sources":["../../src/sessionModes.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,eAAe;IAC9B;wDACoD;IACpD,EAAE,EAAE,MAAM,CAAA;IACV,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,gDAAgD;IAChD,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,iEAAiE;IACjE,OAAO,CAAC,EAAE,WAAW,GAAG,iBAAiB,GAAG,oBAAoB,CAAA;IAChE,sEAAsE;IACtE,QAAQ,CAAC,EAAE,KAAK,GAAG,OAAO,CAAA;CAC3B;AAED;gEACgE;AAChE,eAAO,MAAM,qBAAqB,EAAE,SAAS,eAAe,EAI3D,CAAA;AAED;;;;qCAIqC;AACrC,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,GAAG;IAChF,KAAK,EAAE,SAAS,eAAe,EAAE,CAAA;IACjC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAC3B,CASA;AAED;2DAC2D;AAC3D,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAM7D"}