dsh-ssh-tui 0.5.10 → 0.6.0

package/lib/tui.js

@@ -30,7 +30,12 @@ import { classifyApprovalDetailed, commandForApprovalRequest, isApprovalStatusAr
 import { buildReviewUserMessage, parseReviewOutput, reviewSystemPrompt } from './approval-reviewer.js';
 import { loadProviderCatalog, mergeProviderEntries } from './provider-catalog.js';
 import { formatFooterCwd, formatSessionTime, listResumableSessions } from './session-list.js';
-import { detachFromSshSession, DisplayHost, resolveDshHome, sessionSockPath } from './display-sock.js';
+import { collectDiag, formatDiag } from './diag.js';
+import { SessionStatsTracker, statsRowOf } from './stats.js';
+import { QUESTION_OPTION_KEYS, confirmAnswer, inspectClosesOn, moveQuestionCursor, optionsLength, questionSubmit, selectQuestionOptionByKey, } from './dialogs.js';
+import { commandSuggestions, localizedCommands } from './commands.js';
+import { archiveStalePlans, boundTranscriptRows, findLivePlanRow, findMergeableToolRow, findToolRowByCallId, mergeToolCard, planShouldDefaultExpand, windowTranscript, } from './rows.js';
+import { detachFromSshSession, DisplayHost, isTuiHostProcess, resolveDshHome, sessionSockPath } from './display-sock.js';
 import { applySavedLocale, getLocale, localeDisplayName, localeFromTag, setLocale, t, UI_LOCALE_NAMESPACE, } from './i18n/index.js';
 import { defaultReasoningEffort } from './reasoning.js';
 import { checkForPluginUpdate, installPluginLatest } from './update-check.js';
@@ -42,10 +47,11 @@ import { copyTextFromTranscript } from './copy-text.js';
 import { UserQuestionError, } from '@deepseek-ai/dsh-user-questions';
 import { clipAnsiToWidth, hrefAtColumn, osc52Clipboard, paintedLinkHits, cursorVisualPosition, displayWidth, foldInputView, fmtElapsedCompact, lastCodePoints, padToWidth, sliceCodePoints, paintSegmentedLine, renderMarkdownLines, repeatToWidth, sanitizeTerminalText, shimmerText, truncate, truncateToWidth, waitCardCopy, wrap, wrapSegmented, wrapWaitDetails, } from './term-text.js';
 import { captureHangupSignals, composePaintOutput, detectSshSession, formatLinkQualityChip, HANGUP_CANCEL_TIMEOUT_MS, ignoreFurtherHangupSignals, isEscapePrefix, isHangupErrno, parseCursorPositionReply, PICKER_WINDOW, pickerWindowStart, probeTerminalRttMs, releaseHangupSignals, resolvePaintIntervalMs, waitUntilIdleOrTimeout, } from './paint.js';
+import { TerminalInputGuard } from './terminal-input.js';
 import { contextPressureAlertText, contextPressureRingColor, contextPressureView, formatContextPressureRing, describeProviderRoute, fitFooterStatsLine, fitFooterStatusLine, footerActivity, footerIdentityParts, footerStatsGroups, formatContextPressureChip, formatStatusReport, formatTokens, parseContextPressure, promptPressureTokens, providerUsesLocalOAuth, shouldIdleAutoCompact, } from './footer.js';
 import { crossedQuotaThresholds, DEEPSEEK_PUBLIC_BASE_URL, formatAccountBalance, formatFooterBalance, formatQuotaSnapshot, joinUrl, OPENAI_COMPAT_BALANCE_PATHS, OPENCODE_GO_USAGE_URL, OPENCODE_ZEN_BASE_URL, openCodeApiErrorMessage, openCodeSourceFor, parseDeepSeekBalance, parseOpenAiCompatibleBalance, parseOpenCodeGoQuota, parseSuperGrokBilling, quotaAlertText, quotaRefreshEverySteps, reasoningEffortsForDefault, SUPERGROK_BILLING_URL, tightestQuotaWindow, } from './quota.js';
 import { appendSubagentLog, applyTurnEndToPlan, cardCategoryLabel, cardCategoryOf, compactionHeaderText, formatCompactCommandError, isPromptInjectionMessage, matchTranscriptRows, parseFindQuery, parsePlanTodos, planCloseNudgeText, planMarkdownFromArgs, planDockNote, planIsLive, planTitleFromMarkdown, promptInjectionSources, promptInjectionTitle, subagentHeaderText, todoItemKind, todoProgressLabel, TODO_STATUS_MARK, } from './plan.js';
-import { buildToolHeader, canMergeToolCall, compactEditPath, compactToolBursts, countDiffAddDel, countDiffLines, countOutputLines, diffMetaDiffs, diffStatToken, formatModelList, HIDDEN_TOOL_NAMES, parseExitStatus, planReviewOf, presentToolCall, READ_TOOL_NAMES, SHELL_TOOL_NAMES, toolBodyFitsWorkspace, toolBodyLines, toolTitle, TOOL_FLIP_MS, wrappedToolBodyLineCount, } from './tool-present.js';
+import { buildToolHeader, compactEditPath, compactToolBursts, countDiffAddDel, countDiffLines, countOutputLines, diffMetaDiffs, diffStatToken, formatModelList, HIDDEN_TOOL_NAMES, parseExitStatus, planReviewOf, presentToolCall, READ_TOOL_NAMES, SHELL_TOOL_NAMES, toolBodyFitsWorkspace, toolBodyLines, toolTitle, wrappedToolBodyLineCount, } from './tool-present.js';
 export { clipAnsiToWidth, cursorVisualPosition, displayWidth, foldInputView, hrefAtColumn, osc52Clipboard, osc8Enabled, paintedLinkHits, fmtElapsedCompact, padAnsiToWidth, padToWidth, renderMarkdownLines, repeatToWidth, shimmerText, truncateToWidth, visibleWidth, waitCardCopy, waitSummaryFromReasoning, wrapWaitDetails, } from './term-text.js';
 export { captureHangupSignals, composePaintOutput, detectSshSession, formatLinkQualityChip, ignoreFurtherHangupSignals, isEscapePrefix, findCursorPositionReply, isHangupErrno, linkQualityOf, linkSignalPips, paintIntervalForRtt, paintLinkLabel, parseCursorPositionReply, pickerWindowStart, probeTerminalRttMs, releaseHangupSignals, resolvePaintIntervalMs, waitUntilIdleOrTimeout, writeBootSplash, } from './paint.js';
 export { CONTEXT_IDLE_COMPACT_RATIO, CONTEXT_PRESSURE_DANGER_RATIO, CONTEXT_PRESSURE_WARN_RATIO, CONTEXT_RING_EMPTY, CONTEXT_RING_SEGMENTS, contextPressureAlertText, contextPressureRingColor, contextPressureUsedTokens, contextPressureView, describeProviderRoute, dropFooterQuotaPlanName, fitFooterStatsLine, fitFooterStatusLine, footerActivity, footerIdentityParts, footerStatsGroups, formatContextPressureChip, formatContextPressureRing, formatContextPressureStatusLine, formatDuration, formatFooterQuota, formatQuotaBar, formatStatusReport, formatTokens, formatTokensPerSecond, parseContextPressure, promptPressureTokens, providerShortCode, providerUsesLocalOAuth, shouldIdleAutoCompact, subagentRouteLabel, } from './footer.js';
@@ -138,16 +144,50 @@ const PLUGIN_VERSION = (() => {
 })();
 const STALL_WARNING_MS = 60000;
 const DEFAULT_DETACHED_IDLE_MS = 6 * 60 * 60 * 1000;
+/**
+ * How long a leftover Host that has finished its work waits, with no display,
+ * for the user to come back before it exits on its own.
+ *
+ * The Host holds the session's kernel write lock (`session.lock`) for its whole
+ * life, and that lock is exactly what makes the browser surface answer
+ * `resume failed for session "…"` (the persistence layer refuses a second
+ * writer). A Host kept alive by a busy SSH drop therefore used to block the same
+ * session in the Web UI for the full {@link DEFAULT_DETACHED_IDLE_MS} (six
+ * hours), long after the turn it stayed behind for had already finished: the
+ * session looked unreachable from both surfaces while an idle process held it.
+ * A minute is enough to notice the drop and reattach; after that the turn has
+ * long been flushed, so `--resume` reopens the same log in a fresh Host.
+ *
+ * `DSH_TUI_IDLE_EXIT_MS` (or `ssh-tui.idleExit` in settings.yaml) overrides it;
+ * `0`/`off` restores the legacy "wait for the six-hour timer" behavior.
+ */
+const DEFAULT_IDLE_EXIT_MS = 60 * 1000;
 const CTRL_C_EXIT_WINDOW_MS = 2000;
 const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-const QUESTION_OPTION_KEYS = '123456789abcdefghijklmnopqrstuvwxyz';
 const SUBAGENT_DEFAULT_EFFORT_LABEL = () => t('footer.effortDefault');
 const RESERVED_BOTTOM_LINES = 3; // input line + stats line + status line
-const MAX_TRANSCRIPT_ROWS = 5000;
 const IS_WINDOWS = process.platform === 'win32';
 function dshHomeDir() {
     return resolveDshHome();
 }
+/**
+ * Version of the host packages this process booted from, for `/diag`. Resolved
+ * from the running plugin's own tree, so it reports what is actually loaded
+ * rather than what is installed elsewhere.
+ */
+function hostDshVersion() {
+    for (const id of ['@deepseek-ai/dsh-agent/package.json', '@deepseek-ai/dsh/package.json']) {
+        try {
+            const parsed = createRequire(import.meta.url)(id);
+            if (typeof parsed.version === 'string')
+                return parsed.version;
+        }
+        catch {
+            // try the next candidate
+        }
+    }
+    return 'unknown';
+}
 function displayDshPath(file) {
     const home = dshHomeDir();
     if (IS_WINDOWS) {
@@ -271,45 +311,6 @@ const DEEPSEEK_LOGO_VARIANTS = [
         ],
     },
 ];
-const LOCAL_COMMANDS = [
-    { name: 'help', key: 'cmd.help' },
-    { name: 'model', key: 'cmd.model' },
-    { name: 'effort', key: 'cmd.effort' },
-    { name: 'provider', key: 'cmd.provider' },
-    { name: 'submodel', key: 'cmd.submodel' },
-    { name: 'subeffort', key: 'cmd.subeffort' },
-    { name: 'mode', key: 'cmd.mode' },
-    { name: 'quit', key: 'cmd.quit' },
-    { name: 'exit', key: 'cmd.quit', aliasOf: 'quit' },
-    { name: 'clear', key: 'cmd.clear' },
-    { name: 'status', key: 'cmd.status' },
-    { name: 'disconnect', key: 'cmd.disconnect' },
-    { name: 'approval', key: 'cmd.approval' },
-    { name: 'view', key: 'cmd.view' },
-    { name: 'usage', key: 'cmd.usage' },
-    { name: 'balance', key: 'cmd.usage', aliasOf: 'usage' },
-    { name: 'quota', key: 'cmd.usage', aliasOf: 'usage' },
-    { name: 'subagents', key: 'cmd.subagents' },
-    { name: 'resume', key: 'cmd.resume' },
-    { name: 'setup', key: 'cmd.setup' },
-    { name: 'find', key: 'cmd.find' },
-    { name: 'copy', key: 'cmd.copy' },
-    { name: 'language', key: 'cmd.language' },
-    { name: 'lang', key: 'cmd.language', aliasOf: 'language' },
-    { name: 'dialog-test', key: 'cmd.dialog-test' },
-];
-function commandDescription(name, aliasOf) {
-    if (aliasOf !== undefined)
-        return t('cmd.aliasOf', { name: aliasOf });
-    return t(`cmd.${name}`);
-}
-function localizedCommands() {
-    return LOCAL_COMMANDS.map(command => ({
-        name: command.name,
-        description: commandDescription(command.name, 'aliasOf' in command ? command.aliasOf : undefined),
-        ...('aliasOf' in command ? { aliasOf: command.aliasOf } : {}),
-    }));
-}
 export function parseDisconnectPolicy(raw) {
     const id = raw.trim().toLowerCase();
     if (id === 'pause' || id === 'cancel' || id === '暂停')
@@ -392,6 +393,9 @@ export class SshTui {
     headlessDisplay;
     disconnectPolicy;
     detachedIdleTimer;
+    /** Armed once an SSH drop left this Host alive with work still running. */
+    hostKeptAlive = false;
+    idleExitTimer;
     displayDetached = false;
     displayHost;
     relayColumns;
@@ -434,27 +438,18 @@ export class SshTui {
     openToolCalls = new Map();
     /** Survives result settlement so a card-less result can still be labelled. */
     toolCallNames = new Map();
-    stats = {
-        turns: 0,
-        steps: 0,
-        llmMs: 0,
-        toolMs: 0,
-        ttftMs: 0,
-        ttftSteps: 0,
-        decodeMs: 0,
-        decodeTokens: 0,
-        usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 },
-    };
-    openStepStats;
+    /** Session totals; the tracker owns the arithmetic (see `stats.ts`). */
+    statsTracker = new SessionStatsTracker();
+    /** Snapshot of the session totals, for the footer and `/status`. */
+    get stats() {
+        return this.statsTracker.snapshot();
+    }
     /** Attempt whose live `start` frame opened the current token stream. */
     liveStreamOwner;
     /** Live events parked while the (yielding) history replay holds the floor. */
     replayQueue;
     /** A relay claimed the display while a hangup was still cancelling/flushing. */
     reattachedDuringHangup = false;
-    pendingToolTimes = new Map();
-    usageByStep = new Map();
-    lastStatsTurn = null;
     scrollOffset = 0;
     clickableRows = new Map();
     paintedLinkHitsByRow = new Map();
@@ -470,6 +465,12 @@ export class SshTui {
     streamingReasoning;
     escapeBuffer = '';
     escapeTimer;
+    /**
+     * Cursor-position replies removed from the relay's stdin stream. A launcher
+     * from an older release (or a reply that raced its own probe) would otherwise
+     * type `[17;1R` into the prompt or cancel a dialog with a bare ESC.
+     */
+    inputGuard = new TerminalInputGuard(text => this.handleInputText(text));
     thinkingStartedAt;
     waitStartedAt;
     completionSignaled = false;
@@ -742,6 +743,62 @@ export class SshTui {
         }, idleMs);
         this.detachedIdleTimer.unref?.();
     }
+    /**
+     * How long a leftover, finished Host may sit with no display before it exits
+     * and hands the session back. `0` disables the exit (legacy behavior).
+     */
+    idleExitMs() {
+        const raw = Number.parseInt(process.env.DSH_TUI_IDLE_EXIT_MS ?? '', 10);
+        if (Number.isFinite(raw) && raw >= 0)
+            return raw;
+        const saved = this.ctx.get('settings')?.get(UI_LOCALE_NAMESPACE);
+        if (saved !== null && typeof saved === 'object' && !Array.isArray(saved)) {
+            const value = saved.idleExit;
+            if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
+                return value;
+            const text = String(value ?? '').trim().toLowerCase();
+            if (text === 'off' || text === 'never' || text === 'false')
+                return 0;
+            const parsed = Number.parseInt(text, 10);
+            if (Number.isFinite(parsed) && parsed >= 0)
+                return parsed;
+        }
+        return DEFAULT_IDLE_EXIT_MS;
+    }
+    clearIdleExitTimer() {
+        if (this.idleExitTimer !== undefined)
+            clearTimeout(this.idleExitTimer);
+        this.idleExitTimer = undefined;
+    }
+    /**
+     * Arm the exit for a Host a busy SSH drop left behind. Called when the agent
+     * goes idle — the reason the Host was kept is gone, and every second it stays
+     * is a second its `session.lock` keeps the browser surface from opening the
+     * session (`resume failed for session "…"`). A reattach cancels it.
+     */
+    armIdleExitTimer() {
+        if (!this.headlessDisplay || !this.hostKeptAlive)
+            return;
+        const idleMs = this.idleExitMs();
+        if (idleMs <= 0)
+            return;
+        this.clearIdleExitTimer();
+        this.idleExitTimer = setTimeout(() => {
+            this.idleExitTimer = undefined;
+            if (this.disposed || this.exiting)
+                return;
+            if (this.displayHost?.attached === true)
+                return;
+            if (this.isBusyForHangupKeepalive()) {
+                this.armIdleExitTimer();
+                return;
+            }
+            // Flush + exit, exactly like an idle hangup: the turn already ended, so
+            // nothing is cancelled and the lock goes back to the session store.
+            void this.requestExit(0);
+        }, idleMs);
+        this.idleExitTimer.unref?.();
+    }
     isCompactView() {
         return this.workspaceView === 'compact';
     }
@@ -1030,6 +1087,7 @@ export class SshTui {
         if (this.escapeTimer !== undefined)
             clearTimeout(this.escapeTimer);
         this.escapeTimer = undefined;
+        this.inputGuard.stop();
         process.stdin.removeListener('data', this.handleData);
         process.stdout.removeListener('resize', this.onDirectResize);
         process.stdout.removeListener('error', this.handleIoError);
@@ -1075,6 +1133,7 @@ export class SshTui {
         this.disposed = true;
         this.exiting = true;
         this.clearDetachedIdleTimer();
+        this.clearIdleExitTimer();
         const dialog = this.dialog;
         const queued = this.dialogQueue.splice(0);
         this.dialog = undefined;
@@ -1110,6 +1169,27 @@ export class SshTui {
         if (host !== undefined)
             await host.close();
     }
+    /**
+     * `/diag`: collect the local facts about this session's channel, lock, and
+     * Host, then print the decision chain. Everything is local; nothing is sent
+     * anywhere (see the privacy note in the README).
+     */
+    async runDiagCommand() {
+        const snapshot = await collectDiag({
+            sessionId: String(this.agent.id),
+            pluginVersion: PLUGIN_VERSION,
+            hostVersion: hostDshVersion(),
+            hostProcess: isTuiHostProcess(),
+            link: {
+                kind: this.paintLink === 'ssh' ? 'ssh' : 'local',
+                ...(this.paintRttMs === undefined ? {} : { rttMs: this.paintRttMs }),
+                probeState: this.paintProbed ? 'measured' : this.paintLink === 'ssh' ? 'unknown' : 'unprobed',
+            },
+            ...(this.paintIntervalMs === undefined ? {} : { paintIntervalMs: this.paintIntervalMs }),
+        });
+        this.pushRow({ kind: 'system', text: formatDiag(snapshot).join('\n') });
+        this.markDirty();
+    }
     /** Human-facing exit with goodbye and flush; called from key handling. */
     async requestExit(code) {
         if (this.hangingUp)
@@ -1199,6 +1279,12 @@ export class SshTui {
         const keepHost = this.displayHost !== undefined && busy;
         if (keepHost) {
             this.hangingUp = false;
+            // A relay that arrived while this hangup was unwinding set
+            // `reattachedDuringHangup` so the hangup would honor it. That relay
+            // *cancels* this hangup when it HELLOs, so reaching this keep-host path
+            // means the flag is already cleared above; clearing it here too would be
+            // dead code, and the status handler clears it on the next turn.
+            this.hostKeptAlive = true;
             this.armDetachedIdleTimer();
             await this.onHangup?.();
             return;
@@ -1366,7 +1452,11 @@ export class SshTui {
             this.reattachedDuringHangup = true;
         this.displayDetached = false;
         this.hangingUp = false;
+        this.hostKeptAlive = false;
         this.clearDetachedIdleTimer();
+        // The user is back: the leftover Host is a live session again, so the
+        // idle exit must not fire out from under the display that just attached.
+        this.clearIdleExitTimer();
         this.lastActivity = Date.now();
         this.stalledWarningShown = false;
         this.lastPaintRows = [];
@@ -1416,52 +1506,27 @@ export class SshTui {
         return parts.join(' · ');
     }
     mergeIntoToolCard(previous, next) {
-        const ids = previous.mergedCallIds ?? [previous.callId];
-        if (!ids.includes(previous.callId))
-            ids.push(previous.callId);
-        if (!ids.includes(next.callId))
-            ids.push(next.callId);
-        previous.mergedCallIds = ids;
-        previous.callId = next.callId;
-        previous.name = next.name;
-        previous.args = next.args;
-        if (next.title !== '')
-            previous.title = next.title;
-        if (next.summary !== '')
-            previous.summary = next.summary;
-        if (next.diff !== undefined && next.diff.length > 0) {
-            previous.diff = (previous.repeats ?? 1) > 1 && previous.diff !== undefined && previous.diff.length > 0
-                ? [...previous.diff, ...next.diff]
-                : next.diff;
-        }
-        previous.status = 'running';
-        previous.output = '';
-        previous.exitCode = undefined;
-        previous.signal = undefined;
-        previous.repeats = (previous.repeats ?? 1) + 1;
-        if (!this.replaying)
-            previous.flipUntil = Date.now() + TOOL_FLIP_MS;
+        mergeToolCard(previous, next, Date.now(), this.replaying);
     }
     findToolRowByCallId(callId) {
-        return this.rows.findLast((candidate) => candidate.kind === 'tool'
-            && (candidate.callId === callId || candidate.mergedCallIds?.includes(callId) === true));
+        return findToolRowByCallId(this.rows, callId);
     }
     findMergeableToolRow(next) {
-        const previous = this.rows.findLast((candidate) => candidate.kind === 'tool');
-        return canMergeToolCall(previous, next) ? previous : undefined;
+        return findMergeableToolRow(this.rows, next);
     }
     /** Append one transcript row, bounding memory on long sessions. */
     pushRow(row) {
         this.rows.push(row);
-        if (this.rows.length > MAX_TRANSCRIPT_ROWS) {
-            const removed = this.rows.length - MAX_TRANSCRIPT_ROWS;
-            if (this.focusedRow !== null
-                && this.focusedRow.kind !== 'streaming-reasoning'
-                && this.rows.indexOf(this.focusedRow) < removed) {
-                this.focusedRow = null;
-            }
-            this.rows.splice(0, removed);
-        }
+        // Locate the focused card before trimming: after the splice every surviving
+        // index shifts down and a stale index would clear the focus by accident.
+        const focusedIndex = this.focusedRow === null || this.focusedRow.kind === 'streaming-reasoning'
+            ? undefined
+            : this.rows.indexOf(this.focusedRow);
+        const removed = boundTranscriptRows(this.rows);
+        if (removed === 0)
+            return;
+        if (focusedIndex !== undefined && focusedIndex < removed)
+            this.focusedRow = null;
     }
     /** The transcript rows that support per-row expand/collapse. */
     collapsibleRows() {
@@ -1533,29 +1598,15 @@ export class SshTui {
             ...(this.streaming?.reasoning ? { reasoning: this.streaming.reasoning } : {}),
         };
     }
-    planShouldDefaultExpand(plan) {
-        return plan.active === true
-            || plan.pending === true
-            || plan.todos.some(item => item.status === 'in_progress');
-    }
     findSubagentRow(sessionId) {
         return this.rows.findLast((row) => row.kind === 'subagent' && row.sessionId === sessionId);
     }
     findLivePlanRow() {
-        return this.rows.findLast((row) => row.kind === 'plan' && planIsLive(row));
+        return findLivePlanRow(this.rows);
     }
     /** Older / finished plans stay in the scrolling transcript. */
     archiveStalePlans(keep) {
-        for (const row of this.rows) {
-            if (row.kind !== 'plan' || row === keep)
-                continue;
-            if (row.archived === true)
-                continue;
-            row.archived = true;
-            row.active = false;
-            row.pending = false;
-            row.expanded = false;
-        }
+        archiveStalePlans(this.rows, keep);
     }
     upsertPlanRow(patch) {
         const existing = this.findLivePlanRow();
@@ -1573,7 +1624,7 @@ export class SshTui {
                 existing.archived = true;
                 existing.expanded = false;
             }
-            else if (patch.expanded === undefined && this.planShouldDefaultExpand(existing)) {
+            else if (patch.expanded === undefined && planShouldDefaultExpand(existing)) {
                 existing.expanded = true;
             }
             this.archiveStalePlans(planIsLive(existing) ? existing : undefined);
@@ -1585,19 +1636,16 @@ export class SshTui {
             existing.pending = false;
             existing.expanded = false;
         }
+        const active = patch.active ?? false;
+        const pending = patch.pending ?? false;
+        const todos = patch.todos ?? [];
         const row = {
             kind: 'plan',
-            active: patch.active ?? false,
-            pending: patch.pending ?? false,
-            todos: patch.todos ?? [],
+            active,
+            pending,
+            todos,
             ...(patch.planMarkdown === undefined ? {} : { planMarkdown: patch.planMarkdown }),
-            expanded: this.planShouldDefaultExpand({
-                kind: 'plan',
-                active: patch.active ?? false,
-                pending: patch.pending ?? false,
-                todos: patch.todos ?? [],
-                expanded: false,
-            }),
+            expanded: planShouldDefaultExpand({ active, pending, todos }),
             archived: false,
         };
         this.pushRow(row);
@@ -2538,29 +2586,18 @@ export class SshTui {
         const inputDivider = this.styleLine('system', repeatToWidth('─', width));
         const reserved = RESERVED_BOTTOM_LINES + (inputRows - 1) + headerLines.length + suggestionLines.length + planDockLines.length + 1;
         const available = Math.max(0, height - reserved - dialogLines.length);
-        const maxOffset = Math.max(0, display.length - available);
-        const reveal = this.pendingReveal;
-        if (reveal !== undefined) {
-            this.pendingReveal = undefined;
-            const first = displayRefs.findIndex(ref => ref === reveal);
-            if (first !== -1) {
-                let last = first;
-                while (last + 1 < displayRefs.length && displayRefs[last + 1] === reveal)
-                    last += 1;
-                const span = last - first + 1;
-                this.scrollOffset = Math.max(0, display.length - available - first);
-            }
-        }
-        if (this.scrollOffset > maxOffset)
-            this.scrollOffset = maxOffset;
-        const start = Math.max(0, display.length - available - this.scrollOffset);
-        const visible = display.slice(start, start + available);
-        const visibleRefs = displayRefs.slice(start, start + available);
-        const padding = Math.max(0, available - visible.length);
-        for (let index = 0; index < padding; index++) {
-            visible.unshift('');
-            visibleRefs.unshift(undefined);
-        }
+        const window = windowTranscript({
+            lines: display,
+            refs: displayRefs,
+            available,
+            scrollOffset: this.scrollOffset,
+            reveal: this.pendingReveal,
+        });
+        this.pendingReveal = undefined;
+        this.scrollOffset = window.scrollOffset;
+        const start = window.start;
+        const visible = window.visibleLines;
+        const visibleRefs = window.visibleRefs;
         this.clickableRows.clear();
         this.paintedLinkHitsByRow.clear();
         for (let index = 0; index < visibleRefs.length; index++) {
@@ -2578,20 +2615,7 @@ export class SshTui {
             this.clickableRows.set(dockTop, dockPlan);
         }
         const linkChip = formatLinkQualityChip(this.paintLink, this.paintIntervalMs, this.paintRttMs, this.paintProbed, this.color);
-        const statsGroups = footerStatsGroups({
-            turns: this.stats.turns,
-            steps: this.stats.steps,
-            llmMs: this.stats.llmMs,
-            toolMs: this.stats.toolMs,
-            ttftMs: this.stats.ttftMs,
-            ttftSteps: this.stats.ttftSteps,
-            decodeMs: this.stats.decodeMs,
-            decodeTokens: this.stats.decodeTokens,
-            inputTokens: this.stats.usage.inputTokens,
-            outputTokens: this.stats.usage.outputTokens,
-            cacheReadTokens: this.stats.usage.cacheReadTokens,
-            cacheWriteTokens: this.stats.usage.cacheWriteTokens,
-        });
+        const statsGroups = footerStatsGroups(statsRowOf(this.statsTracker.snapshot()));
         const statsPlain = fitFooterStatsLine(formatLinkQualityChip(this.paintLink, this.paintIntervalMs, this.paintRttMs, this.paintProbed, false), statsGroups, Math.max(1, width));
         const chipVisible = formatLinkQualityChip(this.paintLink, this.paintIntervalMs, this.paintRttMs, this.paintProbed, false);
         const statsLine = statsPlain.startsWith(chipVisible)
@@ -2742,19 +2766,15 @@ export class SshTui {
         this.markDirty();
     }
     buildSuggestions() {
-        const input = this.input;
-        if (!input.startsWith('/'))
+        // Called on every paint: leave the host command service alone unless the
+        // line is actually a slash command.
+        if (!this.input.startsWith('/'))
             return [];
-        const prefix = input.slice(1).toLowerCase();
-        const local = localizedCommands()
-            .filter(command => command.name !== 'dialog-test' && (prefix !== '' || command.aliasOf === undefined))
-            .map(command => ({ name: command.name, description: command.description, local: true }));
-        const seen = new Set(local.map(command => command.name));
-        const dsh = (this.ctx.get('commands')?.list(this.agent) ?? [])
-            .filter(command => !seen.has(command.name))
+        // The host's commands arrive last (a local name wins the duplicate) and are
+        // localized here, where the i18n catalog is already loaded.
+        const foreign = (this.ctx.get('commands')?.list(this.agent) ?? [])
             .map(command => {
-            const descKey = `cmd.${command.name}`;
-            const desc = t(descKey, undefined, command.description);
+            const desc = t(`cmd.${command.name}`, undefined, command.description);
             return {
                 name: command.name,
                 description: commandAcceptsAttachments(command.input)
@@ -2763,17 +2783,7 @@ export class SshTui {
                 local: false,
             };
         });
-        const all = [...local, ...dsh];
-        const filtered = prefix === ''
-            ? all
-            : all.filter(command => command.name.startsWith(prefix) || command.name.includes(prefix));
-        if (prefix === '')
-            return filtered;
-        return filtered.sort((a, b) => {
-            const aStart = a.name.startsWith(prefix) ? 0 : 1;
-            const bStart = b.name.startsWith(prefix) ? 0 : 1;
-            return aStart - bStart;
-        });
+        return commandSuggestions(this.input, foreign);
     }
     suggestionsVisible() {
         return this.commandSuggestions.length > 0 && this.dialog === undefined;
@@ -2789,41 +2799,9 @@ export class SshTui {
         const kind = describeProviderRoute(provider).short;
         return `${provider}/${model}${effort === undefined ? '' : ` (${effort})`} · ${kind}`;
     }
-    /** Replace one step's usage sample so a repeated report never double counts. */
-    recordUsage(turn, step, usage) {
-        const key = `${turn}:${step}`;
-        const next = {
-            inputTokens: usage.inputTokens,
-            outputTokens: usage.outputTokens,
-            cacheReadTokens: usage.cacheReadTokens ?? 0,
-            cacheWriteTokens: usage.cacheWriteTokens ?? 0,
-        };
-        const previous = this.usageByStep.get(key);
-        const totals = this.stats.usage;
-        this.stats.usage = {
-            inputTokens: totals.inputTokens - (previous?.inputTokens ?? 0) + next.inputTokens,
-            outputTokens: totals.outputTokens - (previous?.outputTokens ?? 0) + next.outputTokens,
-            cacheReadTokens: totals.cacheReadTokens - (previous?.cacheReadTokens ?? 0) + next.cacheReadTokens,
-            cacheWriteTokens: totals.cacheWriteTokens - (previous?.cacheWriteTokens ?? 0) + next.cacheWriteTokens,
-        };
-        this.usageByStep.set(key, next);
-    }
     /** Compact session stats groups for the first footer row. */
     statsText() {
-        return footerStatsGroups({
-            turns: this.stats.turns,
-            steps: this.stats.steps,
-            llmMs: this.stats.llmMs,
-            toolMs: this.stats.toolMs,
-            ttftMs: this.stats.ttftMs,
-            ttftSteps: this.stats.ttftSteps,
-            decodeMs: this.stats.decodeMs,
-            decodeTokens: this.stats.decodeTokens,
-            inputTokens: this.stats.usage.inputTokens,
-            outputTokens: this.stats.usage.outputTokens,
-            cacheReadTokens: this.stats.usage.cacheReadTokens,
-            cacheWriteTokens: this.stats.usage.cacheWriteTokens,
-        }).join(' │ ');
+        return footerStatsGroups(statsRowOf(this.statsTracker.snapshot())).join(' │ ');
     }
     /** Refresh the terminal window title (throttled while running). */
     updateTerminalTitle() {
@@ -2924,15 +2902,11 @@ export class SshTui {
      */
     applyStreamChunk(streamed, statsOnly = false) {
         const { chunk } = streamed;
-        const open = this.openStepStats;
-        if (open !== null && open !== undefined
-            && open.turn === streamed.turn && open.step === streamed.step) {
-            if (open.firstTokenTime === null && isTokenDeltaChunk(chunk)) {
-                this.openStepStats = { ...open, firstTokenTime: streamed.time };
-            }
+        if (isTokenDeltaChunk(chunk)) {
+            this.statsTracker.noteFirstToken(streamed.turn, streamed.step, streamed.time);
         }
         if (chunk.type === 'usage' && chunk.usage !== undefined && streamed.stepKnown) {
-            this.recordUsage(streamed.turn, streamed.step, chunk.usage);
+            this.statsTracker.recordUsage(streamed.turn, streamed.step, chunk.usage);
         }
         if (statsOnly)
             return;
@@ -2982,7 +2956,7 @@ export class SshTui {
         const current = this.liveStreamOwner;
         const fallback = current !== undefined && (attemptId === undefined || attemptId === current.attemptId)
             ? current
-            : this.openStepStats;
+            : this.statsTracker.currentStep();
         const streamed = streamChunkOf(payload.frame, fallback);
         if (streamed !== undefined)
             this.applyStreamChunk(streamed);
@@ -3093,29 +3067,19 @@ export class SshTui {
                     .filter(block => block.type === 'reasoning')
                     .map(block => block.text)
                     .join('');
-                const open = this.openStepStats;
-                if (open !== undefined && open.turn === event.data.turn && open.step === event.data.step) {
-                    this.stats.llmMs += Math.max(0, event.time - open.startTime);
-                    // The settlement's own packed stream is authoritative: a retried
-                    // step keeps the failed attempt's first token in the live latch, and
-                    // spanning both attempts reported a rate ~20x off. 0.1.2 has no
-                    // `stream` and still relies on the replayed `assistant/chunk` events
-                    // (or the live latch) instead.
-                    const firstTokenTime = streamFirstTokenTime(event.data.stream)
-                        ?? open.firstTokenTime;
-                    if (firstTokenTime !== null && firstTokenTime !== undefined && Number.isFinite(firstTokenTime)) {
-                        this.stats.ttftMs += Math.max(0, firstTokenTime - open.startTime);
-                        this.stats.ttftSteps += 1;
-                        const outputTokens = event.data.usage?.outputTokens;
-                        if (typeof outputTokens === 'number' && Number.isFinite(outputTokens) && outputTokens >= 0) {
-                            this.stats.decodeMs += Math.max(0, event.time - firstTokenTime);
-                            this.stats.decodeTokens += outputTokens;
-                        }
-                    }
-                    this.openStepStats = undefined;
-                }
+                // The settlement's own packed stream is authoritative: a retried step
+                // keeps the failed attempt's first token in the live latch, and spanning
+                // both attempts reported a rate ~20x off. 0.1.2 has no `stream` and still
+                // relies on the replayed `assistant/chunk` events (or the live latch).
+                this.statsTracker.settleMessage({
+                    turn: event.data.turn,
+                    step: event.data.step,
+                    time: event.time,
+                    firstTokenTime: streamFirstTokenTime(event.data.stream),
+                    outputTokens: event.data.usage?.outputTokens,
+                });
                 if (event.data.usage !== undefined) {
-                    this.recordUsage(event.data.turn, event.data.step, event.data.usage);
+                    this.statsTracker.recordUsage(event.data.turn, event.data.step, event.data.usage);
                 }
                 const reasoningExpanded = this.streamingReasoning?.expanded ?? false;
                 const interrupted = event.data.interrupted === true;
@@ -3138,7 +3102,7 @@ export class SshTui {
             case 'tool/call': {
                 this.openToolCalls.set(String(event.data.callId), event.data.name);
                 this.toolCallNames.set(String(event.data.callId), event.data.name);
-                this.pendingToolTimes.set(String(event.data.callId), event.time);
+                this.statsTracker.noteToolStart(String(event.data.callId), event.time);
                 if (!HIDDEN_TOOL_NAMES.has(event.data.name)) {
                     const present = presentToolCall(event.data.name, event.data.arguments);
                     const previous = this.findMergeableToolRow({ name: event.data.name, args: event.data.arguments });
@@ -3181,11 +3145,7 @@ export class SshTui {
             }
             case 'tool/result': {
                 this.openToolCalls.delete(String(event.data.message.source.callId));
-                const dispatchedAt = this.pendingToolTimes.get(String(event.data.message.source.callId));
-                if (dispatchedAt !== undefined) {
-                    this.stats.toolMs += Math.max(0, event.time - dispatchedAt);
-                    this.pendingToolTimes.delete(String(event.data.message.source.callId));
-                }
+                this.statsTracker.noteToolEnd(String(event.data.message.source.callId), event.time);
                 const callId = String(event.data.message.source.callId);
                 const row = this.findToolRowByCallId(callId);
                 const output = collectText(event.data.message.content);
@@ -3245,25 +3205,12 @@ export class SshTui {
                 break;
             }
             case 'step/start': {
-                this.openStepStats = {
-                    turn: event.data.turn,
-                    step: event.data.step,
-                    startTime: event.time,
-                    firstTokenTime: null,
-                };
+                this.statsTracker.noteStepStart(event.data.turn, event.data.step, event.time);
                 this.markDirty();
                 break;
             }
             case 'step/end': {
-                if (this.lastStatsTurn !== event.data.turn) {
-                    this.stats.turns += 1;
-                    this.lastStatsTurn = event.data.turn;
-                }
-                this.stats.steps += 1;
-                this.openStepStats = undefined;
-                // Usage accounting is complete for this step; the map only exists to
-                // deduplicate repeated usage reports during the step.
-                this.usageByStep.delete(`${event.data.turn}:${event.data.step}`);
+                this.statsTracker.noteStepEnd(event.data.turn, event.data.step);
                 if (!this.replaying) {
                     this.quotaStepsSinceRefresh += 1;
                     const every = quotaRefreshEverySteps(this.quotaSnapshot === undefined
@@ -3295,7 +3242,7 @@ export class SshTui {
                 const reason = event.data.reason;
                 this.openToolCalls.clear();
                 this.toolCallNames.clear();
-                this.pendingToolTimes.clear();
+                this.statsTracker.noteTurnEnd();
                 this.stalledWarningShown = false;
                 this.pendingMessages.clear();
                 // Aborted/errored turns may close without an assembled
@@ -3344,6 +3291,9 @@ export class SshTui {
             return;
         this.lastActivity = Date.now();
         if (status === 'running') {
+            // Work is running again, so any reattach that raced a former hangup has
+            // long been honored; keeping the flag would swallow the next drop.
+            this.reattachedDuringHangup = false;
             this.completionSignaled = false;
             this.completedAt = 0;
             if (this.waitStartedAt === undefined)
@@ -3362,6 +3312,14 @@ export class SshTui {
         if (status !== 'running') {
             this.flushPlanCloseNudge();
             this.maybeIdleAutoCompact();
+            // A leftover Host exists only because this turn was still running when
+            // SSH dropped. Now that it settled, give the user a short window to
+            // reattach before exiting and freeing the session's write lock for the
+            // browser surface.
+            this.armIdleExitTimer();
+        }
+        else {
+            this.clearIdleExitTimer();
         }
         this.markDirty();
     };
@@ -5605,7 +5563,12 @@ export class SshTui {
     }
     // ── keyboard ────────────────────────────────────────────────────────────
     handleData = (chunk) => {
-        const text = this.decoder.write(chunk);
+        const decoded = this.decoder.write(chunk);
+        if (decoded === '')
+            return;
+        this.inputGuard.push(decoded);
+    };
+    handleInputText(text) {
         const combined = this.escapeBuffer + text;
         this.escapeBuffer = '';
         if (this.escapeTimer !== undefined) {
@@ -5796,7 +5759,7 @@ export class SshTui {
             return;
         }
         this.handlePlainText(combined);
-    };
+    }
     /** Handle one data chunk that may contain bracketed-paste markers. */
     processPasteChunk(combined) {
         let index = 0;
@@ -5982,14 +5945,8 @@ export class SshTui {
         const dialog = this.dialog;
         if (dialog === undefined || dialog.kind !== 'questions')
             return false;
-        const count = dialog.question.options?.length ?? 0;
-        if (count === 0)
+        if (!moveQuestionCursor(dialog, delta))
             return false;
-        dialog.cursor = Math.max(0, Math.min(count - 1, dialog.cursor + delta));
-        if (dialog.question.multiSelect !== true) {
-            dialog.selected.clear();
-            dialog.selected.add(dialog.cursor);
-        }
         this.markDirty();
         return true;
     }
@@ -5998,9 +5955,8 @@ export class SshTui {
         if (dialog === undefined)
             return;
         if (dialog.kind === 'inspect') {
-            if (text === '\x1b' || text === '\x03' || text === 'q' || text === 'Q' || text === '\r' || text === '\n') {
+            if (inspectClosesOn(text))
                 this.closeInspect();
-            }
             return;
         }
         if (dialog.kind === 'onboarding') {
@@ -6008,45 +5964,28 @@ export class SshTui {
             return;
         }
         if (dialog.kind === 'confirm') {
-            if (text === 'y' || text === 'Y')
-                this.closeConfirm('y');
-            else if (text === 'n' || text === 'N')
-                this.closeConfirm('n');
-            else if (text === '\x03' || text === '\x1b')
-                this.closeConfirm('cancel');
+            const answer = confirmAnswer(text);
+            if (answer !== undefined)
+                this.closeConfirm(answer);
             return;
         }
-        const key = text.toLowerCase();
-        const index = QUESTION_OPTION_KEYS.indexOf(key);
-        if (index >= 0 && index < (dialog.question.options?.length ?? 0)) {
-            dialog.cursor = index;
-            if (dialog.question.multiSelect === true) {
-                if (dialog.selected.has(index))
-                    dialog.selected.delete(index);
-                else
-                    dialog.selected.add(index);
-            }
-            else {
-                dialog.selected.clear();
-                dialog.selected.add(index);
-            }
+        if (selectQuestionOptionByKey(dialog, text))
             this.markDirty();
-        }
         if (text === '\r' || text === '\n') {
-            const options = dialog.question.options ?? [];
-            const selected = [...dialog.selected].map(index => options[index]?.label).filter((label) => label !== undefined);
-            if (selected.length === 0 && options.length > 0 && dialog.question.multiSelect !== true) {
+            const submit = questionSubmit(dialog, this.input);
+            if (submit.kind === 'reject') {
                 // no selection: treat as cancel unless there are no options
                 dialog.reject(new UserQuestionError('ask_user_question was cancelled', 'ASK_ABORTED'));
                 return;
             }
-            if (options.length === 0) {
-                dialog.resolve({ selected: [], custom: this.input });
-                this.input = '';
-                this.cursor = 0;
+            if (submit.kind === 'resolve') {
+                dialog.resolve({ selected: submit.selected, ...(submit.custom === undefined ? {} : { custom: submit.custom }) });
+                if (submit.custom !== undefined) {
+                    this.input = '';
+                    this.cursor = 0;
+                }
                 return;
             }
-            dialog.resolve({ selected });
             return;
         }
         if (text === '\x1b' || text === '\x03') {
@@ -6915,6 +6854,12 @@ export class SshTui {
                     this.pushRow({ kind: 'system', text: lines.join('\n') });
                 }
                 break;
+            case 'diag':
+                void this.runDiagCommand().catch((error) => {
+                    this.pushRow({ kind: 'error', text: t('cmd.failedNamed', { command, error: errorChain(error) }) });
+                    this.markDirty();
+                });
+                break;
             case 'usage':
             case 'balance':
             case 'quota':
@@ -7194,10 +7139,6 @@ export class SshTui {
         }
     }
 }
-function optionsLength(dialog) {
-    return dialog.kind === 'questions' ? dialog.question.options?.length ?? 0 : 0;
-}
-/** Escape a string for safe interpolation into a RegExp source. */
 function escapeRegex(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
 }