dsh-ssh-tui 0.7.3 → 0.7.4

package/lib/tui.js

@@ -26,7 +26,7 @@ import { METADATA_FILE, readPresetMetadata } from './preset-compat.js';
 import { credentialRef } from '@deepseek-ai/dsh-credentials';
 import { createUserMessage, errorChain, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { SessionId } from '@deepseek-ai/dsh-session';
-import { commandAcceptsAttachments, forEachSessionEventAsync, hostSettingsGeneration, isTokenDeltaChunk, listenHostEvent, readSettingsSection, REPLAY_YIELD_EVERY, sessionEvents, settingsNamespace, streamChunkOf, streamFirstTokenTime, streamFrameAttemptId, streamFrameOwner, toolResultFailed, } from './dsh-compat.js';
+import { commandAcceptsAttachments, forEachSessionEventAsync, hostSettingsGeneration, isTokenDeltaChunk, listenHostEvent, readSettingsSection, REPLAY_YIELD_EVERY, sessionEvents, settingsNamespace, streamChunkOf, streamFirstTokenTime, streamFrameAttemptId, streamFrameOwner, toolResultFailed, TUI_SOURCE_KIND, } from './dsh-compat.js';
 import { classifyApprovalDetailed, commandForApprovalRequest, isApprovalStatusArg, parseAutoApprovalMode } from './auto-approval.js';
 import { buildReviewUserMessage, parseReviewOutput, reviewSystemPrompt } from './approval-reviewer.js';
 import { loadProviderCatalog, mergeProviderEntries } from './provider-catalog.js';
@@ -59,10 +59,12 @@ import { DEFAULT_SUBAGENT_MODEL, SUBAGENT_SETTINGS_NAMESPACE, defaultSubagentMod
 import { resolveFreshSuperGrokToken } from './supergrok-token.js';
 import { copyTextFromRow, copyTextFromTranscript } from './copy-text.js';
 import { displayToolName, subagentCourtesyName } from './job-label.js';
+import { clearWaitingMarker, notifyCommand, notifyTargetCommand, notifyTargetLabel, parseNotifyTarget, runNotify, writeWaitingMarker, } from './question-wait.js';
+import { changesFileLine, changesHeader, changesRemainderLine, changesSummaryVisible, renderChangesDiff, workspaceChangesOf, } from './workspace-changes.js';
 import { UserQuestionError, } from '@deepseek-ai/dsh-user-questions';
 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 { captureHangupSignals, advancePaintedRows, composePaintFrame, composePaintOutput, frameByteBudget, detectSshSession, formatLinkQualityChip, HANGUP_CANCEL_TIMEOUT_MS, ignoreFurtherHangupSignals, isEscapePrefix, isHangupErrno, linkQualityOf, parseCursorPositionReply, PICKER_WINDOW, pickerWindowStart, probeTerminalRttMs, releaseHangupSignals, resolvePaintIntervalMs, toolBodyLineLimit, waitUntilIdleOrTimeout, RTT_HISTORY, medianRtt, } from './paint.js';
 import { TerminalInputGuard } from './terminal-input.js';
 import { contextPressureAlertText, contextPressureRingColor, contextPressureView, formatContextPressureRing, describeProviderRoute, fitFooterChips, fitFooterStatusLine, footerActivity, footerHealthChip, footerIdentityParts, footerSubagentForeign, paintFooterSubagentChip, footerStatsGroups, formatContextPressureChip, providerHasQuotaSurface, formatStatusReport, shortQuotaPlanName, 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, preferredQuotaWindow, quotaAlertText, quotaRefreshEverySteps, reasoningEffortsForDefault, SUPERGROK_BILLING_URL, tightestQuotaWindow, } from './quota.js';
@@ -445,6 +447,25 @@ const DEEPSEEK_LOGO_VARIANTS = [
         ],
     },
 ];
+/**
+ * What marks the row the card cursor is on.
+ *
+ * The card headers spell `▶ ` themselves; a reply is drawn by the markdown
+ * renderer, so its marker is prepended and its width is measured from this
+ * string (three cells, or two once the ASCII fallback has rewritten it).
+ */
+const REPLY_FOCUS_MARKER = '▶ ';
+/**
+ * The text an inspect overlay hands to the copy key: what the overlay shows.
+ *
+ * The overlays are the one place the copy key can be pressed without leaving
+ * them (a dialog covers the input line), so the body on screen is what "copy"
+ * means there — not the card row that opened it, which for a changes card is a
+ * file list and for a tool card a summary the reader has already scrolled past.
+ */
+function inspectCopyText(lines) {
+    return lines.map(line => line.text).join('\n').replace(/\s+$/u, '');
+}
 export function parseDisconnectPolicy(raw) {
     const id = raw.trim().toLowerCase();
     if (id === 'pause' || id === 'cancel' || id === '暂停')
@@ -626,6 +647,7 @@ export class SshTui {
     relayRows;
     onHangup;
     onReattach;
+    onDetach;
     renderTimer;
     decoder = new StringDecoder('utf8');
     color;
@@ -728,6 +750,15 @@ export class SshTui {
     inputGuard = new TerminalInputGuard(text => this.handleInputText(text));
     thinkingStartedAt;
     waitStartedAt;
+    /**
+     * Whether the running turn produced anything a person can read: reply text or
+     * a tool card. A turn that ends with thinking only is the upstream returning
+     * an empty stop, and painting 完成 for it reads as a finished answer — see
+     * the hint at `turn/end`.
+     */
+    turnSawOutput = false;
+    /** Whether the turn produced thinking, which the empty-stop hint names. */
+    turnSawReasoning = false;
     completionSignaled = false;
     replaying = false;
     /** Display-line budget for the first paint after resume; 0 = full transcript. */
@@ -781,10 +812,22 @@ export class SshTui {
     detachedDeniedCount = 0;
     /** Questions waiting for a display right now — their cards do not exist yet. */
     queuedQuestions = 0;
+    /** When the current detached wait began, so the reconnect can say how long. */
+    questionWaitSince;
     paintIntervalMs;
     paintLink = 'local';
+    /**
+     * Whether this process runs inside an SSH session, from the sshd environment.
+     *
+     * Distinct from `paintLink`, which `applyProbedRtt` pins to `'ssh'` for any
+     * relayed frame — a local window included. Only this flag says the capability
+     * table described a remote tty rather than the terminal the bytes reach.
+     */
+    sshSession = false;
     paintProbed = false;
     paintRttMs;
+    /** The last few measured round-trips; the chip and the budget use their median. */
+    paintRttHistory = [];
     sessionTitle = '';
     llmRetry;
     quotaSnapshot;
@@ -833,6 +876,7 @@ export class SshTui {
         this.onRouteSettled = config.onRouteSettled;
         this.onHangup = config.onHangup;
         this.onReattach = config.onReattach;
+        this.onDetach = config.onDetach;
         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
@@ -844,7 +888,13 @@ export class SshTui {
         this.presetName = presetLabel(this.presetId, config.presetName, config.presetTrust);
         this.terminalCaps = config.terminalCaps ?? terminalCapabilities();
         this.useAlternateScreen = !this.lineMode && this.terminalCaps.alternateScreen;
-        this.paintLink = detectSshSession() ? 'ssh' : 'local';
+        // Whether this process is inside an SSH session, kept apart from
+        // `paintLink`: that one also becomes `'ssh'` whenever the launcher relayed
+        // the frame (see `applyProbedRtt`), which is true for a purely local window
+        // too. This field answers the narrower question the clipboard caveat needs —
+        // "is the terminal the capability table described the one the bytes reach".
+        this.sshSession = detectSshSession();
+        this.paintLink = this.sshSession ? 'ssh' : 'local';
         this.paintIntervalMs = resolvePaintIntervalMs(config.paintIntervalMs, process.env, {
             ssh: this.paintLink === 'ssh',
         });
@@ -1013,7 +1063,7 @@ export class SshTui {
                 return;
             this.pushRow({ kind: 'system', text: t('update.installing', { latest: info.latest }) });
             this.markDirty();
-            const result = await installPluginLatest(info.profile);
+            const result = await installPluginLatest(info.profile, info.latest);
             if (this.disposed)
                 return;
             if (result.ok) {
@@ -1687,7 +1737,7 @@ export class SshTui {
     /** `/fix <row>`: repair one named roster row of the profile patch. */
     async runFixCommand(arg) {
         const name = arg.trim().toLowerCase();
-        const row = ALL_ROSTER_ROWS.find(candidate => candidate.id === name || candidate.name.toLowerCase() === name);
+        const row = ALL_ROSTER_ROWS.find(candidate => candidate.id === name || (candidate.name ?? '').toLowerCase() === name);
         if (row === undefined) {
             this.pushRow({
                 kind: 'error',
@@ -1795,6 +1845,11 @@ export class SshTui {
             return true;
         if (this.compactionRunning())
             return true;
+        // A question queued for an answer that has not come. The turn itself has
+        // settled, so nothing else here counts it, and the idle exit would otherwise
+        // kill the Host while it is the only thing still holding that question.
+        if (this.queuedQuestions > 0)
+            return true;
         return false;
     }
     /**
@@ -1831,6 +1886,13 @@ export class SshTui {
         this.reattachedDuringHangup = false;
         ignoreFurtherHangupSignals();
         this.detachDisplay();
+        // Say "no display" now rather than after the cancel/flush below. The lock's
+        // `attached` is what a resume reads to decide that another window is on this
+        // session, and for the whole cancel window it was still set while the window
+        // was already gone — so a reconnect inside that window was refused as
+        // "already attached". A reattach during this hangup patches it back (and the
+        // writes are serialized launcher-side, so the last one wins).
+        await this.onDetach?.();
         const busy = this.isBusyForHangupKeepalive();
         const pauseTurn = this.disconnectPolicy !== 'continue';
         if (pauseTurn && this.agent.status === 'running') {
@@ -1855,6 +1917,11 @@ export class SshTui {
             return;
         }
         const keepHost = this.displayHost !== undefined && busy;
+        if (!keepHost) {
+            // The Host is about to exit, and a marker left behind would keep saying a
+            // question is waiting after the process that held it is gone.
+            void clearWaitingMarker(String(this.agent.id));
+        }
         if (keepHost) {
             this.hangingUp = false;
             // A relay that arrived while this hangup was unwinding set
@@ -2044,6 +2111,9 @@ export class SshTui {
             parts.push(t('attach.awayDetached', { count: detached }));
         if (waiting > 0)
             parts.push(t('attach.awayWaiting', { count: waiting }));
+        if (waiting > 0 && this.questionWaitSince !== undefined) {
+            parts.push(t('attach.questionWaited', { waited: formatShortDuration(Date.now() - this.questionWaitSince) }));
+        }
         if (parts.length === 0)
             return;
         this.pushRow({
@@ -2107,18 +2177,38 @@ export class SshTui {
     currentDisconnectPolicy() {
         return this.disconnectPolicy;
     }
+    /** The paint cadence in force right now: the link tier the footer shows. */
+    currentPaintIntervalMs() {
+        return this.paintIntervalMs;
+    }
     applyProbedRtt(rttMs) {
         const envOverride = Number.parseInt(process.env.DSH_TUI_PAINT_MS ?? '', 10);
         this.paintLink = 'ssh';
-        // A reattach whose probe missed its window reports "unknown"; the link has
-        // not changed, so dropping a measurement we already have just blanks the
-        // footer chip to four hollow circles. Keep it (the next attach re-measures).
-        if (rttMs === undefined && this.paintProbed && this.paintRttMs !== undefined)
-            return;
-        this.paintProbed = rttMs !== undefined;
-        this.paintRttMs = rttMs;
+        if (rttMs !== undefined) {
+            // The relay re-measures the link on its own cadence, so this is called
+            // again and again over one session. The reported round-trip is the median
+            // of the last few measurements: a single burst that reads like a
+            // 2-second link must not pin the footer chip — and with it the paint
+            // cadence and the per-frame byte budget — while two measurements that
+            // agree move it at once. That is the fix for a link that was red from the
+            // first second to the last: the first measurement is taken while the
+            // session is still booting, and it used to be the only one ever taken.
+            this.paintRttHistory.push(rttMs);
+            if (this.paintRttHistory.length > RTT_HISTORY)
+                this.paintRttHistory.shift();
+            this.paintProbed = true;
+            this.paintRttMs = medianRtt(this.paintRttHistory);
+        }
+        else if (!this.paintProbed) {
+            // A probe that missed its window reports "unknown". A link that was never
+            // measured (a pipe, a terminal that does not answer DSR) stays unknown and
+            // keeps the unprobed wording; one that has a measurement keeps its number
+            // rather than blanking the chip to four hollow circles after every
+            // auto-reconnect.
+            this.paintRttMs = undefined;
+        }
         if (!(Number.isFinite(envOverride) && envOverride > 0)) {
-            this.paintIntervalMs = resolvePaintIntervalMs(undefined, {}, { ssh: true, rttMs });
+            this.paintIntervalMs = resolvePaintIntervalMs(undefined, {}, { ssh: true, rttMs: this.paintRttMs });
             if (!this.lineMode)
                 this.startRenderTimer();
         }
@@ -2195,7 +2285,8 @@ export class SshTui {
                 || row.kind === 'plan'
                 || row.kind === 'question'
                 || row.kind === 'goal'
-                || row.kind === 'compaction');
+                || row.kind === 'compaction'
+                || row.kind === 'changes');
             for (const burst of compactToolBursts(this.rows)) {
                 const callAnchor = burst.groups.calls.at(-1);
                 const editAnchor = burst.groups.edits.at(-1);
@@ -2213,13 +2304,35 @@ export class SshTui {
             || row.kind === 'question'
             || row.kind === 'goal'
             || row.kind === 'compaction'
-            || row.kind === 'prompt');
+            || row.kind === 'prompt'
+            || row.kind === 'changes');
         if (this.streaming !== undefined && this.streaming.reasoning !== '') {
             this.streamingReasoning ??= { kind: 'streaming-reasoning', expanded: false };
             rows.push(this.streamingReasoning);
         }
         return rows;
     }
+    /**
+     * Everything the card cursor walks, in transcript order: the collapsible
+     * cards plus the model replies.
+     *
+     * Built from the two lists rather than from the rows alone, because one of the
+     * collapsible entries is synthetic: the live thinking block exists only while a
+     * turn streams and is never a member of `this.rows`. Filtering the rows (the
+     * first version of this) silently dropped it out of the cursor walk — ↑ on a
+     * turn that had only streamed thinking did nothing, and Enter could no longer
+     * expand the card being written. It belongs at the end, which is where it is
+     * painted, so anything not in the rows is appended.
+     */
+    focusRing() {
+        const collapsible = this.collapsibleRows();
+        const ring = this.rows.filter(row => row.kind === 'assistant' || collapsible.includes(row));
+        const known = new Set(this.rows);
+        for (const row of collapsible)
+            if (!known.has(row))
+                ring.push(row);
+        return ring;
+    }
     spinnerFrame(periodMs = 120) {
         return SPINNER[Math.floor(Date.now() / periodMs) % SPINNER.length] ?? '⠋';
     }
@@ -2357,7 +2470,7 @@ export class SshTui {
         // instruction that used to paint as `❯ …`.
         const message = createUserMessage({
             content: [{ type: 'text', text }],
-            source: { kind: 'plugin', plugin: 'dsh-ssh-tui', form: 'notice', summary: queued },
+            source: { kind: TUI_SOURCE_KIND, form: 'notice', summary: queued },
         });
         try {
             this.agent.followup(message);
@@ -2568,7 +2681,10 @@ export class SshTui {
         if (dialog === undefined || dialog.kind !== 'inspect')
             return;
         const header = this.styleLine('system', truncateToWidth(dialog.title, width));
-        const hint = this.styleLine('system', truncateToWidth(t('tool.inspectHint'), width));
+        // A copy from inside the overlay replaces the key legend for the rest of the
+        // visit: the notice row it also pushes is behind this screen, and a copy the
+        // reader cannot confirm is the one thing worse than no copy at all.
+        const hint = this.styleLine('system', truncateToWidth(dialog.notice ?? t('tool.inspectHint'), width));
         const divider = this.styleLine('system', repeatToWidth('─', width));
         const bodyBudget = Math.max(1, height - 4);
         const rendered = [];
@@ -2645,6 +2761,7 @@ export class SshTui {
             title,
             lines,
             offset: 0,
+            copyText: inspectCopyText(lines),
         });
     }
     openSubagentInspect(row) {
@@ -2652,6 +2769,8 @@ export class SshTui {
         if (dialog?.kind === 'inspect' && dialog.subagentSessionId === this.subagentInspectId(row)) {
             dialog.title = t('sub.inspectTitle', { title: subagentDisplayName(row) });
             dialog.lines = subagentInspectLines(row);
+            dialog.copyText = inspectCopyText(dialog.lines);
+            dialog.notice = undefined;
             this.markDirty();
             return;
         }
@@ -2665,8 +2784,36 @@ export class SshTui {
             lines,
             offset: 0,
             subagentSessionId: this.subagentInspectId(row),
+            copyText: inspectCopyText(lines),
         });
     }
+    /**
+     * Read one reply full-screen.
+     *
+     * What Enter does on a selected reply: a reply has no body to fold away, and
+     * the transcript wraps it to the window — which for a long answer with tables
+     * or code blocks is not how it reads. The overlay is the same surface the tool
+     * cards use, and the copy key works inside it, so "read it, then copy it"
+     * needs no trip back through the timeline.
+     */
+    openReplyInspect(row) {
+        // Line mode has no scroller, and `echoInspectToLog` would append the reply
+        // to the log a second time — it is already there, in full. Nothing to open.
+        if (this.lineMode)
+            return;
+        // `- 2`, matching `paintInspectOverlay`, which re-wraps every body line at
+        // `width - 2` inside a two-space indent: rendered wider, long table and code
+        // rows were re-wrapped mid-cell at narrow widths.
+        const width = Math.max(20, this.screenColumns() - 2);
+        // Plain: `styleLine` strips escapes, so a coloured render would lose its
+        // styling anyway — and the overlay's own frame supplies the base style.
+        const lines = renderMarkdownLines(row.text, width, false, false)
+            .map(line => ({ kind: 'assistant', text: line }));
+        const title = t('reply.inspectTitle', { lines: lines.length });
+        if (this.echoInspectToLog(title, lines))
+            return;
+        this.openDialog({ kind: 'inspect', title, lines, offset: 0, copyText: row.text });
+    }
     /**
      * Line mode has no framed scroller, so an inspect body goes into the log.
      *
@@ -2711,9 +2858,27 @@ export class SshTui {
             addDisplay(this.selectLine(styled, focused), row);
         }
     }
-    /** Move the expand/collapse focus among reasoning and tool rows. */
-    moveCollapsibleFocus(delta) {
-        const rows = this.collapsibleRows();
+    /**
+     * Which file line of an expanded changes card the screen cursor is on.
+     *
+     * The card paints its header, then one row per file, and `selectableLines`
+     * holds exactly the viewport. The cursor sits on the input row unless the
+     * reader scrolled, so the file is how many painted rows above the cursor the
+     * card's header is. A cursor on the header, the remainder line, or the prompt
+     * falls back to the first file, which is the only defensible guess.
+     */
+    changesFileIndex(row) {
+        const painted = this.selectableLines.findIndex(line => line.ref === row);
+        if (painted < 0)
+            return 0;
+        const index = this.lastPaintCursorRow - 1 - (this.lastTranscriptStart + painted);
+        if (index < 1 || index > row.files.length)
+            return 0;
+        return index - 1;
+    }
+    /** Move the card cursor among the cards and the replies. */
+    moveFocus(delta) {
+        const rows = this.focusRing();
         if (rows.length === 0)
             return;
         if (this.focusedRow === null) {
@@ -2731,13 +2896,23 @@ export class SshTui {
     }
     /** Toggle the focused block; without focus, toggle the most recent one. */
     toggleCollapsible() {
+        const focused = this.focusedRow;
+        // A reply has no body to fold away, so Enter reads it full-screen instead.
+        // Falling through to the lookup below would be worse than doing nothing:
+        // a reply is not in `collapsibleRows()`, and the fallback is "the newest
+        // card" — Enter on a selected reply would expand a card the reader never
+        // picked.
+        if (focused !== null && focused.kind === 'assistant') {
+            this.openReplyInspect(focused);
+            return;
+        }
         const rows = this.collapsibleRows();
         if (rows.length === 0)
             return;
-        const focused = this.focusedRow !== null && rows.includes(this.focusedRow)
-            ? this.focusedRow
+        const inRing = focused !== null && rows.includes(focused)
+            ? focused
             : undefined;
-        const target = focused ?? rows[rows.length - 1];
+        const target = inRing ?? rows[rows.length - 1];
         if (target === undefined)
             return;
         this.toggleCard(target);
@@ -2758,6 +2933,14 @@ export class SshTui {
         return !toolBodyFitsWorkspace(wrappedToolBodyLineCount(body, width), this.workspaceRowsFor(width, height));
     }
     toggleCard(target) {
+        // A changes card opens its file list first; the next Enter reads the file
+        // the cursor is on. With one file there is nothing to choose, so that Enter
+        // opens it directly.
+        if (target.kind === 'changes' && target.expanded && target.files.length > 0) {
+            this.focusedRow = target;
+            this.openChangesInspect(target, target.files.length === 1 ? 0 : this.changesFileIndex(target));
+            return;
+        }
         if (target.kind === 'subagent') {
             this.focusedRow = target;
             this.openSubagentInspect(target);
@@ -2782,11 +2965,14 @@ export class SshTui {
         const rows = this.collapsibleRows();
         if (rows.length === 0)
             return;
+        // Ctrl+R acts on the cards; a selected reply is not one, and it must survive
+        // the sweep either way (it was not collapsed, so it must not be deselected).
+        const selected = this.focusedRow?.kind === 'assistant' ? this.focusedRow : undefined;
         const allExpanded = rows.every(row => row.expanded);
         if (allExpanded) {
             for (const row of rows)
                 row.expanded = false;
-            this.focusedRow = null;
+            this.focusedRow = selected ?? null;
         }
         else {
             const width = Math.max(10, this.screenColumns());
@@ -2802,7 +2988,7 @@ export class SshTui {
                 }
                 row.expanded = true;
             }
-            this.focusedRow = rows[rows.length - 1] ?? null;
+            this.focusedRow = selected ?? rows[rows.length - 1] ?? null;
         }
         this.forceFullPaint = true;
         this.markDirty();
@@ -2866,6 +3052,14 @@ export class SshTui {
             this.focusedRow = row;
             this.forceFullPaint = true;
         }
+        else if (row.kind === 'assistant') {
+            // A reply has nothing to expand, but revealing it must leave it selected:
+            // Alt+4 and `/find 回复` land here, and clearing the focus (which is what
+            // this branch used to do) meant `/copy` afterwards only worked by falling
+            // back to "the latest reply" — silently, and only when it happened to be
+            // the same row.
+            this.focusedRow = row;
+        }
         else {
             this.focusedRow = null;
         }
@@ -2964,14 +3158,39 @@ export class SshTui {
         }
         const display = [];
         const displayRefs = [];
+        // Cells at the start of each painted line that are chrome rather than text.
+        // Only the focus marker has any, and the drag-selection needs to know how
+        // many so a copy off the selected row does not paste the marker.
+        const displayGutters = [];
         const searchHit = this.searchHits[this.searchIndex];
-        const addDisplay = (line, ref) => {
+        const addDisplay = (line, ref, gutter = 0) => {
             display.push(clipAnsiToWidth(line, width));
             displayRefs.push(ref);
+            displayGutters.push(gutter);
         };
         const pushRow = (kind, text, ref) => {
             if (kind === 'assistant') {
-                for (const line of renderMarkdownLines(text, width, this.color, this.terminalCaps.osc8)) {
+                const focused = ref !== undefined && this.focusedRow === ref;
+                // The same string the card headers use, so the ASCII fallback rewrites
+                // both alike, and the width comes from it rather than from a constant
+                // (in ASCII `▶` becomes `> `, and the marker is still three cells).
+                const marker = sanitizeTerminalText(REPLY_FOCUS_MARKER);
+                const gutter = displayWidth(marker);
+                // A focused reply is rendered three cells narrower so the marker cannot
+                // eat its last characters: painted at full width and then prefixed, the
+                // tail of every one of its lines was clipped away silently (the card
+                // headers avoid this by truncating to the same kind of margin).
+                const inner = focused ? Math.max(1, width - gutter) : width;
+                let placed = false;
+                for (const line of renderMarkdownLines(text, inner, this.color, this.terminalCaps.osc8)) {
+                    // The marker goes on the first line that has something on it: a reply
+                    // starting with a blank line would otherwise carry a marker all by
+                    // itself, with the reader's selection nowhere near its text.
+                    if (focused && !placed && stripAnsi(line).trim() !== '') {
+                        addDisplay(`${marker}${line}`, ref, gutter);
+                        placed = true;
+                        continue;
+                    }
                     addDisplay(line, ref);
                 }
                 return;
@@ -3188,6 +3407,18 @@ export class SshTui {
                 }
                 continue;
             }
+            if (row.kind === 'changes') {
+                const header = `${row.header}${row.expanded ? '' : t('card.expand')}`;
+                this.paintCollapsibleHeader(addDisplay, row, 'tool', header, width);
+                if (row.expanded) {
+                    for (const file of row.files) {
+                        addDisplay(this.styleLine('tool-result', `    ${file}`), row);
+                    }
+                    if (row.more !== undefined)
+                        addDisplay(this.styleLine('system', `    ${row.more}`), row);
+                }
+                continue;
+            }
             if (row.kind === 'compaction') {
                 const running = row.status === 'running';
                 const spinner = running ? ` ${this.spinnerFrame()}` : '';
@@ -3575,6 +3806,10 @@ export class SshTui {
         const start = window.start;
         const visible = window.visibleLines;
         const visibleRefs = window.visibleRefs;
+        // `padding` blank rows are unshifted when the transcript is shorter than the
+        // window, so the gutter of a visible line is read off the same offset the
+        // window itself used (negative before the transcript starts → 0).
+        const visibleGutters = visible.map((_, index) => displayGutters[start + index - window.padding] ?? 0);
         this.clickableRows.clear();
         this.paintedLinkHitsByRow.clear();
         this.transcriptTopScreenY = headerLines.length + 1;
@@ -3586,6 +3821,7 @@ export class SshTui {
             // 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',
+            gutter: visibleGutters[index] ?? 0,
         }));
         for (let index = 0; index < visibleRefs.length; index++) {
             const ref = visibleRefs[index];
@@ -4533,6 +4769,13 @@ export class SshTui {
         this.lastActivity = Date.now();
         if (!this.replaying)
             this.refreshContextPressure();
+        // Before the switch, and by string: `workspace/changes` is not a key of the
+        // 0.1.5 `SessionEventMap`, so a `case` for it fails strict compilation on
+        // that tree. A Host without the service records nothing and this returns.
+        if (String(event.type) === 'workspace/changes') {
+            this.noteWorkspaceChanges(session.id, event.seq);
+            return;
+        }
         switch (event.type) {
             case 'user/message': {
                 const text = event.data.content
@@ -4547,7 +4790,7 @@ export class SshTui {
                         if (!this.replaying)
                             this.beginWait();
                     }
-                    else if (sourceKind === 'plugin' && source.form === 'notice') {
+                    else if (source.form === 'notice') {
                         const summary = source.summary?.trim() ?? '';
                         // Body stays off the workspace (the model still received it).
                         const last = this.rows.at(-1);
@@ -4564,12 +4807,17 @@ export class SshTui {
                         if (!this.replaying)
                             this.beginWait();
                     }
+                    else if (source.form === 'snapshot') {
+                        // `form` is the ContextFormed discriminator every producer shares,
+                        // while `kind` is now per-producer (0.1.7 has no catch-all), so the
+                        // two content branches above key on the form: keying them on the
+                        // released `plugin` kind dropped a `time-context` snapshot — and
+                        // this plugin's own notices — into the raw-context row below.
+                        this.pushRow({ kind: 'system', text: text });
+                    }
                     else if (isPromptInjectionMessage(sourceKind, text, source.plugin)) {
                         this.pushPromptInjection(text, source.plugin);
                     }
-                    else if (sourceKind === 'plugin' && source.form === 'snapshot') {
-                        this.pushRow({ kind: 'system', text: text });
-                    }
                     else {
                         this.pushRow({ kind: 'system', text: t('prompt.contextPrefix', { text }) });
                     }
@@ -4610,7 +4858,10 @@ export class SshTui {
                 if (reasoning !== '') {
                     this.pushRow({ kind: 'reasoning', text: `${reasoning}${interruptedMark}`, expanded: reasoningExpanded });
                 }
+                if (reasoning !== '')
+                    this.turnSawReasoning = true;
                 if (text !== '') {
+                    this.turnSawOutput = true;
                     this.pushRow({ kind: 'assistant', text: `${text}${interruptedMark}` });
                 }
                 else if (interrupted && reasoning === '') {
@@ -4620,6 +4871,7 @@ export class SshTui {
                 break;
             }
             case 'tool/call': {
+                this.turnSawOutput = true;
                 this.openToolCalls.set(String(event.data.callId), event.data.name);
                 this.toolCallNames.set(String(event.data.callId), event.data.name);
                 this.statsTracker.noteToolStart(String(event.data.callId), event.time);
@@ -4803,6 +5055,8 @@ export class SshTui {
                 break;
             case 'turn/start':
                 this.stalledWarningShown = false;
+                this.turnSawOutput = false;
+                this.turnSawReasoning = false;
                 this.llmRetry = undefined;
                 this.status = `turn ${event.data.turn} running`;
                 // A turn is about to spend on this route: make sure the session's record
@@ -4841,6 +5095,17 @@ export class SshTui {
                 if (reason.kind === 'error') {
                     this.pushRow({ kind: 'error', text: t('turn.failed', { turn: event.data.turn, error: reason.error.message }) });
                 }
+                if (reason.kind === 'completed' && !this.replaying && !this.turnSawOutput) {
+                    // The provider ended the turn without an answer. Some gateways map a
+                    // Gemini/Claude reply that only contains a thought part onto
+                    // `reasoning_content` and then finish with stop and no content, so the
+                    // turn looks completed while nothing was said and the user is left to
+                    // guess that another Enter is what continues it. Say so instead.
+                    this.pushRow({
+                        kind: 'system',
+                        text: t(this.turnSawReasoning ? 'turn.emptyThinkingOnly' : 'turn.emptyReply'),
+                    });
+                }
                 const livePlan = this.findLivePlanRow();
                 if (livePlan !== undefined && reason.kind === 'completed') {
                     applyTurnEndToPlan(livePlan);
@@ -4926,6 +5191,100 @@ export class SshTui {
         this.status = 'disposed';
         this.markDirty();
     };
+    /**
+     * One `workspace/changes` event: the files a turn changed.
+     *
+     * The event carries only the turn number; the summary stays on the Host and
+     * is served by `workspaceChanges` for this event's own sequence, and only
+     * while the Session lives. A missing service (every 0.1.5 Host) or a summary
+     * that can no longer be opened (a log replayed after a restart) shows
+     * nothing — upstream's rule, so a card that cannot be read is never drawn.
+     * A later event for the same turn replaces the earlier summary in place.
+     */
+    noteWorkspaceChanges(sessionId, seq) {
+        if (typeof seq !== 'number')
+            return;
+        const service = workspaceChangesOf(this.ctx);
+        if (service === undefined)
+            return;
+        const summary = service.summary(String(sessionId), seq);
+        if (summary === undefined || !changesSummaryVisible(summary))
+            return;
+        const existing = this.rows.findLast((row) => row.kind === 'changes' && row.turn === summary.turn && row.sessionId === String(sessionId));
+        if (existing !== undefined) {
+            this.fillChangesCard(existing, summary, seq);
+        }
+        else {
+            const row = {
+                kind: 'changes',
+                turn: summary.turn,
+                seq,
+                sessionId: String(sessionId),
+                header: '',
+                files: [],
+                expanded: false,
+            };
+            this.fillChangesCard(row, summary, seq);
+            this.pushRow(row);
+        }
+        this.markDirty();
+    }
+    /** Copy one summary onto its card. Shared by the first event and its replacements. */
+    fillChangesCard(row, summary, seq) {
+        row.seq = seq;
+        row.header = changesHeader(summary);
+        row.files = summary.files.map(changesFileLine);
+        const more = changesRemainderLine(summary);
+        if (more === undefined)
+            delete row.more;
+        else
+            row.more = more;
+    }
+    /**
+     * Full view of one file on a changes card: its comparison, as the service
+     * computed it. Binary and oversized files have no lines, so the overlay
+     * carries the one-line explanation instead of an empty body.
+     */
+    openChangesInspect(row, index) {
+        const service = workspaceChangesOf(this.ctx);
+        const label = row.files[index] ?? row.header;
+        const title = t('changes.inspectTitle', { file: label });
+        if (service === undefined) {
+            this.openChangesInspectLines(title, [{ kind: 'tool-result', text: t('changes.unavailable') }]);
+            return;
+        }
+        const controller = new AbortController();
+        void service.diff(row.sessionId, row.seq, index, controller.signal)
+            .then(diff => {
+            const lines = renderChangesDiff(diff);
+            this.openChangesInspectLines(title, lines.length > 0
+                ? lines
+                : [{ kind: 'tool-result', text: t('changes.unavailable') }]);
+        })
+            .catch(() => {
+            this.openChangesInspectLines(title, [{ kind: 'tool-result', text: t('changes.unavailable') }]);
+        });
+    }
+    /** Open (or replace) the changes overlay, or echo it to the log in line mode. */
+    openChangesInspectLines(title, lines) {
+        if (this.echoInspectToLog(title, lines))
+            return;
+        const dialog = this.dialog;
+        if (dialog?.kind === 'inspect') {
+            dialog.title = title;
+            dialog.lines = lines;
+            dialog.offset = 0;
+            // The dialog may be a leftover from another overlay, and this path is
+            // asynchronous: a reply overlay opened while the diff was being read would
+            // keep its `copyText`, so the copy key would hand back the reply under a
+            // diff. Everything the previous body owned is replaced here.
+            dialog.copyText = inspectCopyText(lines);
+            dialog.notice = undefined;
+            this.markDirty();
+            return;
+        }
+        this.openDialog({ kind: 'inspect', title, lines, offset: 0, copyText: inspectCopyText(lines) });
+    }
     /** Plan-mode / command / team events that plugins merge into SessionEventMap. */
     handleExtensionEvent(event) {
         const type = String(event.type);
@@ -5647,6 +6006,10 @@ export class SshTui {
             return;
         dialog.title = t('sub.inspectTitle', { title: subagentDisplayName(row) });
         dialog.lines = subagentInspectLines(row);
+        // The body grows while the child runs, and the copy text is that body: it
+        // has to move with it or the key hands back the log as it stood when the
+        // overlay opened.
+        dialog.copyText = inspectCopyText(dialog.lines);
     }
     // ── approval and questions ──────────────────────────────────────────────
     hasLiveDisplay() {
@@ -5656,6 +6019,64 @@ export class SshTui {
             return this.displayHost?.attached === true;
         return true;
     }
+    /**
+     * Tell the absent user that a question is waiting.
+     *
+     * The marker file is the part that needs no configuration: it sits next to the
+     * session's stderr log, so logging back into the jump host shows it before the
+     * TUI is open. The command is whatever the user pointed `ssh-tui.notify` at,
+     * run once; it never blocks the wait and never reports its own failure.
+     */
+    announceWaitingQuestion(request) {
+        const sessionId = String(this.agent.id);
+        const question = request.questions
+            .map(item => item.question.trim())
+            .filter(text => text !== '')
+            .join(' / ')
+            .slice(0, 200);
+        const since = this.questionWaitSince ?? Date.now();
+        void writeWaitingMarker({
+            sessionId,
+            count: this.queuedQuestions,
+            question,
+            since,
+        });
+        const command = this.readNotifyCommand();
+        if (command === undefined)
+            return;
+        const smtp = this.readNotifySmtp();
+        const context = {
+            sessionId,
+            count: this.queuedQuestions,
+            question,
+            waitedMs: Date.now() - since,
+            resumeCommand: `dsh --profile ${profileFromArgv()} --resume ${sessionId}`,
+            ...(smtp.user === undefined ? {} : { smtpUser: smtp.user }),
+            ...(smtp.password === undefined ? {} : { smtpPassword: smtp.password }),
+        };
+        void runNotify(command, context);
+    }
+    /** The SMTP account `/notify smtp` saved, when the target is authenticated. */
+    readNotifySmtp() {
+        const raw = readSettingsSection(this.ctx, UI_LOCALE_NAMESPACE);
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+            return {};
+        const saved = raw;
+        const user = typeof saved.notifySmtpUser === 'string' ? saved.notifySmtpUser : undefined;
+        const password = typeof saved.notifySmtpPassword === 'string' ? saved.notifySmtpPassword : undefined;
+        return {
+            ...(user === undefined || user === '' ? {} : { user }),
+            ...(password === undefined || password === '' ? {} : { password }),
+        };
+    }
+    /** `DSH_TUI_NOTIFY`, else the saved `ssh-tui.notify`. Empty means off. */
+    readNotifyCommand() {
+        const raw = readSettingsSection(this.ctx, UI_LOCALE_NAMESPACE);
+        const saved = raw !== null && typeof raw === 'object' && !Array.isArray(raw)
+            ? raw.notify
+            : undefined;
+        return notifyCommand(process.env, typeof saved === 'string' ? saved : undefined);
+    }
     waitForLiveDisplay(signal) {
         if (this.hasLiveDisplay())
             return Promise.resolve();
@@ -5792,7 +6213,7 @@ export class SshTui {
                                 ...(request.reason === undefined || request.reason.trim() === '' ? {} : { reason: request.reason }),
                                 ...(this.hostSandboxMode === undefined || this.hostSandboxMode.trim() === '' ? {} : { sandboxMode: this.hostSandboxMode }),
                             }) }],
-                    source: { kind: 'plugin', plugin: 'dsh-ssh-tui' },
+                    source: { kind: TUI_SOURCE_KIND },
                 })],
             system: reviewSystemPrompt(getLocale()),
             maxTokens: 400,
@@ -5874,6 +6295,10 @@ export class SshTui {
      * `the user rejected tool "bash"`. Steer a plugin notice with the real
      * classifier/reviewer reason. Summary matches the workspace decision row
      * so the handler does not paint the body twice.
+     *
+     * This notice is committed to the session, so it is exactly the injection a
+     * V4 log refuses when it wears the released `plugin` wrapper — see
+     * {@link TUI_SOURCE_KIND}.
      */
     tellModelApprovalDenied(command, reason, summary) {
         if (this.replaying || this.agentGone)
@@ -5881,7 +6306,7 @@ export class SshTui {
         const text = t('approval.modelDenied', { command, reason });
         const message = createUserMessage({
             content: [{ type: 'text', text }],
-            source: { kind: 'plugin', plugin: 'dsh-ssh-tui', form: 'notice', summary },
+            source: { kind: TUI_SOURCE_KIND, form: 'notice', summary },
         });
         try {
             if (this.agent.status === 'running')
@@ -5991,11 +6416,20 @@ export class SshTui {
             // 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;
+            this.questionWaitSince ??= Date.now();
+            // The user learns about the wait from a marker file and, when they
+            // configured one, a command. Both run after the counter moves, so a
+            // reconnect during either still sees the question as queued.
+            this.announceWaitingQuestion(request);
             try {
                 await this.waitForLiveDisplay(request.signal);
             }
             finally {
                 this.queuedQuestions -= 1;
+                if (this.queuedQuestions === 0) {
+                    this.questionWaitSince = undefined;
+                    void clearWaitingMarker(String(this.agent.id));
+                }
             }
         }
         const answers = [];
@@ -7561,6 +7995,44 @@ export class SshTui {
         this.pushRow({ kind: 'system', text: t('view.switched', { name: next === 'compact' ? t('view.compact') : t('view.detailed') }) });
         this.markDirty();
     }
+    /**
+     * /notify: where a question waiting on an absent user is announced.
+     *
+     * No argument shows what is configured. `off` clears it. `mail`, `smtp` and
+     * `local` store the command that target needs; the SMTP password is kept
+     * beside it and handed to the command through the environment, so it is never
+     * part of the command string.
+     */
+    async runNotifyCommand(arg) {
+        const target = parseNotifyTarget(arg);
+        if (target === undefined) {
+            this.pushRow({ kind: 'error', text: t('notify.usage') });
+            this.markDirty();
+            return;
+        }
+        if (target.kind === 'off' && arg.trim() === '') {
+            const current = this.readNotifyCommand();
+            this.pushRow({
+                kind: 'system',
+                text: current === undefined ? t('notify.statusOff') : t('notify.statusOn', { command: current }),
+            });
+            this.markDirty();
+            return;
+        }
+        if (target.kind === 'off') {
+            await this.mergeUiSettings({ notify: '', notifySmtpUser: '', notifySmtpPassword: '' });
+            this.pushRow({ kind: 'system', text: t('notify.cleared') });
+            this.markDirty();
+            return;
+        }
+        await this.mergeUiSettings({
+            notify: notifyTargetCommand(target),
+            notifySmtpUser: target.kind === 'smtp' ? target.user ?? '' : '',
+            notifySmtpPassword: target.kind === 'smtp' ? target.password ?? '' : '',
+        });
+        this.pushRow({ kind: 'system', text: t('notify.saved', { target: notifyTargetLabel(target) }) });
+        this.markDirty();
+    }
     /** /disconnect: pause (default) or continue the turn after SSH drop. */
     async runDisconnectCommand(arg) {
         const direct = parseDisconnectPolicy(arg);
@@ -8104,13 +8576,21 @@ export class SshTui {
         // 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);
+        const moved = combined === '' ? undefined : this.keymap.sequences.get(combined);
+        // While a dialog is open its own routing owns the keys — with one exception:
+        // an inspect overlay is the only place the copy key can be pressed at all,
+        // and gating it put the reader's rebound key out of reach exactly where the
+        // overlay's own hint advertises copying.
+        const overlayCopy = this.dialog !== undefined
+            && this.dialog.kind === 'inspect'
+            && (this.dialog.copyText ?? '') !== ''
+            && moved === 'copy';
+        if ((this.dialog === undefined || overlayCopy) && combined !== '') {
             if (moved !== undefined && this.keymap.overridden.has(moved)) {
                 if (this.runKeyAction(moved))
                     return;
             }
-            if (this.keymap.suppressed.has(combined))
+            if (this.dialog === undefined && this.keymap.suppressed.has(combined))
                 return;
         }
         const escape = /^\x1b\[([A-D])$/u;
@@ -8135,7 +8615,7 @@ export class SshTui {
                         this.markDirty();
                     }
                     else if (this.input === '' && this.collapsibleRows().length > 0) {
-                        this.moveCollapsibleFocus(-1);
+                        this.moveFocus(-1);
                     }
                     else {
                         this.historyBack();
@@ -8159,7 +8639,7 @@ export class SshTui {
                         this.markDirty();
                     }
                     else if (this.input === '' && this.collapsibleRows().length > 0) {
-                        this.moveCollapsibleFocus(1);
+                        this.moveFocus(1);
                     }
                     else {
                         this.historyForward();
@@ -8187,19 +8667,23 @@ export class SshTui {
                     this.scrollInspectOrTranscript(-3);
                     return;
                 }
-                // 32 is "motion with the left button held": a drag over a reply.
-                if (button === 32) {
+                // 32 is "motion with the left button held": a drag over a reply. Shift
+                // adds 4 to every button code, and a terminal that still forwards the
+                // report while Shift is down (instead of keeping it for its own
+                // selection) must drag exactly like an unshifted one — otherwise the
+                // gesture the user was told to fall back on does nothing here.
+                if (button === 32 || button === 36) {
                     this.extendMouseSelection(y, x);
                     return;
                 }
-                if (button === 0) {
+                if (button === 0 || button === 4) {
                     this.beginMouseSelection(y, x);
                     return;
                 }
                 return;
             }
             // A release ends either a drag (copy what it covered) or a plain click.
-            if (button === 0)
+            if (button === 0 || button === 4)
                 this.endMouseSelection(y, x);
             return;
         }
@@ -8432,13 +8916,20 @@ export class SshTui {
                 this.input = this.input.slice(0, this.cursor);
                 this.markDirty();
                 return;
+            // A dialog owns the keyboard while it is up: moving the transcript cursor
+            // under it changed what a later copy would take while the screen showed
+            // nothing of the sort.
             case '\x0e':
-                this.moveCollapsibleFocus(1);
+                if (this.dialog === undefined)
+                    this.moveFocus(1);
                 return;
             case '\x10':
-                this.moveCollapsibleFocus(-1);
+                if (this.dialog === undefined)
+                    this.moveFocus(-1);
                 return;
             case '\x12':
+                if (this.dialog !== undefined)
+                    return;
                 if (this.focusedRow === null)
                     this.toggleCollapsible();
                 else
@@ -9612,7 +10103,11 @@ export class SshTui {
     }
     /** The painted lines as plain text, for the selection rules. */
     plainSelectableLines() {
-        return this.selectableLines.map(line => ({ text: stripAnsi(line.raw), copyable: line.copyable }));
+        return this.selectableLines.map(line => ({
+            text: stripAnsi(line.raw),
+            copyable: line.copyable,
+            gutter: line.gutter,
+        }));
     }
     /** Screen row from a mouse report to an index into `selectableLines`. */
     selectableLineAt(screenY) {
@@ -9737,7 +10232,10 @@ export class SshTui {
     }
     copyPlainText(text, notice) {
         this.copyYank = text;
-        this.focusedRow = null;
+        // The selection stays: the marker on the copied row is how the reader sees
+        // *what* went to the clipboard, and a second press of the copy key must be
+        // idempotent. Clearing it here made the next `/copy` silently fall back to
+        // "the latest reply" — a different row, with nothing on screen to say so.
         this.input = '';
         this.cursor = 0;
         this.inputFolded = false;
@@ -9750,14 +10248,32 @@ export class SshTui {
         // how the terminals that *do* honour it work — but where the table does not
         // promise it the user is told once per session rather than at every copy, or
         // not at all until they paste into an empty clipboard.
-        if (!this.terminalCaps.osc52 && !this.osc52HintShown) {
+        //
+        // An SSH session is the exception the table cannot see. The classifier reads
+        // the *remote* terminal (the tty on the far side of the connection, which is
+        // usually a bare Linux console or an unnamed pty), while the bytes are
+        // written to the *local* terminal — the one the user is actually copying
+        // into. That local terminal is what accepted the write, which is why a copy
+        // over SSH works and then warns that it did not. Warning there is a lie, so
+        // the caveat stays quiet inside an SSH session.
+        //
+        // The test is the session itself and not `paintLink`, which is also `'ssh'`
+        // on a local window whenever the launcher relayed the frame: there the
+        // capability table *did* describe the terminal that receives the bytes, so
+        // the caveat is exactly what the user needs to read (the terminal probe
+        // asserts it does, for seven terminal profiles).
+        if (!this.terminalCaps.osc52 && !this.sshSession && !this.osc52HintShown) {
             this.osc52HintShown = true;
             this.pushRow({ kind: 'system', text: t('copy.osc52Hint', { terminal: this.terminalCaps.label }) });
         }
         this.markDirty();
     }
     copyFocusedCard(arg = '') {
-        if (this.dialog !== undefined)
+        // A dialog covers the input line, so the copy key is the only way to copy
+        // from inside one. The inspect overlay carries what it is showing; every
+        // other dialog keeps the key inert, exactly as it always was.
+        const overlay = this.dialog?.kind === 'inspect' ? this.dialog : undefined;
+        if (this.dialog !== undefined && overlay === undefined)
             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
@@ -9775,14 +10291,30 @@ export class SshTui {
             return true;
         }
         if (arg.trim() === '') {
-            const picked = copyTextFromTranscript(this.rows, this.focusedRow);
+            const shown = overlay?.copyText;
+            const picked = shown !== undefined && shown.trim() !== ''
+                ? { text: shown, source: 'focused' }
+                : 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 }));
+            // The label follows the text: when the overlay supplied it, the row the
+            // cursor sits on may be a different card entirely (Ctrl+N/P used to move
+            // it behind the overlay), and naming that row would be a false report.
+            const source = shown !== undefined && shown.trim() !== ''
+                ? t('copy.sourceFull')
+                : picked.source === 'focused'
+                    ? t(this.focusedRow?.kind === 'assistant' ? 'copy.sourceFocusedReply' : 'copy.sourceFocused')
+                    : t('copy.sourceAssistant');
+            const notice = t('copy.ok', { chars: picked.text.length, source });
+            this.copyPlainText(picked.text, notice);
+            if (overlay !== undefined) {
+                // The notice row is behind the overlay, so the overlay says it too.
+                overlay.notice = notice;
+                this.markDirty();
+            }
             return true;
         }
         this.pushRow({ kind: 'system', text: t('copy.usage') });
@@ -9832,6 +10364,14 @@ export class SshTui {
             return;
         }
         this.scrollOffset = 0;
+        // A selected reply has no card to fold, so Enter has to reach it too: the
+        // gate below only asks about collapsible rows, and in a session with no card
+        // at all (a plain Q&A, or right after `/clear`) that left Enter doing
+        // nothing while `Alt+4` / Ctrl+N had just selected the reply.
+        if (this.input.trim() === '' && this.focusedRow !== null && this.focusedRow.kind === 'assistant') {
+            this.toggleCollapsible();
+            return;
+        }
         if (this.input.trim() === '' && this.collapsibleRows().length > 0) {
             this.toggleCollapsible();
             return;
@@ -10006,6 +10546,12 @@ export class SshTui {
                     this.markDirty();
                 });
                 break;
+            case 'notify':
+                void this.runNotifyCommand(arg).catch((error) => {
+                    this.pushRow({ kind: 'error', text: t('cmd.failedNamed', { command: 'notify', error: errorChain(error) }) });
+                    this.markDirty();
+                });
+                break;
             case 'disconnect':
                 void this.runDisconnectCommand(arg).catch((error) => {
                     if (error instanceof UserQuestionError) {