dsh-ssh-tui 0.6.4 → 0.7.0-rc.2

package/lib/tui.js

@@ -22,6 +22,7 @@ import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { createRequire } from 'node:module';
 import { StringDecoder } from 'node:string_decoder';
+import { METADATA_FILE, readPresetMetadata } from '@deepseek-ai/dsh-agent-presets';
 import { credentialRef } from '@deepseek-ai/dsh-credentials';
 import { createUserMessage, errorChain, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { SessionId } from '@deepseek-ai/dsh-session';
@@ -32,10 +33,17 @@ import { loadProviderCatalog, mergeProviderEntries } from './provider-catalog.js
 import { catalogContextWindow, catalogWindowIndex, suggestedRouteContextWindow, } from './context-window.js';
 import { formatFooterCwd } from './session-list.js';
 import { collectDiag, formatDiag } from './diag.js';
+import { ApprovalVerdictCache, cacheableShape, verdictKey } from './approval-cache.js';
+import { collectDoctor, doctorChecks, formatDoctorReport, rowsToRepair } from './doctor.js';
+import { colorDepth, downgradeSgr } from './color-depth.js';
+import { appendRow, lineModeEnabled, lineModeLines } from './line-mode.js';
+import { keymapReport, resolveKeymap } from './keymap.js';
 import { presetLabel, profileFromArgv } from './preset-label.js';
-import { ensureRosterRows, rosterPatchPath } from './preset-rows.js';
+import { flattenGroups, groupPresets, optionMatches } from './preset-picker.js';
+import { isRefusal, planCopy, planDelete, planMetadata, presetDirectory, } from './preset-authoring.js';
+import { ensureRosterRows, planDuplicateRepair, planRosterRepair, rosterPatchPath, writePatchWithBackup, ROSTER_ROWS, } from './preset-rows.js';
 import { SessionStatsTracker, statsRowOf } from './stats.js';
-import { QUESTION_OPTION_KEYS, confirmAnswer, inspectClosesOn, moveQuestionCursor, optionsLength, questionSubmit, selectQuestionOptionByKey, } from './dialogs.js';
+import { QUESTION_OPTION_KEYS, applyQuestionFilter, backspaceQuestionFilter, clearQuestionFilter, typeQuestionFilter, visibleQuestionIndexes, 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';
@@ -46,15 +54,16 @@ import { ROUTE_MEMORY_NAMESPACE, parseRouteMemory, rememberedRouteFor, upsertRem
 import { AGENT_DEFAULT_MODEL_SETTINGS_NAMESPACE } from '@deepseek-ai/dsh-agent-default-model';
 import { DEFAULT_SUBAGENT_MODEL, SUBAGENT_SETTINGS_NAMESPACE, defaultSubagentModelForProvider, subagentModelMatchesProvider, subagentSettingsValue, } from './subagent-model.js';
 import { resolveFreshSuperGrokToken } from './supergrok-token.js';
-import { copyTextFromTranscript } from './copy-text.js';
+import { copyTextFromRow, 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 { clipAnsiToWidth, hrefAtColumn, osc52Clipboard, paintedLinkHits, cursorVisualPosition, displayWidth, foldInputView, fmtElapsedCompact, highlightAnsiNeedle, searchContains, lastCodePoints, padToWidth, sliceCodePoints, paintSegmentedLine, renderMarkdownLines, repeatToWidth, sanitizeTerminalText, shimmerText, stripAnsi, truncate, truncateToWidth, waitCardCopy, wrap, wrapSegmented, wrapWaitDetails, } from './term-text.js';
+import { clampSelection, offsetAfterColumn, offsetAtColumn, selectionSpans, selectionText, } from './selection.js';
+import { captureHangupSignals, advancePaintedRows, composePaintFrame, composePaintOutput, frameByteBudget, detectSshSession, formatLinkQualityChip, HANGUP_CANCEL_TIMEOUT_MS, ignoreFurtherHangupSignals, isEscapePrefix, isHangupErrno, linkQualityOf, parseCursorPositionReply, PICKER_WINDOW, pickerWindowStart, probeTerminalRttMs, releaseHangupSignals, resolvePaintIntervalMs, toolBodyLineLimit, 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 { contextPressureAlertText, contextPressureRingColor, contextPressureView, formatContextPressureRing, describeProviderRoute, fitFooterChips, fitFooterStatusLine, footerActivity, footerHealthChip, footerIdentityParts, footerStatsGroups, formatContextPressureChip, formatStatusReport, formatTokens, parseContextPressure, promptPressureTokens, providerUsesLocalOAuth, shouldIdleAutoCompact, } from './footer.js';
 import { COMMAND_CODE_CREDITS_URL, COMMAND_CODE_SUBSCRIPTIONS_URL, COMMAND_CODE_USAGE_URL, commandCodePeriodStart, commandCodeSourceFor, crossedQuotaThresholds, DEEPSEEK_PUBLIC_BASE_URL, formatAccountBalance, formatFooterBalance, formatQuotaSnapshot, joinUrl, OPENAI_COMPAT_BALANCE_PATHS, OPENCODE_GO_USAGE_URL, OPENCODE_ZEN_BASE_URL, openCodeApiErrorMessage, openCodeSourceFor, parseCommandCodeQuota, 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, 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';
+import { buildToolHeader, compactEditPath, compactFailureLines, compactFileStats, 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';
@@ -151,6 +160,38 @@ function onboardTemplate(state) {
     }
     return providerTemplates()[state.providerType];
 }
+/**
+ * A short duration in the shortest useful unit: `12s` / `3m` / `1h`.
+ * Locale-neutral on purpose — it reads the same in both catalogs.
+ */
+/**
+ * The `keys` section of this plugin's settings, if the deployment has one.
+ *
+ * Read once at construction: a keymap that changed under a running session would
+ * move a key mid-use, which is worse than asking for a restart.
+ */
+function readConfiguredKeys(ctx) {
+    const settings = ctx.get('settings');
+    const section = settings?.get?.(settingsNamespace('ssh-tui'));
+    if (section === null || typeof section !== 'object' || Array.isArray(section))
+        return {};
+    const keys = section.keys;
+    if (keys === null || typeof keys !== 'object' || Array.isArray(keys))
+        return {};
+    const out = {};
+    for (const [action, value] of Object.entries(keys)) {
+        if (typeof value === 'string')
+            out[action] = value;
+    }
+    return out;
+}
+function formatShortDuration(ageMs) {
+    const seconds = Math.max(0, Math.round(ageMs / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.round(seconds / 60);
+    return minutes < 60 ? `${minutes}m` : `${Math.round(minutes / 60)}h`;
+}
 const PLUGIN_VERSION = (() => {
     try {
         const require = createRequire(import.meta.url);
@@ -161,7 +202,11 @@ const PLUGIN_VERSION = (() => {
         return '0.0.0';
     }
 })();
+/** Files named on a collapsed compact burst before the rest are counted. */
+const MAX_COMPACT_FILE_STATS = 4;
 const STALL_WARNING_MS = 60000;
+/** Bytes already queued for the terminal before a frame is skipped instead. */
+const STDOUT_BACKLOG_BYTES = 32 * 1024;
 const DEFAULT_DETACHED_IDLE_MS = 6 * 60 * 60 * 1000;
 /**
  * How long a leftover Host that has finished its work waits, with no display,
@@ -437,6 +482,9 @@ export class SshTui {
     autoAllowedCount = 0;
     autoDeniedCount = 0;
     aiReviewCount = 0;
+    cacheHitCount = 0;
+    /** Verdicts this TUI already reviewed, reusable for a bounded time. */
+    approvalCache = new ApprovalVerdictCache();
     /** Host knobs folded from the session log: auto mode needs approval=ask to see requests. */
     hostSandboxMode;
     hostApprovalPolicy;
@@ -527,6 +575,26 @@ export class SshTui {
     reattachedDuringHangup = false;
     scrollOffset = 0;
     clickableRows = new Map();
+    /**
+     * The transcript as painted, for free-form selection. Only the lines that came
+     * from a model reply are copyable: the mouse belongs to the TUI, so dragging
+     * cannot reach the terminal's own selection, and this is what replaces it.
+     */
+    selectableLines = [];
+    /** Screen row (1-based) of the first transcript line in the last frame. */
+    transcriptTopScreenY = 1;
+    /** Where a drag started; the run it belongs to decides what can be selected. */
+    mouseAnchor;
+    /**
+     * What the drag grabbed, so a transcript that scrolls mid-drag cannot slide
+     * the selection onto a different row: the source row and the line's text.
+     */
+    mouseAnchorRef;
+    mouseAnchorText = '';
+    /** The drag being painted in reverse video right now. */
+    mouseSelection;
+    /** A press that has not moved yet: a release without motion is still a click. */
+    pendingMouseClick;
     paintedLinkHitsByRow = new Map();
     copyYank = '';
     /** Last OSC-52 payload (tests; empty when nothing has been copied). */
@@ -566,6 +634,41 @@ export class SshTui {
     cwdChipRow;
     /** Set when a card expand/collapse moves chrome; next paint full-redraws. */
     forceFullPaint = false;
+    /** Highest row the last budgeted frame could not paint, resumed next tick. */
+    paintResume;
+    /** How many times a display has come back after a drop in this Host's life. */
+    displayDrops = 0;
+    /** When the display went away, so the reconnect can say how long it was gone. */
+    detachedAt;
+    /**
+     * Whether the agent-preset roster service is mounted. Read once at boot and
+     * after a repair — never per frame: answering it from the composition would
+     * mean touching the filesystem on every repaint.
+     */
+    rosterMissing = false;
+    /** Screen row of the health chip in the status strip, for click-to-doctor. */
+    healthChipRow;
+    /** How much colour this terminal can take (see `color-depth`). */
+    colorDepth;
+    /** Append events as plain lines instead of painting a framed screen. */
+    lineMode;
+    /** Rebindable actions (see `keymap`); defaults are only replaced on request. */
+    keymap;
+    /**
+     * Lines produced before a display attached.
+     *
+     * The Host boots, pushes its banner, and only then does the launcher's relay
+     * arrive — and a Host's stdout is a discarded pipe, so anything written in
+     * that window is gone. Without this buffer line mode loses the beginning of
+     * the session, which is the one thing a log must not do.
+     */
+    lineModePending = [];
+    /** The counters as they stood when the display went away, for the summary. */
+    awaySnapshot;
+    /** Approvals refused because nobody could confirm them (a subset of denials). */
+    detachedDeniedCount = 0;
+    /** Questions waiting for a display right now — their cards do not exist yet. */
+    queuedQuestions = 0;
     paintIntervalMs;
     paintLink = 'local';
     paintProbed = false;
@@ -584,13 +687,17 @@ export class SshTui {
     searchHits = [];
     searchIndex = -1;
     searchQuery = '';
+    /** The plain text the user searched for, which is what gets highlighted. */
+    searchNeedle = '';
     planNudgePending = false;
     pendingReveal;
     constructor(ctx, agent, config) {
         this.ctx = ctx;
         this.agent = agent;
-        const noColorEnv = process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== '';
-        this.color = config.color !== false && !noColorEnv && process.env.TERM !== 'dumb';
+        // The palette the terminal can take, decided once: a truecolor pair on an
+        // 8-colour terminal is not a cosmetic loss, it is the wrong colour.
+        this.colorDepth = config.color === false ? 'none' : colorDepth(process.env);
+        this.color = this.colorDepth !== 'none';
         this.maxToolOutputLines = Math.max(1, config.maxToolOutputLines ?? 6);
         this.showReasoning = config.showReasoning !== false;
         this.workspaceView = this.readWorkspaceView();
@@ -606,10 +713,16 @@ export class SshTui {
         this.onHangup = config.onHangup;
         this.onReattach = config.onReattach;
         this.headlessDisplay = config.headlessDisplay === true;
+        // Line mode: no frames at all, one appended line per event. The alternate
+        // screen is what makes a screen reader and a `tee` lose events, so it stays
+        // off too.
+        this.lineMode = config.lineMode === true || lineModeEnabled(process.env);
+        this.keymap = resolveKeymap(config.keys ?? readConfiguredKeys(this.ctx));
         this.disconnectPolicy = config.disconnectPolicy ?? this.readDisconnectPolicy();
         this.presetId = config.presetId ?? 'standard';
         this.presetName = presetLabel(this.presetId, config.presetName, config.presetTrust);
-        this.useAlternateScreen = process.env.DSH_TUI_NO_ALT_SCREEN !== '1' && process.env.DSH_TUI_NO_ALT_SCREEN !== 'true';
+        this.useAlternateScreen = !this.lineMode
+            && process.env.DSH_TUI_NO_ALT_SCREEN !== '1' && process.env.DSH_TUI_NO_ALT_SCREEN !== 'true';
         this.paintLink = detectSshSession() ? 'ssh' : 'local';
         this.paintIntervalMs = resolvePaintIntervalMs(config.paintIntervalMs, process.env, {
             ssh: this.paintLink === 'ssh',
@@ -621,7 +734,12 @@ export class SshTui {
         // in-app update, which only runs `dsh plugin add`) boots without one. Say
         // so at boot: the banner's localized default hides the missing service, and
         // the loss is not only `/mode` — the preset-owned tools are absent too.
-        if (this.ctx.get('agentPresets') === undefined) {
+        const keyReport = keymapReport(this.keymap);
+        if (keyReport !== undefined) {
+            this.pushRow({ kind: 'system', text: t('keys.report', { report: keyReport }) });
+        }
+        this.refreshRosterHealth();
+        if (this.rosterMissing) {
             this.pushRow({ kind: 'system', text: t('mode.bootMissing') });
         }
         if (config.cwdNotice !== undefined && config.cwdNotice !== '') {
@@ -655,7 +773,16 @@ export class SshTui {
         process.stdin.prependListener('close', this.handleHangupStream);
         process.stdout.on('error', this.handleIoError);
         process.stdin.on('error', this.handleIoError);
-        this.write(`${this.useAlternateScreen ? '\x1b[?1049h' : ''}\x1b[?1000h\x1b[?1006h\x1b[?2004h\x1b[?25l`);
+        if (this.lineMode) {
+            // Typing still works — commands are how the user drives the session — but
+            // there is no screen to paint and no animation to run.
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.on('data', this.handleData);
+            this.bootBackgroundTasks();
+            return;
+        }
+        this.write(`${this.useAlternateScreen ? '\x1b[?1049h' : ''}\x1b[?1000h\x1b[?1002h\x1b[?1006h\x1b[?2004h\x1b[?25l`);
         this.render();
         this.updateTerminalTitle();
         void this.calibratePaintInterval().finally(() => {
@@ -933,6 +1060,22 @@ export class SshTui {
                 ? this.styleLine('tool', collapsed)
                 : paintSegmentedLine(collapsed, 0, collapsed.length, headerSegments);
             addDisplay(this.focusedRow === anchor && this.color ? `\x1b[7m${styled}\x1b[27m` : styled, anchor);
+            // A collapsed burst is all the reader sees, so the two things that decide
+            // whether to expand belong on it: which files moved, and what failed.
+            if (kind === 'edits') {
+                const stats = compactFileStats(groups.edits);
+                const shown = stats.slice(0, MAX_COMPACT_FILE_STATS);
+                const parts = shown.map(stat => `${stat.path} ${diffStatToken(stat.add, stat.del)}`.trim());
+                if (stats.length > shown.length) {
+                    parts.push(t('compact.filesMore', { count: stats.length - shown.length }));
+                }
+                if (parts.length > 0) {
+                    addDisplay(this.styleLine('tool-result', truncateToWidth(`    ${parts.join(' · ')}`, width)), anchor);
+                }
+            }
+            for (const line of compactFailureLines(items)) {
+                addDisplay(this.styleLine('error', truncateToWidth(`    ${line}`, width)), anchor);
+            }
             return;
         }
         const expandedHeaderLines = headerSegments.length === 0
@@ -949,7 +1092,7 @@ export class SshTui {
                     ? t('compact.lines', { count: countDiffLines(item.diff) || 1 })
                     : token;
                 addDisplay(this.styleLine('tool-result', truncateToWidth(`    ${item.title}  ${extra}`, width)), item);
-                for (const line of toolBodyLines(item, Number.MAX_SAFE_INTEGER)) {
+                for (const line of toolBodyLines(item, Number.MAX_SAFE_INTEGER, width)) {
                     this.paintToolBodyLine(addDisplay, item, line, width);
                 }
                 continue;
@@ -1190,7 +1333,7 @@ export class SshTui {
         try {
             process.stdout.write('\x1b]0;\x07');
             process.stdout.write('\x1b[0m\x1b[2J\x1b[3J\x1b[H');
-            process.stdout.write(`\x1b[?1000l\x1b[?1006l\x1b[?2004l\x1b[?25h${this.useAlternateScreen ? '\x1b[?1049l' : ''}`);
+            process.stdout.write(`\x1b[?1000l\x1b[?1002l\x1b[?1006l\x1b[?2004l\x1b[?25h${this.useAlternateScreen ? '\x1b[?1049l' : ''}`);
         }
         catch (error) {
             if (!isHangupErrno(error)) {
@@ -1265,7 +1408,142 @@ export class SshTui {
             },
             ...(this.paintIntervalMs === undefined ? {} : { paintIntervalMs: this.paintIntervalMs }),
         });
-        this.pushRow({ kind: 'system', text: formatDiag(snapshot).join('\n') });
+        this.pushRow({ kind: 'diag', text: formatDiag(snapshot).join('\n') });
+        this.markDirty();
+    }
+    /**
+     * Whether a host service is registered.
+     *
+     * The typed `ctx.get` knows only the services this plugin depends on;
+     * `/doctor` also probes `codeRuntime`, which the PTC preset mounts and this
+     * plugin deliberately does not depend on, so the lookup is untyped here.
+     */
+    hasHostService(name) {
+        const get = this.ctx.get;
+        return typeof get === 'function' && get.call(this.ctx, name) !== undefined;
+    }
+    /** Routing facts for the doctor's self-consistency check. */
+    doctorRouting() {
+        const settings = this.ctx.get('settings');
+        if (settings === undefined)
+            return undefined;
+        const section = settings.get(settingsNamespace('llm-pi-ai'));
+        const providers = section?.providers ?? {};
+        const provider = this.currentProvider();
+        const models = Array.isArray(providers[provider]?.models) ? providers[provider]?.models ?? [] : [];
+        const model = this.agent.options.model ?? this.selectionRef?.current?.model;
+        const sub = this.subagentSelection.current;
+        return {
+            provider,
+            ...(model === undefined ? {} : { model }),
+            routes: Object.keys(providers),
+            routeModels: models.map(modelEntryId).filter((id) => id !== undefined),
+            ...(sub.provider === undefined ? {} : { subProvider: sub.provider }),
+            ...(sub.model === undefined ? {} : { subModel: sub.model }),
+        };
+    }
+    /** One collected `/doctor` snapshot, from this process's own services. */
+    async collectDoctorFacts(profile) {
+        const routing = this.doctorRouting();
+        return collectDoctor({
+            profile,
+            dshHome: resolveDshHome(),
+            hostVersion: hostDshVersion(),
+            services: {
+                roster: this.ctx.get('agentPresets') !== undefined,
+                codeRuntime: this.hasHostService('codeRuntime'),
+            },
+            anchors: [process.argv[1], this.ctx.baseUrl],
+            ...(routing === undefined ? {} : { routing }),
+        });
+    }
+    /**
+     * `/doctor`: the deployment checkup. `/doctor --fix` then repairs whatever
+     * the report marked fixable, after one confirmation.
+     */
+    async runDoctorCommand(arg, fixRequested) {
+        const profile = profileFromArgv();
+        const facts = await this.collectDoctorFacts(profile);
+        this.pushRow({ kind: 'diag', text: formatDoctorReport(facts, doctorChecks(facts)).join('\n') });
+        this.markDirty();
+        if (!fixRequested)
+            return;
+        await this.repairProfilePatch(rowsToRepair(facts), facts);
+    }
+    /** `/fix <row>`: repair one named roster row of the profile patch. */
+    async runFixCommand(arg) {
+        const name = arg.trim().toLowerCase();
+        const row = ROSTER_ROWS.find(candidate => candidate.id === name || candidate.name.toLowerCase() === name);
+        if (row === undefined) {
+            this.pushRow({
+                kind: 'error',
+                text: t('doctor.fix.unknownRow', { row: arg.trim(), rows: ROSTER_ROWS.map(candidate => candidate.id).join(', ') }),
+            });
+            this.markDirty();
+            return;
+        }
+        await this.repairProfilePatch([row], await this.collectDoctorFacts(profileFromArgv()));
+    }
+    /**
+     * Write the planned repairs into the profile patch after one confirmation.
+     *
+     * Only two things are ever changed: rows that are missing get mounted, and an
+     * insert that repeats an earlier one is removed. An override or disable the
+     * user wrote is never touched, and the previous file is kept as a backup.
+     */
+    async repairProfilePatch(rows, facts) {
+        let text = facts.patch.text;
+        const duplicates = facts.patch.readable ? planDuplicateRepair(text) : undefined;
+        if (duplicates !== undefined)
+            text = duplicates.text;
+        const roster = planRosterRepair(text, rows);
+        if (roster !== undefined)
+            text = roster.text;
+        const added = roster?.added ?? [];
+        const removed = duplicates?.removed ?? [];
+        if (added.length === 0 && removed.length === 0) {
+            this.pushRow({ kind: 'system', text: t('doctor.fix.none') });
+            this.markDirty();
+            return;
+        }
+        const changes = [
+            ...added.map(id => `+${id}`),
+            ...removed.map(entry => `-${entry.id} (line ${entry.line})`),
+        ].join(' ');
+        const answer = await new Promise(resolve => {
+            this.openConfirm(t('doctor.fix.confirm', { changes }), t('doctor.fix.confirmHint', { path: facts.patchPath }), resolve);
+        });
+        if (answer !== 'y') {
+            this.pushRow({ kind: 'system', text: t('doctor.fix.cancelled') });
+            this.markDirty();
+            return;
+        }
+        try {
+            // A patch that does not exist yet needs no backup: the write creates it
+            // from the template, exactly as the installer would.
+            let backup;
+            if (facts.patch.readable) {
+                backup = await writePatchWithBackup(facts.patchPath, text);
+            }
+            else {
+                await ensureRosterRows(facts.dshHome, facts.profile, rows);
+            }
+            this.pushRow({
+                kind: 'system',
+                text: [
+                    t('doctor.fix.applied', {
+                        added: added.join(', ') || '—',
+                        removed: removed.map(entry => entry.id).join(', ') || '—',
+                        path: facts.patchPath,
+                    }),
+                    ...(backup === undefined ? [] : [t('doctor.fix.backup', { path: backup })]),
+                    t('doctor.fix.restart', { profile: facts.profile }),
+                ].join('\n'),
+            });
+        }
+        catch (error) {
+            this.pushRow({ kind: 'error', text: t('doctor.fix.failed', { error: errorChain(error) }) });
+        }
         this.markDirty();
     }
     /** Human-facing exit with goodbye and flush; called from key handling. */
@@ -1328,6 +1606,14 @@ export class SshTui {
         if (this.hangingUp || this.disposed)
             return;
         this.hangingUp = true;
+        // The one place a real detach starts from, so the reconnect notice can say
+        // how long the user was away. A boot attach never sets it.
+        this.detachedAt ??= Date.now();
+        this.awaySnapshot ??= {
+            allowed: this.autoAllowedCount,
+            denied: this.autoDeniedCount,
+            detached: this.detachedDeniedCount,
+        };
         this.reattachedDuringHangup = false;
         ignoreFurtherHangupSignals();
         this.detachDisplay();
@@ -1520,6 +1806,50 @@ export class SshTui {
         }
         this.displayHost = host;
     }
+    /**
+     * One row for what happened while nobody was watching.
+     *
+     * Only the parts that actually happened are listed, so a plain link blip stays
+     * one line. The counts are deltas against the snapshot taken at the drop: the
+     * totals belong to the session, this belongs to the gap.
+     */
+    pushAwaySummary(awayMs) {
+        const before = this.awaySnapshot;
+        this.awaySnapshot = undefined;
+        if (before === undefined)
+            return;
+        const allowed = this.autoAllowedCount - before.allowed;
+        const denied = this.autoDeniedCount - before.denied;
+        const detached = this.detachedDeniedCount - before.detached;
+        const waiting = this.queuedQuestions;
+        const parts = [];
+        if (allowed + denied > 0) {
+            parts.push(t('attach.awayApprovals', { allowed, denied }));
+        }
+        if (detached > 0)
+            parts.push(t('attach.awayDetached', { count: detached }));
+        if (waiting > 0)
+            parts.push(t('attach.awayWaiting', { count: waiting }));
+        if (parts.length === 0)
+            return;
+        this.pushRow({
+            kind: 'system',
+            text: t('attach.awaySummary', { away: formatShortDuration(awayMs), parts: parts.join(' · ') }),
+        });
+    }
+    /** Say the user was away, and what happened while they were. */
+    pushReconnectNotice() {
+        if (this.detachedAt === undefined)
+            return;
+        this.displayDrops += 1;
+        const away = Date.now() - this.detachedAt;
+        this.detachedAt = undefined;
+        this.pushRow({
+            kind: 'system',
+            text: t('attach.reconnected', { count: this.displayDrops, away: formatShortDuration(away) }),
+        });
+        this.pushAwaySummary(away);
+    }
     /** Re-open DECSET and start painting to an attached Display relay. */
     attachRelayDisplay() {
         // A relay that HELLOs while a hangup is still unwinding must be honored by
@@ -1540,9 +1870,22 @@ export class SshTui {
         this.lastPaintRows = [];
         this.lastChromeKey = '';
         this.lastTranscriptStart = -1;
-        this.write(`${this.useAlternateScreen ? '\x1b[?1049h' : ''}\x1b[?1000h\x1b[?1006h\x1b[?2004h\x1b[?25l`);
+        if (this.lineMode) {
+            // No DECSET at all in line mode: no mouse reporting, no hidden cursor, no
+            // alternate screen. The held lines are the whole point of the handover.
+            this.flushLineMode();
+            // The user is back, and the notice belongs in the log like any event.
+            this.pushReconnectNotice();
+            void this.onReattach?.();
+            return;
+        }
+        this.write(`${this.useAlternateScreen ? '\x1b[?1049h' : ''}\x1b[?1000h\x1b[?1002h\x1b[?1006h\x1b[?2004h\x1b[?25l`);
         this.forceFullPaint = true;
         this.dirty = true;
+        // The user is back: say so, with how many times this Host has been
+        // reconnected and how long this gap lasted. Pushed before the paint so the
+        // frame that follows carries it.
+        this.pushReconnectNotice();
         this.paint();
         this.startRenderTimer();
         void this.onReattach?.();
@@ -1595,6 +1938,14 @@ export class SshTui {
     /** Append one transcript row, bounding memory on long sessions. */
     pushRow(row) {
         this.rows.push(row);
+        if (this.lineMode) {
+            // Appended here rather than from the render timer: a timer can coalesce
+            // two events into one tick, and an event that is coalesced away is an
+            // event the log lost.
+            const appended = appendRow(lineModeLines(row));
+            if (appended !== '')
+                this.writeLineMode(appended);
+        }
         // 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'
@@ -1606,6 +1957,21 @@ export class SshTui {
         if (focusedIndex !== undefined && focusedIndex < removed)
             this.focusedRow = null;
     }
+    /** Append one event, holding it until a display can carry it. */
+    writeLineMode(chunk) {
+        if (this.displayHost?.attached === true && !this.displayDetached) {
+            this.write(chunk);
+            return;
+        }
+        this.lineModePending.push(chunk);
+    }
+    /** Hand the held lines to the display that just attached. */
+    flushLineMode() {
+        if (this.lineModePending.length === 0)
+            return;
+        const pending = this.lineModePending.splice(0);
+        this.write(pending.join(''));
+    }
     /** The transcript rows that support per-row expand/collapse. */
     collapsibleRows() {
         const compact = this.isCompactView();
@@ -1815,15 +2181,78 @@ export class SshTui {
         }
         return lines;
     }
+    /**
+     * One diff line with its changed characters in reverse video.
+     *
+     * The line is split at the spans and each piece is styled on its own. Reverse
+     * is an attribute rather than a colour, so the emphasis survives every palette,
+     * including a monochrome terminal.
+     */
+    styleEmphasisedLine(line, width) {
+        const inner = Math.max(1, width - 2);
+        const spans = [...(line.spans ?? [])].sort((left, right) => left.start - right.start);
+        const pieces = [];
+        let cursor = 0;
+        for (const span of spans) {
+            const from = Math.max(cursor, Math.min(line.text.length, span.start));
+            const to = Math.max(from, Math.min(line.text.length, span.end));
+            if (from > cursor)
+                pieces.push({ text: line.text.slice(cursor, from), emphasis: false });
+            if (to > from)
+                pieces.push({ text: line.text.slice(from, to), emphasis: true });
+            cursor = to;
+        }
+        if (cursor < line.text.length)
+            pieces.push({ text: line.text.slice(cursor), emphasis: false });
+        const flat = pieces.length === 0 ? [{ text: line.text, emphasis: false }] : pieces;
+        const rows = [];
+        let buffer = [];
+        let used = 0;
+        const flush = () => {
+            if (buffer.length === 0)
+                return;
+            const body = buffer
+                .map(piece => (piece.emphasis
+                ? `\x1b[7m${this.styleLine(line.kind, piece.text)}\x1b[27m`
+                : this.styleLine(line.kind, piece.text)))
+                .join('');
+            rows.push(`  ${body}`);
+            buffer = [];
+            used = 0;
+        };
+        for (const piece of flat) {
+            let rest = piece.text;
+            while (rest !== '') {
+                const room = Math.max(1, inner - used);
+                const wrapped = wrap(rest, room)[0] ?? rest;
+                buffer.push({ text: wrapped, emphasis: piece.emphasis });
+                used += displayWidth(wrapped);
+                rest = rest.slice(wrapped.length);
+                if (used >= inner && rest !== '')
+                    flush();
+            }
+        }
+        flush();
+        return rows.length === 0 ? [this.styleLine(line.kind, '')] : rows;
+    }
     paintToolBodyLine(addDisplay, row, line, width) {
         const inner = Math.max(1, width - 2);
         const fillRow = line.kind === 'diff-add' || line.kind === 'diff-del';
+        // An emphasised line is styled in parts: the escapes wrap *styled* pieces,
+        // because the painter's sanitiser strips any escape that reaches it inside
+        // the text — which is how a literal `[7m` once appeared on screen.
+        if (line.spans !== undefined && line.spans.length > 0) {
+            for (const painted of this.styleEmphasisedLine(line, width))
+                addDisplay(painted, row);
+            return;
+        }
         for (const wrapped of wrap(line.text, inner)) {
             const body = fillRow ? padToWidth(`  ${wrapped}`, width) : `  ${wrapped}`;
             const kind = line.kind;
             const style = kind === 'diff-add' || kind === 'diff-del' || kind === 'diff-path'
                 ? this.styleLine(kind, body)
                 : kind === 'todo-done' || kind === 'todo-active' || kind === 'todo-pending'
+                    || kind === 'todo-failed' || kind === 'todo-skipped'
                     ? this.styleLine(kind, body)
                     : kind === 'error'
                         ? this.styleLine('error', body)
@@ -1856,6 +2285,7 @@ export class SshTui {
                 rendered.push(kind === 'diff-add' || kind === 'diff-del' || kind === 'diff-path'
                     ? this.styleLine(kind, body)
                     : kind === 'todo-done' || kind === 'todo-active' || kind === 'todo-pending'
+                        || kind === 'todo-failed' || kind === 'todo-skipped'
                         ? this.styleLine(kind, body)
                         : kind === 'error'
                             ? this.styleLine('error', body)
@@ -2008,10 +2438,42 @@ export class SshTui {
         this.forceFullPaint = true;
         this.markDirty();
     }
-    highlightSearchLine(line) {
-        if (line.includes('\x1b[7m'))
-            return line;
-        return this.color ? `\x1b[7m${line}\x1b[27m` : `» ${line}`;
+    /**
+     * Mark the search hit across the lines that are actually on screen.
+     *
+     * Only the lines that show the match are marked — highlighting the whole card
+     * made a hit look like a selected card, and on a narrow screen the reader
+     * could not tell which word had matched. When the wrap split the needle so no
+     * single line contains it, the row's first line is marked instead: `/find`
+     * reported a hit, so the reader has to see where it is.
+     */
+    highlightSearchLines(visible, refs) {
+        const hit = this.searchHits[this.searchIndex];
+        const needle = this.searchNeedle;
+        if (hit === undefined || needle === '')
+            return [...visible];
+        const hitLines = [];
+        for (let index = 0; index < visible.length; index += 1) {
+            if (refs[index] === hit)
+                hitLines.push(index);
+        }
+        if (hitLines.length === 0)
+            return [...visible];
+        const inlineHit = hitLines.some(index => searchContains(stripAnsi(visible[index] ?? ''), needle));
+        const lines = [...visible];
+        for (const index of hitLines) {
+            const line = lines[index] ?? '';
+            if (line.includes('\x1b[7m'))
+                continue;
+            if (searchContains(stripAnsi(line), needle)) {
+                lines[index] = this.color ? highlightAnsiNeedle(line, needle) : `» ${line}`;
+                continue;
+            }
+            if (!inlineHit && index === hitLines[0]) {
+                lines[index] = this.color ? `\x1b[7m${line}\x1b[27m` : `» ${line}`;
+            }
+        }
+        return lines;
     }
     revealRow(row) {
         if (row === undefined)
@@ -2094,6 +2556,8 @@ export class SshTui {
         const parsed = parseFindQuery(arg);
         const label = parsed.category === undefined ? '' : `${cardCategoryLabel(parsed.category)} `;
         const hits = matchTranscriptRows(this.rows, arg);
+        // The step message says "回复 deploy"; the highlight must look for "deploy".
+        this.searchNeedle = parsed.category === undefined ? arg.trim() : parsed.query;
         this.applySearchHits(`${label}${parsed.query}`.trim(), hits);
     }
     stepSearch(delta) {
@@ -2118,7 +2582,7 @@ export class SshTui {
         this.revealRow(hit);
     }
     paint = () => {
-        if (this.exiting)
+        if (this.exiting || this.lineMode)
             return;
         const width = Math.max(10, this.screenColumns());
         const height = Math.max(6, this.screenRows());
@@ -2130,9 +2594,7 @@ export class SshTui {
         const displayRefs = [];
         const searchHit = this.searchHits[this.searchIndex];
         const addDisplay = (line, ref) => {
-            const clipped = clipAnsiToWidth(line, width);
-            const hit = ref !== undefined && ref === searchHit;
-            display.push(hit ? this.highlightSearchLine(clipped) : clipped);
+            display.push(clipAnsiToWidth(line, width));
             displayRefs.push(ref);
         };
         const pushRow = (kind, text, ref) => {
@@ -2234,9 +2696,17 @@ export class SshTui {
                 for (const wrapped of expandedHeaderLines) {
                     addDisplay(wrapped, row);
                 }
-                for (const line of toolBodyLines(row, Number.MAX_SAFE_INTEGER)) {
+                // On a measured slow link an expanded body is capped and points at the
+                // overlay instead; every other link shows it in full, exactly as it has
+                // since the 0.3.9 card pass.
+                const bodyLimit = toolBodyLineLimit(linkQualityOf(this.paintLink, this.paintRttMs));
+                const body = toolBodyLines(row, Number.MAX_SAFE_INTEGER, width);
+                for (const line of body.slice(0, bodyLimit)) {
                     this.paintToolBodyLine(addDisplay, row, line, width);
                 }
+                if (body.length > bodyLimit) {
+                    addDisplay(this.styleLine('tool-result', truncateToWidth(t('tool.bodyMoreLines', { count: body.length - bodyLimit }), width)), row);
+                }
                 continue;
             }
             if (row.kind === 'subagent') {
@@ -2585,11 +3055,22 @@ export class SshTui {
                 }
                 const options = d.question.options ?? [];
                 const approve = d.question.intent?.approve;
-                const start = pickerWindowStart(d.cursor, options.length);
-                const end = Math.min(options.length, start + PICKER_WINDOW);
+                if (d.filtering === true || (d.filter ?? '') !== '') {
+                    addDialog(`  ${t('dialog.filterLabel', { query: d.filter ?? '' })}`);
+                }
+                // Only the options the filter left are listed. The hotkey stays the
+                // option's own number in the full list, so it does not move under the
+                // user's fingers as the filter narrows.
+                const visibleIndexes = visibleQuestionIndexes(d);
+                const cursorAt = Math.max(0, visibleIndexes.indexOf(d.cursor));
+                const start = pickerWindowStart(cursorAt, visibleIndexes.length);
+                const end = Math.min(visibleIndexes.length, start + PICKER_WINDOW);
                 if (start > 0)
                     addDialog(`  ${t('picker.moreAbove', { count: start })}`);
-                for (let index = start; index < end; index += 1) {
+                for (let at = start; at < end; at += 1) {
+                    const index = visibleIndexes[at];
+                    if (index === undefined)
+                        continue;
                     const option = options[index];
                     if (option === undefined)
                         continue;
@@ -2600,11 +3081,15 @@ export class SshTui {
                     const extra = option.description === undefined ? '' : ` — ${option.description}`;
                     addDialog(` ${focused}${key} ${marker} ${option.label}${recommended}${extra}`);
                 }
-                if (end < options.length)
-                    addDialog(`  ${t('picker.moreBelow', { count: options.length - end })}`);
+                if (end < visibleIndexes.length) {
+                    addDialog(`  ${t('picker.moreBelow', { count: visibleIndexes.length - end })}`);
+                }
                 if (options.length === 0) {
                     addDialog(t('dialog.freeform'));
                 }
+                if (d.filtering === true) {
+                    addDialog(t('dialog.filterHint'));
+                }
                 addDialog(d.question.multiSelect === true ? t('dialog.multiHint') : t('dialog.singleHint'));
             }
         }
@@ -2697,6 +3182,16 @@ export class SshTui {
         const visibleRefs = window.visibleRefs;
         this.clickableRows.clear();
         this.paintedLinkHitsByRow.clear();
+        this.transcriptTopScreenY = headerLines.length + 1;
+        // Kept as painted and stripped only when a drag actually happens: this
+        // runs on every frame, and a mouse event is rare next to a repaint.
+        this.selectableLines = visible.map((line, index) => ({
+            raw: line,
+            ref: visibleRefs[index],
+            // Only a model reply is freely copyable; a tool card, a notice or the
+            // chrome keeps its click behavior instead.
+            copyable: visibleRefs[index]?.kind === 'assistant',
+        }));
         for (let index = 0; index < visibleRefs.length; index++) {
             const ref = visibleRefs[index];
             const screenY = headerLines.length + index + 1;
@@ -2706,6 +3201,10 @@ export class SshTui {
             if (hits.length > 0)
                 this.paintedLinkHitsByRow.set(screenY, hits);
         }
+        const visibleWithSearch = this.highlightSearchLines(visible, visibleRefs);
+        const visibleWithSelection = this.mouseSelection === undefined
+            ? visibleWithSearch
+            : this.highlightSelection(visibleWithSearch);
         const dockPlan = this.findLivePlanRow();
         if (dockPlan !== undefined && planDockLines.length > 0) {
             const dockTop = headerLines.length + visible.length + 1;
@@ -2713,11 +3212,6 @@ export class SshTui {
         }
         const linkChip = formatLinkQualityChip(this.paintLink, this.paintIntervalMs, this.paintRttMs, this.paintProbed, this.color);
         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)
-            ? clipAnsiToWidth(`${linkChip}${this.styleLine('system', statsPlain.slice(chipVisible.length))}`, Math.max(1, width))
-            : this.styleLine('system', statsPlain);
         const idleMs = Date.now() - this.lastActivity;
         const livePlan = this.findLivePlanRow();
         const liveGoal = this.rows.findLast((row) => row.kind === 'goal');
@@ -2754,6 +3248,10 @@ export class SshTui {
             subModel: sub.model,
             ...(sub.provider === undefined ? {} : { subProvider: sub.provider }),
             ...(sub.reasoningEffort === undefined ? {} : { subEffort: String(sub.reasoningEffort) }),
+            // Quota and context pressure stay on the identity line, where they have
+            // always been: B-1 moved them one row up into the strip, and a user
+            // looking at a wide terminal read that as "额度条没了". The strip keeps
+            // the loss order for the groups it does own.
             ...(quotaWindow === undefined || this.quotaSnapshot === undefined || this.quotaSnapshot.provider !== provider
                 ? {}
                 : { quotaCode: this.quotaSnapshot.plan, quotaPercent: quotaWindow.remainingPercent }),
@@ -2778,12 +3276,37 @@ export class SshTui {
                 : activity.text;
         const identity = footerIdentityParts(footer);
         const statusText = fitFooterStatusLine(activityText, identity, Math.max(1, width));
+        // The context ring is the one accent on an otherwise muted line; the mute
+        // has to be resumed after its reset, exactly as the pre-strip footer did.
         const statusLine = this.contextPressure === undefined || !this.color
             ? this.styleLine('system', statusText)
             : this.styleLine('system', statusText).replace(formatContextPressureRing(this.contextPressure.percent), `\x1b[${contextPressureRingColor(this.contextPressure.level)}m${formatContextPressureRing(this.contextPressure.percent)}\x1b[0m\x1b[90m`);
+        // The strip: one loss order for the groups a narrow terminal can do without.
+        // Health leads because it is the only group that reports a broken install;
+        // the session counters go before the operational signals. Quota and context
+        // pressure are deliberately not here — they are on the identity line.
+        const strip = [];
+        const health = footerHealthChip(this.rosterMissing, this.color);
+        // Muted like the identity line, accent excepted: the pre-strip footer
+        // painted the counters dim and only the ⚠'s own glyph yellow.
+        if (health !== undefined)
+            strip.push({ ...health, long: this.muteFooterLine(health.long) });
+        strip.push({
+            id: 'link',
+            // Keeps the default foreground, exactly as it looked before the strip.
+            long: formatLinkQualityChip(this.paintLink, this.paintIntervalMs, this.paintRttMs, this.paintProbed, this.color),
+            short: formatLinkQualityChip(this.paintLink, this.paintIntervalMs, this.paintRttMs, this.paintProbed, false)
+                .replace(/\s*\d+ms$/u, ''),
+            priority: 1,
+        });
+        statsGroups.forEach((text, index) => {
+            strip.push({ id: `stat${index}`, long: this.muteFooterLine(text), short: '', priority: 4 + index });
+        });
+        const statsLine = clipAnsiToWidth(fitFooterChips(strip, Math.max(1, width), this.mutedSeparator()), Math.max(1, width));
+        this.healthChipRow = undefined;
         const paintRows = [
             ...headerLines,
-            ...visible,
+            ...visibleWithSelection,
             ...planDockLines,
             ...dialogLines,
             inputDivider,
@@ -2792,6 +3315,8 @@ export class SshTui {
             `${statsLine}\x1b[0m`,
             `${statusLine}\x1b[0m`,
         ];
+        if (health !== undefined)
+            this.healthChipRow = paintRows.length - 1;
         // Bottom chrome is force-repainted whenever its state changes while the
         // agent is working; this clears any stale cell left behind by a previous
         // frame even when the row strings happen to be identical.
@@ -2800,7 +3325,7 @@ export class SshTui {
             this.status,
             this.agent.status,
             this.scrollOffset,
-            statsPlain,
+            statsLine,
             statusText,
             inputView.text,
             inputView.folded,
@@ -2826,10 +3351,13 @@ export class SshTui {
         this.forceFullPaint = false;
         // One stdout write per frame: dirty rows only, so jump-host SSH sees a
         // single packet instead of one write per line. Clip/pad so leftover
-        // wide glyphs cannot wrap into the input box.
+        // wide glyphs cannot wrap into the input box. The frame is bounded by the
+        // link's byte budget: the tail goes first and rows that do not fit stay
+        // dirty for the next tick (tracked through `paintResume`), so a big repaint
+        // arrives in a few ordered pieces instead of one long freeze.
         const inputTopRow = visible.length + planDockLines.length + dialogLines.length + suggestionLines.length + headerLines.length + 2;
         const row = Math.min(height, inputTopRow + cursorRowOffset);
-        this.write(composePaintOutput({
+        const frame = composePaintFrame({
             width,
             height,
             paintRows,
@@ -2840,10 +3368,22 @@ export class SshTui {
             previousChromeStart: this.lastChromeStart,
             cursorRow: row,
             cursorColumn: column,
-        }));
+            // A size change starts with a full clear, so splitting it would leave the
+            // user looking at a half-empty screen for a frame or two; that one frame
+            // stays whole. Everything incremental is budgeted.
+            maxBytes: sizeChanged ? undefined : frameByteBudget(linkQualityOf(this.paintLink, this.paintRttMs)),
+            ...(this.paintResume === undefined ? {} : { from: this.paintResume }),
+        });
+        this.paintResume = frame.resume;
+        this.write(frame.output);
         this.lastPaintCursorRow = row;
         this.lastPaintCursorColumn = Math.min(width, Math.max(1, column));
-        this.lastPaintRows = paintRows.length > height ? paintRows.slice(0, height) : paintRows;
+        const snapshot = paintRows.length > height ? paintRows.slice(0, height) : paintRows;
+        // Only the rows this frame wrote are up to date; a deferred row keeps its
+        // old entry so the next frame still sees it as changed.
+        this.lastPaintRows = frame.deferred.length === 0
+            ? snapshot
+            : advancePaintedRows(this.lastPaintRows, snapshot, frame.painted);
         this.lastChromeKey = chromeKey;
         this.lastPaintWidth = width;
         this.lastPaintHeight = height;
@@ -2958,6 +3498,13 @@ export class SshTui {
             return;
         if ((this.displayDetached || this.headlessDisplay) && this.displayHost?.attached !== true)
             return;
+        // Burst merging on a slow link: the previous frames have not drained yet,
+        // so another one would only queue behind them and delay the newest state.
+        // The paint is skipped, not lost — `dirty` stays set and the next tick
+        // draws what is current. The bound keeps a genuinely stuck pipe from
+        // freezing the screen forever: after four cadences we paint regardless.
+        if (this.stdoutBacklogged() && Date.now() - this.lastPaintAt < 4 * this.paintIntervalMs)
+            return;
         if (this.agent.status === 'running'
             && Date.now() - this.lastActivity > STALL_WARNING_MS
             && !this.stalledWarningShown
@@ -2971,11 +3518,423 @@ export class SshTui {
         this.dirty = false;
         this.paint();
     };
+    /** Whether the previous frames have not drained yet (slow link, big burst). */
+    stdoutBacklogged() {
+        // Only the direct-stdout path can be measured here; a detached display
+        // sends through its own socket and keeps its own queue.
+        if (this.displayHost?.attached === true || this.displayDetached)
+            return false;
+        try {
+            return process.stdout.writableLength > STDOUT_BACKLOG_BYTES;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * `/preset`: list, inspect, copy, rename, describe, and delete agent presets.
+     *
+     * The four operations the web client drives over the remote surface (list,
+     * read, copy, delete) plus display-metadata edits, which upstream has no
+     * method for and this command writes itself. Every write is either an
+     * upstream service call — which validates the id, the trust level, and the
+     * writable root — or a `preset.yml` written beside a backup. Nothing here
+     * throws: refusals and host errors become rows.
+     */
+    async runPresetCommand(arg) {
+        const service = this.presetService();
+        if (service === undefined) {
+            this.pushRow({
+                kind: 'error',
+                text: [
+                    t('preset.missingService'),
+                    t('mode.missingServiceHint', {
+                        profile: profileFromArgv(),
+                        patch: rosterPatchPath(resolveDshHome(), profileFromArgv()),
+                    }),
+                ].join('\n'),
+            });
+            this.markDirty();
+            return;
+        }
+        const parts = arg.trim().split(/\s+/u).filter(part => part !== '');
+        // No argument opens the wizard: pick a preset, then pick what to do with
+        // it. Every action it offers calls the same handler the line command does,
+        // so both paths share one set of plans, refusals, and confirmations.
+        if (parts.length === 0)
+            return this.presetWizard(service);
+        const sub = parts[0] ?? 'list';
+        const rest = parts.slice(1);
+        if (sub === 'list')
+            return this.presetList(service);
+        if (sub === 'show')
+            return this.presetShow(service, rest[0]);
+        if (sub === 'copy')
+            return this.presetCopy(service, rest[0], rest[1], rest.slice(2).join(' '));
+        if (sub === 'rename')
+            return this.presetWriteMetadata(service, rest[0], { name: rest.slice(1).join(' ') });
+        if (sub === 'describe')
+            return this.presetWriteMetadata(service, rest[0], { description: rest.slice(1).join(' ') });
+        if (sub === 'delete')
+            return this.presetDelete(service, rest[0]);
+        this.pushRow({ kind: 'error', text: t('preset.unknownSub', { sub }) });
+        this.markDirty();
+    }
+    /** The preset service, or undefined on a profile without the roster. */
+    presetService() {
+        return this.ctx.get('agentPresets');
+    }
+    /**
+     * The interactive path: pick a preset, then pick what to do with it.
+     *
+     * Built only on the dialogs the rest of the TUI already uses — a list with a
+     * preselected current entry, and a question with no options for typed input —
+     * and it hands every action to the same handler the line command calls, so a
+     * wizard write can never take a shortcut past a plan, a refusal, or the
+     * delete confirmation.
+     */
+    async presetWizard(service) {
+        try {
+            const presets = await service.list();
+            if (presets.length === 0) {
+                this.pushRow({ kind: 'error', text: t('preset.none') });
+                this.markDirty();
+                return;
+            }
+            const labelOf = (preset) => `${preset.id} · ${preset.name ?? preset.id}`;
+            const currentIndex = presets.findIndex(preset => preset.id === this.presetId);
+            const pickedAnswer = await this.askQuestion({
+                id: 'preset-pick',
+                question: t('preset.wizardPick', { count: presets.length }),
+                options: presets.map(preset => ({
+                    label: labelOf(preset),
+                    description: [
+                        preset.trust === 'user' ? t('preset.trustUser') : t('preset.trustSystem'),
+                        ...(preset.id === service.defaultId ? [t('preset.isDefault')] : []),
+                        ...(preset.id === this.presetId ? [t('preset.isCurrent')] : []),
+                        ...(preset.broken === undefined ? [] : [t('preset.wizardBroken')]),
+                    ].join(' · '),
+                })),
+            }, 0, 1, currentIndex >= 0 ? currentIndex : 0);
+            const picked = presets.find(preset => labelOf(preset) === pickedAnswer.selected[0]);
+            if (picked === undefined)
+                return;
+            const authorable = service.authorable === true;
+            const userOwned = picked.trust === 'user';
+            const actions = [
+                { id: 'show', label: t('preset.actionShow') },
+                // A copy may start from any preset — the destination is the user root.
+                ...(authorable ? [{ id: 'copy', label: t('preset.actionCopy') }] : []),
+                ...(authorable && userOwned ? [
+                    { id: 'rename', label: t('preset.actionRename') },
+                    { id: 'describe', label: t('preset.actionDescribe') },
+                    { id: 'delete', label: t('preset.actionDelete') },
+                ] : []),
+            ];
+            const actionAnswer = await this.askQuestion({
+                id: 'preset-action',
+                question: t('preset.wizardAction', { id: picked.id, name: picked.name ?? picked.id }),
+                options: actions.map(action => ({ label: action.label })),
+            });
+            const action = actions.find(candidate => candidate.label === actionAnswer.selected[0])?.id;
+            if (action === undefined)
+                return;
+            if (action === 'show') {
+                await this.presetShow(service, picked.id);
+                return;
+            }
+            if (action === 'copy') {
+                const id = await this.askPresetInput(t('preset.wizardNewId', { from: picked.id }));
+                if (id === undefined)
+                    return this.presetCancelled();
+                const name = await this.askPresetInput(t('preset.wizardNewName'));
+                if (name === undefined)
+                    return this.presetCancelled();
+                await this.presetCopy(service, picked.id, id.trim(), name.trim());
+                return;
+            }
+            if (action === 'rename') {
+                const name = await this.askPresetInput(t('preset.wizardRename', { id: picked.id }));
+                if (name === undefined)
+                    return this.presetCancelled();
+                await this.presetWriteMetadata(service, picked.id, { name });
+                return;
+            }
+            if (action === 'describe') {
+                const description = await this.askPresetInput(t('preset.wizardDescribe', { id: picked.id }));
+                if (description === undefined)
+                    return this.presetCancelled();
+                await this.presetWriteMetadata(service, picked.id, { description });
+                return;
+            }
+            await this.presetDelete(service, picked.id);
+        }
+        catch (error) {
+            if (error instanceof UserQuestionError) {
+                this.presetCancelled();
+                return;
+            }
+            throw error;
+        }
+    }
+    /** One free-form answer; `undefined` when the user cancels with Esc. */
+    async askPresetInput(question) {
+        try {
+            const answer = await this.askQuestion({ id: 'preset-input', question, options: [] });
+            return answer.custom ?? answer.selected[0] ?? '';
+        }
+        catch (error) {
+            if (error instanceof UserQuestionError)
+                return undefined;
+            throw error;
+        }
+    }
+    /** A wizard step the user backed out of: nothing was written. */
+    presetCancelled() {
+        this.pushRow({ kind: 'system', text: t('preset.cancelled') });
+        this.markDirty();
+    }
+    /** One row per preset: id, display name, trust, and what it is missing. */
+    async presetList(service) {
+        const presets = await service.list();
+        const authorable = service.authorable === true;
+        const lines = [t('preset.listTitle', { count: presets.length, default: service.defaultId })];
+        for (const preset of presets) {
+            const flags = [
+                preset.trust === 'user' ? t('preset.trustUser') : t('preset.trustSystem'),
+                ...(preset.id === service.defaultId ? [t('preset.isDefault')] : []),
+                ...(preset.id === this.presetId ? [t('preset.isCurrent')] : []),
+            ].join(' · ');
+            lines.push(t('preset.listRow', { id: preset.id, name: preset.name ?? preset.id, flags }));
+            if (preset.broken !== undefined)
+                lines.push(t('preset.listBroken', { reason: preset.broken }));
+        }
+        lines.push(authorable
+            ? t('preset.listWritable', { root: service.roots?.find(root => root.trust === 'user')?.path ?? '' })
+            : t('preset.listReadOnly'));
+        this.pushRow({ kind: 'system', text: lines.join('\n') });
+        this.markDirty();
+    }
+    /** One preset's metadata and the rows its composition mounts. */
+    async presetShow(service, id) {
+        const presets = await service.list();
+        const ids = presets.map(preset => preset.id).join(', ');
+        if (id === undefined || id === '') {
+            this.pushRow({ kind: 'error', text: t('preset.needId', { ids }) });
+            this.markDirty();
+            return;
+        }
+        const preset = presets.find(candidate => candidate.id === id);
+        if (preset === undefined) {
+            this.pushRow({ kind: 'error', text: t('preset.unknownId', { id, ids }) });
+            this.markDirty();
+            return;
+        }
+        const lines = [t('preset.showTitle', { id: preset.id, name: preset.name ?? preset.id })];
+        lines.push(t('preset.showMeta', {
+            trust: preset.trust === 'user' ? t('preset.trustUser') : t('preset.trustSystem'),
+            order: preset.order === undefined ? '—' : String(preset.order),
+            directory: presetDirectory(preset),
+        }));
+        if (preset.description !== undefined)
+            lines.push(t('preset.showDescription', { description: preset.description }));
+        if (preset.broken !== undefined) {
+            lines.push(t('preset.showBroken', { reason: preset.broken }));
+        }
+        else if (typeof service.compositionInventory === 'function') {
+            const composition = (await service.compositionInventory()).find(entry => entry.id === preset.id);
+            if (composition === undefined) {
+                lines.push(t('preset.showNoRows'));
+            }
+            else {
+                for (const row of composition.rows) {
+                    lines.push(t('preset.showRow', {
+                        module: row.moduleName,
+                        entry: row.entryId === null ? '' : t('preset.showRowId', { id: row.entryId }),
+                        state: row.enabled === true
+                            ? ''
+                            : row.enabled === false
+                                ? t('preset.rowDisabled')
+                                : t('preset.rowConditional', { condition: row.condition ?? '' }),
+                    }));
+                }
+            }
+        }
+        else if (typeof service.read === 'function') {
+            // A host older than the inventory API still hands over the document.
+            const document = await service.read(preset.id);
+            lines.push(t('preset.showRawHint'));
+            for (const line of document.split('\n').slice(0, 40))
+                lines.push(`  ${line}`);
+        }
+        else {
+            lines.push(t('preset.unsupported', { feature: 'read' }));
+        }
+        this.pushRow({ kind: 'system', text: lines.join('\n') });
+        this.markDirty();
+    }
+    /** Copy an existing preset (upstream's only creation path). */
+    async presetCopy(service, from, id, name) {
+        if (typeof service.copy !== 'function') {
+            this.pushRow({ kind: 'error', text: t('preset.unsupported', { feature: 'copy' }) });
+            this.markDirty();
+            return;
+        }
+        const presets = await service.list();
+        const plan = planCopy({
+            presets,
+            authorable: service.authorable === true,
+            from: from ?? '',
+            id: id ?? '',
+            name: name === '' ? undefined : name,
+        });
+        if (isRefusal(plan)) {
+            this.pushPresetRefusal(plan);
+            return;
+        }
+        const copy = service.copy.bind(service);
+        await this.presetWrite(async () => {
+            await copy(plan.from, plan.id, plan.name);
+            return t('preset.copyDone', {
+                from: plan.from,
+                id: plan.id,
+                name: plan.name === undefined ? '' : ` · ${plan.name}`,
+                directory: presetDirectory(presets.find(candidate => candidate.id === plan.id) ?? presets[0]),
+            });
+        });
+    }
+    /** Edit the display name or description: a `preset.yml` written beside a backup. */
+    async presetWriteMetadata(service, id, patch) {
+        const presets = await service.list();
+        const preset = presets.find(candidate => candidate.id === id);
+        if (preset === undefined) {
+            this.pushRow({
+                kind: 'error',
+                text: t('preset.unknownId', { id: id ?? '', ids: presets.map(candidate => candidate.id).join(', ') }),
+            });
+            this.markDirty();
+            return;
+        }
+        if ((patch.name ?? patch.description ?? '').trim() === '') {
+            this.pushRow({ kind: 'error', text: t('preset.needValue', { id: preset.id }) });
+            this.markDirty();
+            return;
+        }
+        // Merge with what the preset publishes now, so editing one field never
+        // drops the other and `order` survives.
+        const current = await readPresetMetadata(presetDirectory(preset));
+        const plan = planMetadata({ preset, current, patch });
+        if (isRefusal(plan)) {
+            this.pushPresetRefusal(plan);
+            return;
+        }
+        const path = join(plan.directory, METADATA_FILE);
+        const field = patch.name === undefined ? t('preset.fieldDescription') : t('preset.fieldName');
+        await this.presetWrite(async () => {
+            const backup = await writePatchWithBackup(path, plan.text);
+            return [
+                t('preset.metadataDone', { id: plan.id, field }),
+                ...(backup === undefined ? [] : [t('preset.backupLine', { path: backup })]),
+            ].join('\n');
+        });
+    }
+    /** Delete a user preset after one confirmation. */
+    async presetDelete(service, id) {
+        if (typeof service.remove !== 'function') {
+            this.pushRow({ kind: 'error', text: t('preset.unsupported', { feature: 'delete' }) });
+            this.markDirty();
+            return;
+        }
+        const presets = await service.list();
+        const preset = presets.find(candidate => candidate.id === id);
+        if (preset === undefined) {
+            this.pushRow({
+                kind: 'error',
+                text: t('preset.unknownId', { id: id ?? '', ids: presets.map(candidate => candidate.id).join(', ') }),
+            });
+            this.markDirty();
+            return;
+        }
+        const plan = planDelete({
+            preset,
+            authorable: service.authorable === true,
+            current: preset.id === this.presetId,
+        });
+        if (isRefusal(plan)) {
+            this.pushPresetRefusal(plan);
+            return;
+        }
+        const answer = await new Promise(resolve => {
+            this.openConfirm(t('preset.deleteConfirm', { id: plan.id }), t('preset.deleteHint', { directory: presetDirectory(preset) }), resolve);
+        });
+        if (answer !== 'y') {
+            this.pushRow({ kind: 'system', text: t('preset.deleteCancelled') });
+            this.markDirty();
+            return;
+        }
+        const remove = service.remove.bind(service);
+        await this.presetWrite(async () => {
+            await remove(plan.id);
+            return t('preset.deleteDone', { id: plan.id });
+        });
+    }
+    /**
+     * Run one authoring call and report it.
+     *
+     * The service validates more than this command can (the writable root, an
+     * occupied id, the trust recorded on disk), so its message is what the user
+     * sees when it refuses.
+     */
+    async presetWrite(call) {
+        try {
+            this.pushRow({ kind: 'system', text: await call() });
+        }
+        catch (error) {
+            this.pushRow({ kind: 'error', text: t('preset.failed', { error: errorChain(error) }) });
+        }
+        this.markDirty();
+    }
+    /** One refusal, in the user's language. */
+    pushPresetRefusal(refusal) {
+        this.pushRow({
+            kind: 'error',
+            text: t(`preset.refused.${refusal.error}`, {
+                id: refusal.id ?? '',
+                name: refusal.name ?? refusal.id ?? '',
+                root: this.presetService()?.roots?.find(root => root.trust === 'user')?.path ?? '',
+            }, refusal.error),
+        });
+        this.markDirty();
+    }
+    /**
+     * Apply the footer's muted style around a strip that carries its own accents
+     * (the link pips, the ⚠). {@link styleLine} cannot do this: it sanitises its
+     * input, which strips an accent's `ESC` and leaves the `[32m` body on the grid
+     * as four literal characters — the garbled footer B-1 shipped. Every inner
+     * reset re-opens the muted style, so the text between two accents stays muted.
+     */
+    muteFooterLine(text) {
+        if (text === '')
+            return '';
+        const code = this.mutedSgr();
+        if (code === '')
+            return text;
+        const open = `\x1b[${code}m`;
+        return `${open}${text.replaceAll('\x1b[0m', `\x1b[0m${open}`)}\x1b[0m`;
+    }
+    /** The muted strip separator, so the groups between the accents stay dim. */
+    mutedSeparator() {
+        const code = this.mutedSgr();
+        return code === '' ? ' │ ' : `\x1b[${code}m │ `;
+    }
+    mutedSgr() {
+        return this.color ? downgradeSgr('90', this.colorDepth) : '';
+    }
     styleLine(kind, text) {
         const safe = sanitizeTerminalText(text);
         if (!this.color)
             return safe;
-        const code = kind === 'user' ? '36' :
+        const requested = kind === 'user' ? '36' :
             kind === 'assistant' ? '37' :
                 kind === 'reasoning' ? '2;3' :
                     kind === 'brand' ? '1;38;2;77;107;253' :
@@ -2986,10 +3945,17 @@ export class SshTui {
                                     kind === 'diff-path' ? '1;36' :
                                         kind === 'todo-done' ? '2;32' :
                                             kind === 'todo-active' ? '1;36' :
-                                                kind === 'todo-pending' ? '90' :
-                                                    kind === 'plan-dock' ? '38;5;180' :
-                                                        kind === 'error' ? '31' :
-                                                            '90';
+                                                kind === 'todo-failed' ? '31' :
+                                                    kind === 'todo-skipped' ? '2;33' :
+                                                        kind === 'todo-pending' ? '90' :
+                                                            kind === 'plan-dock' ? '38;5;180' :
+                                                                kind === 'diag' ? '2;36' :
+                                                                    kind === 'error' ? '31' :
+                                                                        '90';
+        const code = downgradeSgr(requested, this.colorDepth);
+        // Nothing left to paint: the text stands on its own.
+        if (code === '')
+            return safe;
         return `\x1b[${code}m${safe}\x1b[0m`;
     }
     /**
@@ -4087,16 +5053,47 @@ export class SshTui {
         }
         return '';
     }
-    async reviewUnknownWithModel(request, command, args) {
-        const llm = this.ctx.get('llm');
-        if (llm === undefined)
-            return undefined;
+    /**
+     * The route the AI approval reviewer runs on: the subagent selection when it
+     * matches the parent provider, else that provider's light model. Shared with
+     * the verdict cache, whose key has to name the reviewer that produced a
+     * verdict — a different model may decide differently.
+     */
+    reviewerRoute() {
         const selection = this.subagentSelection.current;
         const parentProvider = this.selectionRef?.current?.provider ?? this.agent.options.provider ?? this.providerName;
         const provider = selection.provider ?? parentProvider;
         const model = subagentModelMatchesProvider(provider, selection.model)
             ? selection.model
             : defaultSubagentModelForProvider(provider, [], this.selectionRef?.current?.model);
+        return { provider, model };
+    }
+    /**
+     * The cache key for one `ask`-shaped request, or `undefined` when the shape
+     * must not be remembered (no command, or an opaque interpreter payload).
+     */
+    approvalCacheKey(request, command, args) {
+        if (command === undefined)
+            return undefined;
+        const input = {
+            toolName: request.toolName,
+            command,
+            args,
+            reason: request.reason,
+            sandboxMode: this.hostSandboxMode,
+            agentId: String(request.agent.id),
+            workspaceCwd: this.workspaceCwd(),
+            locale: getLocale(),
+            reviewer: this.reviewerRoute(),
+            authorization: this.latestUserAuthorizationText(request.agent),
+        };
+        return cacheableShape(input) ? verdictKey(input) : undefined;
+    }
+    async reviewUnknownWithModel(request, command, args) {
+        const llm = this.ctx.get('llm');
+        if (llm === undefined)
+            return undefined;
+        const { provider, model } = this.reviewerRoute();
         // 最近模型输出/思考（≤2 段）与会话日志里最新用户消息（跳过 plugin notice）
         const segments = [];
         for (let i = this.rows.length - 1; i >= 0 && segments.length < 2; i -= 1) {
@@ -4168,7 +5165,7 @@ export class SshTui {
         this.markDirty();
         return verdict;
     }
-    recordAutoApproval(decision, risk, toolName, command, reason) {
+    recordAutoApproval(decision, risk, toolName, command, reason, fromCache) {
         if (decision === 'allow')
             this.autoAllowedCount += 1;
         else
@@ -4179,12 +5176,20 @@ export class SshTui {
         const clipped = Array.from(subject).length > 160
             ? `${Array.from(subject).slice(0, 160).join('')}…`
             : subject;
-        const rowText = t('approval.decisionRow', {
-            verdict: decision === 'allow' ? t('approval.reviewApproved') : t('approval.reviewRejected'),
-            command: clipped,
-            risk,
-            reason,
-        });
+        const rowText = fromCache === undefined
+            ? t('approval.decisionRow', {
+                verdict: decision === 'allow' ? t('approval.reviewApproved') : t('approval.reviewRejected'),
+                command: clipped,
+                risk,
+                reason,
+            })
+            : t('approval.cacheHitRow', {
+                age: formatShortDuration(fromCache.ageMs),
+                verdict: decision === 'allow' ? t('approval.reviewApproved') : t('approval.reviewRejected'),
+                command: clipped,
+                risk,
+                reason,
+            });
         this.pushRow({ kind: 'system', text: rowText });
         this.markDirty();
         if (decision === 'deny')
@@ -4246,10 +5251,22 @@ export class SshTui {
                 return 'rejected';
             }
             // Unknown shape: the rule table cannot judge it — hand it to the
-            // subagent-configured model with compact context (AI review). Without
-            // a display there is nobody to fall back on, so unreviewable asks
-            // reject and the turn completes instead of stalling.
+            // subagent-configured model with compact context (AI review). A verdict
+            // this TUI already produced for the exact same request (tool, command,
+            // arguments, workspace, reviewer, and the user message that authorized
+            // it) is reused inside its TTL instead of paying for the review again.
+            const cacheKey = this.approvalCacheKey(request, command, row?.args);
+            const cached = cacheKey === undefined ? undefined : this.approvalCache.lookup(cacheKey);
+            if (cached !== undefined) {
+                this.cacheHitCount += 1;
+                this.recordAutoApproval(cached.verdict.approved ? 'allow' : 'deny', cached.verdict.risk, request.toolName, command, cached.verdict.reason === ''
+                    ? cached.verdict.approved ? t('approval.reviewApproved') : t('approval.reviewRejected')
+                    : cached.verdict.reason, { fromCache: true, ageMs: cached.ageMs });
+                return cached.verdict.approved ? 'allowed-once' : 'rejected';
+            }
             const reviewed = await this.reviewUnknownWithModel(request, command, row?.args);
+            if (reviewed !== undefined && cacheKey !== undefined)
+                this.approvalCache.store(cacheKey, reviewed);
             if (reviewed?.approved === true) {
                 this.recordAutoApproval('allow', reviewed.risk, request.toolName, command, reviewed.reason === '' ? t('approval.reviewApproved') : reviewed.reason);
                 return 'allowed-once';
@@ -4259,6 +5276,7 @@ export class SshTui {
                 return 'rejected';
             }
             if (!this.hasLiveDisplay()) {
+                this.detachedDeniedCount += 1;
                 this.recordAutoApproval('deny', 'medium', request.toolName, command, t('approval.ruleDetached'));
                 return 'rejected';
             }
@@ -4297,8 +5315,17 @@ export class SshTui {
         });
     };
     handleUserQuestions = async (request) => {
-        if (!this.hasLiveDisplay())
-            await this.waitForLiveDisplay(request.signal);
+        if (!this.hasLiveDisplay()) {
+            // Counted here, not read off the rows: the card is built only after the
+            // wait resolves, so at reattach time a queued question has no row yet.
+            this.queuedQuestions += 1;
+            try {
+                await this.waitForLiveDisplay(request.signal);
+            }
+            finally {
+                this.queuedQuestions -= 1;
+            }
+        }
         const answers = [];
         const agentLabel = request.agent === undefined || request.agent.id === this.agent.id
             ? undefined
@@ -4436,14 +5463,23 @@ export class SshTui {
         this.removeQueuedDialog(dialog);
         dialog.resolve('cancel');
     }
-    openQuestion(question, index, total, resolve, reject, preselected) {
+    openQuestion(question, index, total, resolve, reject, preselected, matchKeys) {
+        // A list opens with its first option already chosen: Enter then answers that
+        // default for a single- and a multi-select question alike, instead of
+        // coming back with an empty selection. Esc stays the explicit cancel, and a
+        // question with no options still answers with the typed text.
+        const optionCount = question.options?.length ?? 0;
+        const initial = preselected !== undefined && preselected >= 0 && preselected < optionCount
+            ? preselected
+            : optionCount > 0 ? 0 : -1;
         const dialog = {
             kind: 'questions',
             question,
             index,
             total,
-            selected: new Set(preselected !== undefined && preselected >= 0 ? [preselected] : []),
-            cursor: preselected !== undefined && preselected >= 0 ? preselected : 0,
+            selected: new Set(initial >= 0 ? [initial] : []),
+            cursor: initial >= 0 ? initial : 0,
+            ...(matchKeys === undefined ? {} : { matchKeys }),
             resolve: (selection) => {
                 this.settleQuestion(dialog, () => resolve(selection));
             },
@@ -4455,9 +5491,9 @@ export class SshTui {
         return dialog;
     }
     /** Open one question dialog and await its answer (cancellation rejects). */
-    askQuestion(question, index = 0, total = 1, preselected) {
+    askQuestion(question, index = 0, total = 1, preselected, matchKeys) {
         return new Promise((resolve, reject) => {
-            this.openQuestion(question, index, total, resolve, reject, preselected);
+            this.openQuestion(question, index, total, resolve, reject, preselected, matchKeys);
         });
     }
     /** The stored llm-pi-ai profile for one provider route, when settings provide one. */
@@ -5374,48 +6410,53 @@ export class SshTui {
             this.markDirty();
             return;
         }
-        // Shipped presets resolve through the TUI dictionary; a user-authored one
-        // keeps the name its own preset.yml published.
-        const labels = presets.map(preset => presetLabel(preset.id, preset.name, preset.trust));
-        const matchesDirect = (preset, label) => preset.id.toLowerCase() === direct
-            || (preset.name ?? '').trim().toLowerCase() === direct
-            || label.toLowerCase() === direct;
+        // Shipped presets first, then locally authored ones, each line naming its
+        // group and position: the dialog is a flat list, so the grouping lives in
+        // the order and the text.
+        const options = flattenGroups(groupPresets(presets, this.presetId));
+        const matchesDirect = (option) => option.id.toLowerCase() === direct || option.label.toLowerCase() === direct
+            // A published name still selects its preset even when the label resolves
+            // through the dictionary instead.
+            || optionMatches(option, direct);
         let index = direct === ''
             ? -1
-            : presets.findIndex((preset, at) => matchesDirect(preset, labels[at] ?? preset.id));
+            : options.findIndex(option => matchesDirect(option));
         if (index < 0 && direct !== '') {
             this.pushRow({
                 kind: 'error',
-                text: t('mode.unknown', { id: arg.trim(), available: presets.map(preset => preset.id).join(', ') }),
+                text: t('mode.unknown', { id: arg.trim(), available: options.map(option => option.id).join(', ') }),
             });
             this.markDirty();
             return;
         }
         if (index < 0 && direct === '') {
+            // Like every other picker, the list opens on what is in effect now.
+            const currentIndex = options.findIndex(option => option.id === this.presetId);
             const answer = await this.askQuestion({
                 id: 'mode-pick',
                 question: t('mode.pick'),
-                options: presets.map((preset, at) => ({
-                    label: labels[at] ?? preset.id,
-                    description: `${preset.id === this.presetId ? t('mode.currentPrefix') : ''}${preset.broken === undefined ? preset.description ?? '' : t('mode.brokenSuffix', { reason: preset.broken })}`.trim(),
-                })),
-            });
-            index = labels.indexOf(answer.selected[0] ?? '');
+                options: options.map(option => ({ label: option.label, description: option.description })),
+            }, 0, 1, currentIndex >= 0 ? currentIndex : undefined, options.map(option => option.id));
+            const picked = answer.selected[0] ?? '';
+            index = options.findIndex(option => option.label === picked);
         }
         if (index < 0)
             return;
-        const selected = presets[index];
+        const option = options[index];
+        if (option === undefined)
+            return;
+        const selected = presets.find(preset => preset.id === option.id);
         if (selected === undefined)
             return;
-        if (selected.broken !== undefined) {
+        if (option.broken !== undefined) {
             this.pushRow({
                 kind: 'error',
-                text: t('mode.broken', { name: labels[index] ?? selected.id, reason: selected.broken }),
+                text: t('mode.broken', { name: option.label, reason: option.broken }),
             });
             this.markDirty();
             return;
         }
-        const selectedName = labels[index] ?? selected.id;
+        const selectedName = option.label;
         const hasWork = sessionEvents(this.agent.session).some(event => event.type === 'turn/start');
         if (!hasWork) {
             await agentPresets.recompose(this.agent.ctx, selected.id);
@@ -5439,11 +6480,16 @@ export class SshTui {
      * patch tree once at boot — so the report says so instead of pretending the
      * running session gained a roster.
      */
+    /** Re-read the roster fact this process was composed with (cheap, no IO). */
+    refreshRosterHealth() {
+        this.rosterMissing = this.ctx.get('agentPresets') === undefined;
+    }
     async repairRoster() {
         const profile = profileFromArgv();
         const patch = rosterPatchPath(resolveDshHome(), profile);
         try {
             const result = await ensureRosterRows(resolveDshHome(), profile);
+            this.refreshRosterHealth();
             this.pushRow({
                 kind: 'system',
                 text: result === 'present' ? t('mode.fixPresent', { patch }) : t('mode.fixWritten', { patch }),
@@ -5776,6 +6822,19 @@ export class SshTui {
             this.processPasteChunk(combined);
             return;
         }
+        // A key the user moved, and a key their move displaced. Consulted before any
+        // routing so a plain control byte reaches it as readily as a CSI sequence;
+        // everything else keeps the handling below, which is what makes the defaults
+        // unchanged by construction.
+        if (this.dialog === undefined && combined !== '') {
+            const moved = this.keymap.sequences.get(combined);
+            if (moved !== undefined && this.keymap.overridden.has(moved)) {
+                if (this.runKeyAction(moved))
+                    return;
+            }
+            if (this.keymap.suppressed.has(combined))
+                return;
+        }
         const escape = /^\x1b\[([A-D])$/u;
         const match = combined.match(escape);
         if (match !== null) {
@@ -5833,6 +6892,7 @@ export class SshTui {
         const sgrMouse = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/u.exec(combined);
         if (sgrMouse !== null) {
             const button = Number(sgrMouse[1]);
+            const x = Number(sgrMouse[2]);
             const y = Number(sgrMouse[3]);
             if (sgrMouse[4] === 'M') {
                 if (button === 64) {
@@ -5843,12 +6903,20 @@ export class SshTui {
                     this.scrollInspectOrTranscript(-3);
                     return;
                 }
+                // 32 is "motion with the left button held": a drag over a reply.
+                if (button === 32) {
+                    this.extendMouseSelection(y, x);
+                    return;
+                }
                 if (button === 0) {
-                    const x = Number(sgrMouse[2]);
-                    this.handleMouseClick(y, x);
+                    this.beginMouseSelection(y, x);
                     return;
                 }
+                return;
             }
+            // A release ends either a drag (copy what it covered) or a plain click.
+            if (button === 0)
+                this.endMouseSelection(y, x);
             return;
         }
         if (combined === '\x1b[5~') {
@@ -6135,6 +7203,32 @@ export class SshTui {
             this.markDirty();
         }
     }
+    /**
+     * Run one rebindable action.
+     * @param action - the action the pressed key was moved to.
+     * @returns true when the key was consumed.
+     */
+    runKeyAction(action) {
+        switch (action) {
+            case 'pageUp':
+                this.scrollInspectOrTranscript(Math.max(3, Math.floor(this.screenRows() / 2)));
+                return true;
+            case 'pageDown':
+                this.scrollInspectOrTranscript(-Math.max(3, Math.floor(this.screenRows() / 2)));
+                return true;
+            case 'toggleCard':
+                this.toggleCollapsible();
+                return true;
+            case 'copy':
+                this.copyFocusedCard();
+                return true;
+            case 'cancel':
+                this.handleEscape();
+                return true;
+            default:
+                return false;
+        }
+    }
     moveQuestionCursor(delta) {
         const dialog = this.dialog;
         if (dialog === undefined || dialog.kind !== 'questions')
@@ -6163,6 +7257,32 @@ export class SshTui {
                 this.closeConfirm(answer);
             return;
         }
+        // Filter mode owns the printable keys: the list's hotkeys are letters and
+        // digits, so the two cannot both be live at once.
+        if (dialog.filtering === true) {
+            if (text === '\r' || text === '\n') {
+                applyQuestionFilter(dialog);
+                this.markDirty();
+                return;
+            }
+            if (text === '\x7f' || text === '\b') {
+                backspaceQuestionFilter(dialog);
+                this.markDirty();
+                return;
+            }
+            if (text.length === 1 && text >= ' ') {
+                typeQuestionFilter(dialog, text);
+                this.markDirty();
+                return;
+            }
+            return;
+        }
+        if (text === '/' && (dialog.question.options?.length ?? 0) > 0) {
+            dialog.filtering = true;
+            dialog.filter = '';
+            this.markDirty();
+            return;
+        }
         if (selectQuestionOptionByKey(dialog, text))
             this.markDirty();
         if (text === '\r' || text === '\n') {
@@ -6771,6 +7891,15 @@ export class SshTui {
         }
     }
     handleEscape() {
+        if (this.dialog?.kind === 'questions'
+            && (this.dialog.filtering === true || (this.dialog.filter ?? '') !== '')) {
+            // Esc means "show me everything again" while a filter is up; cancelling
+            // the whole question on the same key would throw away the answer the user
+            // is still composing.
+            clearQuestionFilter(this.dialog);
+            this.markDirty();
+            return;
+        }
         if (this.dialog !== undefined) {
             if (this.dialog.kind === 'inspect') {
                 this.closeInspect();
@@ -6808,9 +7937,147 @@ export class SshTui {
         }
     }
     /** Toggle the collapsible row under a click, or copy an OSC-8 link. */
+    /**
+     * The anchor's line index in the *current* frame.
+     *
+     * A live session repaints while the button is down, and the transcript is
+     * pinned to the bottom: a row arriving below shifts everything up by one. The
+     * stored index would then point at whatever moved into that screen row, so
+     * the anchor is re-found by the row it grabbed (and by its text when the row
+     * carries no identity). When the row has scrolled out of view entirely, the
+     * old index is the best that can be done.
+     */
+    resolveAnchorLine() {
+        const anchor = this.mouseAnchor;
+        if (anchor === undefined)
+            return undefined;
+        const candidates = [];
+        for (let index = 0; index < this.selectableLines.length; index += 1) {
+            const line = this.selectableLines[index];
+            if (line === undefined || line.copyable !== true)
+                continue;
+            if (this.mouseAnchorRef !== undefined) {
+                if (line.ref === this.mouseAnchorRef)
+                    candidates.push(index);
+            }
+            else if (stripAnsi(line.raw) === this.mouseAnchorText) {
+                candidates.push(index);
+            }
+        }
+        if (candidates.length === 0)
+            return anchor.line;
+        return candidates.reduce((best, index) => (Math.abs(index - anchor.line) < Math.abs(best - anchor.line) ? index : best), candidates[0] ?? anchor.line);
+    }
+    /** The painted lines as plain text, for the selection rules. */
+    plainSelectableLines() {
+        return this.selectableLines.map(line => ({ text: stripAnsi(line.raw), copyable: line.copyable }));
+    }
+    /** Screen row from a mouse report to an index into `selectableLines`. */
+    selectableLineAt(screenY) {
+        const index = screenY - this.transcriptTopScreenY;
+        if (index < 0 || index >= this.selectableLines.length)
+            return undefined;
+        return index;
+    }
+    /**
+     * Left button pressed. The click itself waits for the release: this may turn
+     * into a drag, and a press that never moves must still open a link or toggle
+     * a card exactly as before.
+     */
+    beginMouseSelection(y, x) {
+        this.pendingMouseClick = undefined;
+        this.mouseAnchor = undefined;
+        if (this.dialog !== undefined) {
+            this.pendingMouseClick = { y, x };
+            return;
+        }
+        const line = this.selectableLineAt(y);
+        if (line === undefined || this.selectableLines[line]?.copyable !== true) {
+            this.pendingMouseClick = { y, x };
+            return;
+        }
+        this.mouseAnchor = { line, column: Math.max(0, x - 1) };
+        const grabbed = this.selectableLines[line];
+        this.mouseAnchorRef = grabbed?.ref;
+        this.mouseAnchorText = grabbed === undefined ? '' : stripAnsi(grabbed.raw);
+        this.mouseSelection = undefined;
+    }
+    /** The button is held and the pointer moved: extend the drag and repaint it. */
+    extendMouseSelection(y, x) {
+        const resolved = this.resolveAnchorLine();
+        if (resolved === undefined || this.mouseAnchor === undefined)
+            return;
+        this.mouseAnchor = { line: resolved, column: this.mouseAnchor.column };
+        const anchor = this.mouseAnchor;
+        const line = this.selectableLineAt(y) ?? (y < this.transcriptTopScreenY ? 0 : this.selectableLines.length - 1);
+        const clamped = clampSelection(this.plainSelectableLines(), anchor, { line, column: Math.max(0, x - 1) });
+        if (clamped === undefined)
+            return;
+        const same = this.mouseSelection !== undefined
+            && this.mouseSelection.from.line === clamped.from.line
+            && this.mouseSelection.from.column === clamped.from.column
+            && this.mouseSelection.to.line === clamped.to.line
+            && this.mouseSelection.to.column === clamped.to.column;
+        this.mouseSelection = clamped;
+        if (!same)
+            this.markDirty();
+    }
+    /** Release: copy the dragged text, or perform the click that never became one. */
+    endMouseSelection(y, x) {
+        const resolved = this.resolveAnchorLine();
+        const anchor = resolved === undefined || this.mouseAnchor === undefined
+            ? undefined
+            : { line: resolved, column: this.mouseAnchor.column };
+        const selection = this.mouseSelection;
+        const click = this.pendingMouseClick;
+        this.mouseAnchor = undefined;
+        this.mouseAnchorRef = undefined;
+        this.mouseAnchorText = '';
+        this.mouseSelection = undefined;
+        this.pendingMouseClick = undefined;
+        if (anchor === undefined) {
+            if (click !== undefined)
+                this.handleMouseClick(click.y, click.x);
+            return;
+        }
+        const text = selection === undefined ? '' : selectionText(this.plainSelectableLines(), selection);
+        if (text.trim() === '') {
+            // A press that did not really drag is a click, not an empty copy.
+            this.handleMouseClick(y, x);
+            this.markDirty();
+            return;
+        }
+        const lines = selection === undefined ? 1 : selection.to.line - selection.from.line + 1;
+        this.copyPlainText(text, t('copy.selection', { chars: text.length, lines }));
+        this.markDirty();
+    }
+    /** Paint the drag in reverse video; the affected lines drop their colors. */
+    highlightSelection(visible) {
+        const selection = this.mouseSelection;
+        if (selection === undefined)
+            return [...visible];
+        const plain = this.plainSelectableLines();
+        const spans = selectionSpans(plain, selection);
+        if (spans.length === 0)
+            return [...visible];
+        const lines = [...visible];
+        for (const span of spans) {
+            const text = plain[span.line]?.text ?? '';
+            const startOffset = offsetAtColumn(text, span.start);
+            const endOffset = offsetAfterColumn(text, span.end);
+            lines[span.line] = `${text.slice(0, startOffset)}\x1b[7m${text.slice(startOffset, endOffset)}\x1b[27m${text.slice(endOffset)}`;
+        }
+        return lines;
+    }
     handleMouseClick(y, x = 1) {
         if (this.dialog !== undefined)
             return;
+        // The health chip is a standing warning, so clicking it opens the report
+        // that explains it — the row is the strip, and the chip leads it.
+        if (this.healthChipRow !== undefined && y === this.healthChipRow) {
+            this.runCommand('/doctor');
+            return;
+        }
         const hits = this.paintedLinkHitsByRow.get(y);
         const href = hits === undefined ? undefined : hrefAtColumn(hits, Math.max(0, x - 1));
         if (href !== undefined && href.trim() !== '') {
@@ -6837,18 +8104,38 @@ export class SshTui {
         this.pushRow({ kind: 'system', text: notice });
         this.markDirty();
     }
-    copyFocusedCard() {
+    copyFocusedCard(arg = '') {
         if (this.dialog !== undefined)
             return false;
-        const picked = copyTextFromTranscript(this.rows, this.focusedRow);
-        if (picked.text.trim() === '') {
-            this.pushRow({ kind: 'system', text: t('copy.empty') });
-            this.markDirty();
-            return false;
+        // `error` copies the newest failure or diagnostic row: a long path or a
+        // command in one of those must reach the clipboard whole, which is exactly
+        // what copying the row's own text does (the wrapped screen lines a drag
+        // would join are not what the user wants to paste into a report).
+        if (arg.trim().toLowerCase() === 'error') {
+            const failed = this.rows.findLast(row => row.kind === 'error' || row.kind === 'diag');
+            const text = copyTextFromRow(failed);
+            if (text.trim() === '') {
+                this.pushRow({ kind: 'system', text: t('copy.noError') });
+                this.markDirty();
+                return false;
+            }
+            this.copyPlainText(text, t('copy.ok', { chars: text.length, source: t('copy.sourceError') }));
+            return true;
         }
-        const source = picked.source === 'focused' ? t('copy.sourceFocused') : t('copy.sourceAssistant');
-        this.copyPlainText(picked.text, t('copy.ok', { chars: picked.text.length, source }));
-        return true;
+        if (arg.trim() === '') {
+            const picked = copyTextFromTranscript(this.rows, this.focusedRow);
+            if (picked.text.trim() === '') {
+                this.pushRow({ kind: 'system', text: t('copy.empty') });
+                this.markDirty();
+                return false;
+            }
+            const source = picked.source === 'focused' ? t('copy.sourceFocused') : t('copy.sourceAssistant');
+            this.copyPlainText(picked.text, t('copy.ok', { chars: picked.text.length, source }));
+            return true;
+        }
+        this.pushRow({ kind: 'system', text: t('copy.usage') });
+        this.markDirty();
+        return false;
     }
     scrollInspectOrTranscript(delta) {
         if (this.dialog?.kind === 'inspect') {
@@ -7075,7 +8362,7 @@ export class SshTui {
                 });
                 break;
             case 'copy':
-                this.copyFocusedCard();
+                this.copyFocusedCard(arg);
                 break;
             case 'find':
                 this.runFindCommand(arg);
@@ -7134,6 +8421,18 @@ export class SshTui {
                     this.markDirty();
                 });
                 break;
+            case 'doctor':
+                void this.runDoctorCommand(arg, /--fix|(^|\s)fix(\s|$)/u.test(arg)).catch((error) => {
+                    this.pushRow({ kind: 'error', text: t('cmd.failedNamed', { command, error: errorChain(error) }) });
+                    this.markDirty();
+                });
+                break;
+            case 'fix':
+                void this.runFixCommand(arg).catch((error) => {
+                    this.pushRow({ kind: 'error', text: t('cmd.failedNamed', { command, error: errorChain(error) }) });
+                    this.markDirty();
+                });
+                break;
             case 'usage':
             case 'balance':
             case 'quota':
@@ -7200,12 +8499,35 @@ export class SshTui {
                                 allowed: this.autoAllowedCount,
                                 denied: this.autoDeniedCount,
                                 reviewed: this.aiReviewCount,
+                                cacheHits: this.cacheHitCount,
+                                cached: this.approvalCache.size,
                             })
                             : t('approval.statusOff'),
                     });
                     this.markDirty();
                     break;
                 }
+                // The cache is the one piece of auto-approval state the user can
+                // inspect and drop on demand: `/approval cache` reports it,
+                // `/approval cache clear` forgets every remembered verdict.
+                if (requested === 'cache' || requested === 'cache clear' || requested === 'cache status') {
+                    if (requested === 'cache clear') {
+                        const dropped = this.approvalCache.clear();
+                        this.pushRow({ kind: 'system', text: t('approval.cacheCleared', { count: dropped }) });
+                    }
+                    else {
+                        this.pushRow({
+                            kind: 'system',
+                            text: t('approval.cacheStatus', {
+                                cached: this.approvalCache.size,
+                                cacheHits: this.cacheHitCount,
+                                minutes: this.approvalCache.ttlMinutes,
+                            }),
+                        });
+                    }
+                    this.markDirty();
+                    break;
+                }
                 const next = requested === 'toggle'
                     ? this.autoApprovalMode === 'auto' ? 'off' : 'auto'
                     : parseAutoApprovalMode(requested);
@@ -7215,6 +8537,9 @@ export class SshTui {
                     break;
                 }
                 this.autoApprovalMode = next;
+                // A remembered verdict belongs to the mode that produced it; leaving
+                // auto mode (or re-entering it) starts from an empty cache.
+                this.approvalCache.clear();
                 void this.mergeUiSettings({ autoApproval: next }).catch((error) => {
                     this.pushRow({ kind: 'error', text: t('cmd.failedNamed', { command: 'approval', error: errorChain(error) }) });
                     this.markDirty();
@@ -7228,6 +8553,12 @@ export class SshTui {
                 this.markDirty();
                 break;
             }
+            case 'preset':
+                void this.runPresetCommand(arg).catch((error) => {
+                    this.pushRow({ kind: 'error', text: t('cmd.failedNamed', { command, error: errorChain(error) }) });
+                    this.markDirty();
+                });
+                break;
             case 'setup':
                 void this.runOnboarding();
                 break;