dsh-ssh-tui 0.8.3 → 0.8.4-rc.2

package/lib/tui.js

@@ -21,13 +21,14 @@ import { mkdir, readFile, writeFile } from 'node:fs/promises';
 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 './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, TUI_SOURCE_KIND, } from './dsh-compat.js';
+import { commandAcceptsAttachments, forEachSessionEventAsync, hostSettingsGeneration, isTokenDeltaChunk, listenHostEvent, drainChildSubagents, 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 { InputReader } from './input-reader.js';
+import { InputRouter } from './input-router.js';
 import { auditQuestionPrimaries, auditRepresentations, formatRepresentationAudit, isRepresentation, represent, } from './representation.js';
 import { clampScreenOffset, reportRowKind, screenFromDialog, screenLayout, screenPositionText, } from './screen.js';
 import { screenRuntimeStrip } from './footer-budget.js';
@@ -47,7 +48,7 @@ import { resolveTheme, setActiveTheme, themeByName, themeEmphasisToken, themeExt
 import { presetLabel, profileFromArgv } from './preset-label.js';
 import { flattenGroups, groupPresets, optionMatches } from './preset-picker.js';
 import { isRefusal, planCopy, planDelete, planMetadata, presetDirectory, } from './preset-authoring.js';
-import { ensureRosterRows, planDuplicateRepair, planRosterRepair, formsRowsDeclared, rosterPatchPath, rosterRows, writePatchWithBackup, ALL_ROSTER_ROWS, } from './preset-rows.js';
+import { ensureRosterRows, planDuplicateRepair, planRosterRepair, rosterPatchPath, rosterRows, writePatchWithBackup, ALL_ROSTER_ROWS, } from './preset-rows.js';
 import { SessionStatsTracker, sessionTokenTotal, statsRowOf, } from './stats.js';
 import { QUESTION_OPTION_KEYS, applyQuestionFilter, backspaceQuestionFilter, clearQuestionFilter, typeQuestionFilter, visibleQuestionIndexes, confirmAnswer, inspectClosesOn, moveQuestionCursor, optionsLength, questionOptionIndex, initialQuestionSelection, questionOptionMarker, questionSubmit, selectQuestionOptionByKey, windowInteractionLines, PICKER_ROLE, interactionRole, stallsTask, surfacePriority, isSurfaceDialog, } from './dialogs.js';
 import { commandSuggestions, localizedCommands } from './commands.js';
@@ -74,8 +75,7 @@ import { UserQuestionError, } from '@deepseek-ai/dsh-user-questions';
 import { durableQuestionRecords, answerSummaryText, questionViewOf, } from './question-state.js';
 import { clipAnsiToWidth, cursorVisualPosition, displayWidth, fmtElapsedCompact, foldInputView, highlightAnsiNeedle, hrefAtColumn, lastCodePoints, osc52Clipboard, padToWidth, paintSegmentedLine, paintedLinkHits, renderMarkdownLines, repeatToWidth, sanitizeTerminalText, searchContains, setAmbiguousWidthMeasured, setAmbiguousWidthReserve, shimmerText, sliceCodePoints, stripAnsi, truncate, truncateToWidth, visibleWidth, waitCardCopy, wrap, wrapSegmented, wrapWaitDetails, } from './term-text.js';
 import { clampSelection, offsetAfterColumn, offsetAtColumn, selectionSpans, selectionText, } from './selection.js';
-import { captureHangupSignals, advancePaintedRows, composePaintFrame, frameByteBudget, detectSshSession, formatLinkQualityChip, HANGUP_CANCEL_TIMEOUT_MS, ignoreFurtherHangupSignals, isEscapePrefix, isHangupErrno, linkQualityOf, linkRedrawBudgetMs, parseCursorPositionReply, PICKER_WINDOW, pickerWindowStart, probeTerminalRttMs, releaseHangupSignals, resolvePaintIntervalMs, toolBodyLineLimit, waitUntilIdleOrTimeout, RTT_HISTORY, medianRtt, } from './paint.js';
-import { TerminalInputGuard } from './terminal-input.js';
+import { captureHangupSignals, advancePaintedRows, composePaintFrame, frameByteBudget, detectSshSession, formatLinkQualityChip, HANGUP_CANCEL_TIMEOUT_MS, ignoreFurtherHangupSignals, isHangupErrno, linkQualityOf, linkRedrawBudgetMs, PICKER_WINDOW, pickerWindowStart, probeTerminalRttMs, releaseHangupSignals, resolvePaintIntervalMs, toolBodyLineLimit, waitUntilIdleOrTimeout, RTT_HISTORY, medianRtt, } from './paint.js';
 import { contextPressureAlertText, contextPressureView, describeProviderRoute, fitFooterStatusLine, footerActivity, footerHealthChip, footerIdentityParts, footerSubagentForeign, paintFooterSubagentChip, footerStatsGroups, formatContextPressureChip, runtimeStrip, providerHasQuotaSurface, formatStatusReport, planRouteBadge, 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';
 import { appendSubagentLog, foldSubagentUserLog, applyTurnEndToPlan, buildSubagentHeader, cardCategoryLabel, cardCategoryOf, clipSubagentActivity, compactionHeaderText, formatCompactCommandError, isPromptInjectionMessage, matchTranscriptRows, parseFindQuery, planCloseNudgeText, planMarkdownFromArgs, planDockNote, planIsLive, planTitleFromMarkdown, promptInjectionSources, promptInjectionTitle, describeSubagentFailure, subagentChipSummary, subagentDisplayName, subagentInspectLines, subagentRowFromSpawnTool, todoItemKind, askQuestions, todoProgressLabel, TODO_STATUS_MARK, } from './plan.js';
@@ -448,84 +448,27 @@ const QUOTA_RETRY_MS = 15_000;
  * screen's own tests have one source: the *order* is the product decision (B2.6 §3
  * keeps it unchanged), and this is where it is written down.
  */
-const SETUP_STEPS = ['provider', 'id', 'base-url', 'key', 'models', 'models-pick', 'model-default', 'context', 'confirm'];
-/** The steps that show a text field (the others are pickers or the confirmation). */
-const SETUP_FIELD_STEPS = new Set(['provider', 'id', 'base-url', 'key', 'models', 'context']);
+/** SGR mouse report: `\x1b[<button;column;row` + `M` (press/motion) or `m` (release). */
+const SGR_MOUSE_RE = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/u;
 /**
- * Whether one data chunk is a paste rather than keystrokes.
+ * Whether one unit carries more than one Unicode code point.
  *
- * Bracketed paste says so outright, and that is the path every modern terminal
- * takes. A console without it sends the content as one burst instead, and a burst
- * carrying more than one line break is not a human pressing Enter twice — they
- * cannot press it twice inside one read. This is the fallback's one rule, kept
- * here so every surface that can take a paste applies the same one.
+ * This is the test `composerUnit` needs, and `unit.length > 1` is not it: `.length`
+ * counts UTF-16 code units, and an astral character — `🚀`, `𠮷`, an emoji with a
+ * modifier — is two of those while being a single code point. Reading the first code
+ * point and comparing the remainder costs nothing on the hot path (ASCII answers 1, so
+ * the comparison is `length > 1` as before) and never allocates, which `Array.from`
+ * would. A lone surrogate answers 1, which is the honest reading: it is one code unit
+ * and the Reader cannot produce one from the wire.
  */
-function looksLikePasteBurst(text) {
-    let breaks = 0;
-    for (let index = 0; index < text.length; index += 1) {
-        const char = text[index];
-        if (char === '\r' && text[index + 1] !== '\n')
-            breaks += 1;
-        else if (char === '\n' && text[index - 1] !== '\r')
-            breaks += 1;
-        if (breaks > 1)
-            return true;
-    }
-    return false;
-}
-/**
- * Split one read into the keys it carries.
- *
- * A terminal hands over whatever arrived together, which is not always one key: a
- * fast typist on a slow link sends `text\r`, a console without bracketed paste sends
- * a whole line, and a paste is followed by Enter inside the same read. The composer
- * has always taken a read apart (`handlePlainText` types it character by character),
- * and a Screen has to see the same keys — a control byte is only itself when it
- * stands alone, so a read handed to one step is a read whose Enter is dropped on the
- * floor. That is what this returns: escape sequences whole (an arrow is one key),
- * control bytes one each with CRLF read as the one Enter it is, and a run of
- * printable text kept together, because a step that filters on what it is given
- * wants the run and a paste without markers still must not answer a confirmation.
- */
-function screenKeys(text) {
-    const keys = [];
-    let index = 0;
-    while (index < text.length) {
-        const char = text[index];
-        if (char === '\x1b') {
-            // A CSI sequence (`\x1b[` params final), SS3 (`\x1bO` one char), or the lone
-            // Escape key itself when nothing follows it in this read.
-            const rest = text.slice(index);
-            const sequence = /^\x1b\[[0-9;?<]*[ -/]*[@-~]/u.exec(rest)?.[0] ?? /^\x1bO[@-~]/u.exec(rest)?.[0];
-            if (sequence !== undefined) {
-                keys.push(sequence);
-                index += sequence.length;
-                continue;
-            }
-            keys.push('\x1b');
-            index += 1;
-            continue;
-        }
-        if (char === '\r' || char === '\n') {
-            // Windows terminals send Enter as CRLF; both halves are one key.
-            const next = text[index + 1];
-            keys.push('\r');
-            index += (char === '\r' && next === '\n') || (char === '\n' && next === '\r') ? 2 : 1;
-            continue;
-        }
-        if (char < ' ' || char === '\x7f') {
-            keys.push(char);
-            index += 1;
-            continue;
-        }
-        let end = index;
-        while (end < text.length && text[end] >= ' ' && text[end] !== '\x7f')
-            end += 1;
-        keys.push(text.slice(index, end));
-        index = end;
-    }
-    return keys;
+function carriesMultipleCodePoints(unit) {
+    if (unit.length <= 1)
+        return false;
+    return unit.length > ((unit.codePointAt(0) ?? 0) > 0xffff ? 2 : 1);
 }
+const SETUP_STEPS = ['provider', 'id', 'base-url', 'key', 'models', 'models-pick', 'model-default', 'context', 'confirm'];
+/** The steps that show a text field (the others are pickers or the confirmation). */
+const SETUP_FIELD_STEPS = new Set(['provider', 'id', 'base-url', 'key', 'models', 'context']);
 /**
  * The durable event types the plan projection reads (B2.5).
  *
@@ -882,7 +825,6 @@ export class SshTui {
     input = '';
     cursor = 0;
     inputFolded = false;
-    inPaste = false;
     history = [];
     historyIndex = -1;
     /** Live input parked while browsing history with ↑. Restored by ↓ past the newest item. */
@@ -1136,7 +1078,6 @@ export class SshTui {
     onReattach;
     onDetach;
     renderTimer;
-    decoder = new StringDecoder('utf8');
     color;
     maxToolOutputLines;
     showReasoning;
@@ -1496,8 +1437,6 @@ export class SshTui {
      * `turn/start` is the only thing that resets it.
      */
     reasoningExpandedChoice;
-    escapeBuffer = '';
-    escapeTimer;
     /**
      * How long an acknowledgement or a warning stays on the chrome.
      *
@@ -1512,11 +1451,28 @@ export class SshTui {
     feedbackTtlMs = resolveFeedbackTtlMs(process.env);
     feedbackTimer;
     /**
-     * Cursor-position replies removed from the relay's stdin stream. A launcher
-     * from an older release (or a reply that raced its own probe) would otherwise
-     * type `[17;1R` into the prompt or cancel a dialog with a bare ESC.
+     * The input Reader (AD-21): decoding, reply filtering, escape assembly, paste
+     * framing and unit classification live there; the frames come back through
+     * `handleInputText` / `consumeFrame`, which own the routing and the semantics.
      */
-    inputGuard = new TerminalInputGuard(text => this.handleInputText(text));
+    reader = new InputReader({
+        onRead: text => this.handleInputText(text),
+        onFrame: frame => this.consumeFrame(frame),
+    });
+    /**
+     * The Router (AD-22, W-2): the one place a unit's owner is decided.
+     *
+     * `ownershipView` is the read-only snapshot it answers from — one object, rewritten
+     * per decision, so a keystroke allocates nothing (W-2 is a hot-path migration).
+     */
+    router = new InputRouter();
+    ownershipView = {
+        screenKind: undefined,
+        surfaceKind: undefined,
+        surfaceHasField: false,
+        composerEmpty: true,
+        workspaceCards: false,
+    };
     thinkingStartedAt;
     waitStartedAt;
     /**
@@ -1546,6 +1502,15 @@ export class SshTui {
     cwdChipRow;
     /** Set when a card expand/collapse moves chrome; next paint full-redraws. */
     forceFullPaint = false;
+    /**
+     * How many times the Screen has been dismissed.
+     *
+     * A read is not a key: its units are delivered one at a time, and a Screen owns the
+     * read it was sent — once it is gone the rest is dropped (0.8.3's rule, W-3a keeps
+     * it). Counting dismissals rather than comparing the Screen object keeps that check
+     * out of the owner-read ratchet, which exists to stop new *ownership* reads.
+     */
+    screenDismissals = 0;
     /** 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. */
@@ -2276,6 +2241,7 @@ export class SshTui {
         const credentials = this.ctx.get('credentials');
         const provider = this.currentProviderId();
         if (providerUsesLocalOAuth(provider)) {
+            await this.repairAgentPlaneAtBoot();
             // Workspace feedback *about* setup — not the wizard's own surface, which is the
             // setup Screen (B2.6 §12). These rows are the command plane's.
             this.pushRow(represent('command-status', {
@@ -2311,6 +2277,7 @@ export class SshTui {
         }
         if (envKey !== undefined && envKey !== '') {
             if (stored || existsSync(DSH_ENV_FILE) || this.resume) {
+                await this.repairAgentPlaneAtBoot();
                 this.pushRow(represent('command-status', {
                     kind: 'system',
                     text: t('onboard.envInUse', { env: envRef }),
@@ -2336,8 +2303,10 @@ export class SshTui {
         // got an empty workspace, a provider that cannot answer, and no hint that
         // `/setup` exists. The launch flag is not evidence of configuration; the
         // credential store is, and that is what `stored` reads.
-        if (stored)
+        if (stored) {
+            await this.repairAgentPlaneAtBoot();
             return;
+        }
         this.pushRow(represent('command-status', { kind: 'system', text: t('onboard.needSetup') }));
         await this.runOnboarding();
     }
@@ -2409,12 +2378,9 @@ export class SshTui {
         if (this.renderTimer !== undefined)
             clearInterval(this.renderTimer);
         this.renderTimer = undefined;
-        if (this.escapeTimer !== undefined)
-            clearTimeout(this.escapeTimer);
         if (this.feedbackTimer !== undefined)
             clearTimeout(this.feedbackTimer);
-        this.escapeTimer = undefined;
-        this.inputGuard.stop();
+        this.reader.stop();
         process.stdin.removeListener('data', this.handleData);
         process.stdout.removeListener('resize', this.onDirectResize);
         process.stdout.removeListener('error', this.handleIoError);
@@ -2557,10 +2523,29 @@ export class SshTui {
         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;
+        // The official DeepSeek adapter is registered through `ctx.llm`, not through
+        // `llm-pi-ai`; the adapter directory is the same source `src/index.ts` uses
+        // for route availability. Keep the configured list too: a pi-ai gateway may
+        // be configured before its adapter has finished registering. Doctor is
+        // best-effort, so an unavailable directory falls back to that list rather
+        // than failing the report.
+        let adapterRoutes = [];
+        const llm = this.ctx.get('llm');
+        if (llm !== undefined) {
+            try {
+                adapterRoutes = llm.listProviders()
+                    .map(entry => entry.id.trim())
+                    .filter(id => id !== '');
+            }
+            catch {
+                // Keep the configured set; `/doctor` must still render what it knows.
+            }
+        }
+        const routes = [...new Set([...Object.keys(providers), ...adapterRoutes])];
         return {
             provider,
             ...(model === undefined ? {} : { model }),
-            routes: Object.keys(providers),
+            routes,
             routeModels: models.map(modelEntryId).filter((id) => id !== undefined),
             ...(sub.provider === undefined ? {} : { subProvider: this.displayProviderId(sub.provider) }),
             ...(sub.model === undefined ? {} : { subModel: sub.model }),
@@ -2569,6 +2554,7 @@ export class SshTui {
     /** One collected `/doctor` snapshot, from this process's own services. */
     async collectDoctorFacts(profile) {
         const routing = this.doctorRouting();
+        const tools = this.agentPlaneTools();
         return collectDoctor({
             profile,
             dshHome: resolveDshHome(),
@@ -2576,6 +2562,8 @@ export class SshTui {
             services: {
                 roster: this.ctx.get('agentPresets') !== undefined,
                 codeRuntime: this.hasHostService('codeRuntime'),
+                askUserTool: tools.askUser,
+                presentTool: tools.present,
             },
             generation: hostSettingsGeneration(this.ctx),
             anchors: [process.argv[1], this.ctx.baseUrl],
@@ -2658,7 +2646,7 @@ export class SshTui {
                 backup = await writePatchWithBackup(facts.patchPath, text);
             }
             else {
-                await ensureRosterRows(facts.dshHome, facts.profile, rows);
+                await ensureRosterRows(facts.dshHome, facts.profile, rows, facts.generation ?? 'legacy');
             }
             const done = [
                 t('doctor.fix.applied', {
@@ -4054,6 +4042,7 @@ export class SshTui {
         if (this.screen === undefined)
             return;
         this.screen = undefined;
+        this.screenDismissals += 1;
         this.screenSurface = undefined;
         this.screenSurfaceResolve = undefined;
         // One full repaint when a Screen closes, and it is deliberate: the transcript
@@ -5638,7 +5627,12 @@ export class SshTui {
             column = Math.min(width, promptWidth + inputView.cursorOffset + 1);
         }
         else {
-            const pos = cursorVisualPosition(inputView.text, this.cursor, inputTextWidth);
+            // The caret belongs to the field being drawn, like the text above it (W-3b.1a):
+            // `fieldCursor` is the borrowed answer's caret while a Surface has one, and the
+            // draft's otherwise. Reading `this.cursor` here put the terminal's caret — the
+            // cell an IME draws its pre-edit in — at the hidden draft's offset, which is a
+            // different number whenever a Surface borrowed the field.
+            const pos = cursorVisualPosition(inputView.text, fieldCursor, inputTextWidth);
             while (pos.row >= inputDisplayLines.length)
                 inputDisplayLines.push('');
             cursorRowOffset = pos.row;
@@ -5801,38 +5795,38 @@ export class SshTui {
             ...(health === undefined ? {} : { warning: { long: health.long, short: health.short } }),
             depth: this.colorDepth,
             color: this.color,
-            ...(this.footerEcho === undefined ? {} : { echo: this.footerEcho.text }),
         };
         const stripText = runtimeStrip(stripInput, Math.max(1, width), this.mutedSeparator(), this.spinnerFrame());
-        // The acknowledgement the strip could not fit.
-        //
-        // The echo chip is the lowest-priority group on the stats row, which is exactly
-        // the state a working session is in — so a command's confirmation was dropped
-        // entirely and the reader saw *no* feedback at all (B2.5, reported). The chip is
-        // still where it goes first; when it did not survive, the row that always fits
-        // says it instead. One message, one place, no extra rows.
-        const missingEcho = this.notice === undefined
-            && this.footerEcho !== undefined
-            && !stripText.includes(this.footerEcho.text)
-            ? this.footerEcho.text
-            : undefined;
         // The row is one muted run with the accents spliced in at higher intensity;
         // `muteFooterLine` reopens the mute after every reset so the (already
         // coloured) pips and meters cannot bleed into the text around them.
         const statsLine = clipAnsiToWidth(this.muteFooterLine(stripText), Math.max(1, width));
         this.healthChipRow = undefined;
-        // The identity row is composed *after* the strip, because whether it needs to
-        // carry the echo depends on what the strip managed to fit (see below).
+        // Every acknowledgement lands on the identity row, and nowhere else.
+        //
+        // The echo used to be the lowest-priority chip *on the meter row*, with the
+        // identity row as the fallback when it did not fit — so which of the two rows a
+        // message appeared on depended on its length and the window's width. The same
+        // `/copy` said `已复制 412 字…（最近回复）` on the row above the last one (it fit)
+        // and `还没有可复制的回复…` on the last one (it did not): two acknowledgements,
+        // two lines, nothing in the product saying why (reported). A confirmation is
+        // read, not measured, so it is not the meter row's business either — the first
+        // footer row answers the five telemetry questions and only those (E-1).
+        //
+        // A notice still outranks an echo: an operational warning must not be hidden by
+        // an acknowledgement that happens to be alive at the same moment. Both are
+        // Host-local, both are transient, and now both are on the row that always fits.
+        const echoText = this.notice === undefined ? this.footerEcho?.text : undefined;
         const statusText = this.notice !== undefined
             ? truncateToWidth(this.notice.text, Math.max(1, width))
-            : missingEcho === undefined
-                ? fitFooterStatusLine('', identity, Math.max(1, width))
-                : truncateToWidth(missingEcho, Math.max(1, width));
+            : echoText !== undefined
+                ? truncateToWidth(echoText, Math.max(1, width))
+                : fitFooterStatusLine('', identity, Math.max(1, width));
         // Accents on an otherwise muted line: the `sub:` chip. Each reset reopens
         // mute, the same way the pre-strip footer did. `styleLine` sanitises first,
         // so the accent is spliced in after.
         let statusLine = this.styleLine('system', statusText);
-        if (this.color && this.notice === undefined) {
+        if (this.color && this.notice === undefined && echoText === undefined) {
             // The chip is only accented when it survived the fit: a `sub:` route the
             // row could not afford is not on the line, and `paintFooterSubagentChip`
             // returns the line unchanged when it cannot find its text.
@@ -8423,6 +8417,13 @@ export class SshTui {
         const options = {
             provider,
             model,
+            // The reviewer is a direct LLM call outside the Agent loop; the loop normally
+            // supplies this identity. OpenCode requires a per-conversation session
+            // signal: pi-ai's built-in provider turns this into `x-opencode-session`,
+            // while the configured openai-responses route sends `session_id`. Other
+            // providers may use it for their own affinity/cache routing. It must be the
+            // Session that actually asked for approval, never a shared or random id.
+            sessionId: request.agent.session.id,
             messages: [createUserMessage({
                     content: [{ type: 'text', text: buildReviewUserMessage({
                                 userText,
@@ -8802,6 +8803,21 @@ export class SshTui {
         const at = this.fieldCursor();
         this.setField(`${current.slice(0, at)}${text}${current.slice(at)}`, at + text.length);
     }
+    /**
+     * Move the caret of whichever field owns the keyboard to one end (Home/End).
+     *
+     * One implementation for the two owners that carry these keys (W-3b.1): the composer
+     * edits the draft, a Surface with a borrowed field edits the answer, and a Surface
+     * without one has nothing to move — `textIsEditable` is what says which of those the
+     * keyboard is on. Ctrl+A/Ctrl+E reach the same two positions through `composerUnit`,
+     * which asks the same question.
+     */
+    moveFieldCursor(target) {
+        if (!this.textIsEditable())
+            return;
+        this.setField(this.fieldText(), target === 'start' ? 0 : this.fieldText().length);
+        this.markDirty();
+    }
     /** One card's key: a call's batch can repeat a question id across calls. */
     questionCardKey(callId, questionId) {
         return `${callId ?? `live:${this.liveQuestionSeq}`}\u0000${questionId}`;
@@ -10939,18 +10955,91 @@ export class SshTui {
         this.markDirty();
     }
     /**
-     * `/mode fix`: write the roster row into this profile's user patch layer.
+     * The two tools a 0.1.7 terminal profile mounts itself, read from the running
+     * composition. The profile patch is only the instruction; this is the answer
+     * to whether the instruction actually produced a tool.
+     */
+    agentPlaneTools() {
+        const tools = this.ctx.get('tools');
+        return {
+            askUser: tools?.get('ask_user_question') !== undefined,
+            present: tools?.get('present') !== undefined,
+        };
+    }
+    /** Whether this process's agent plane has both tools. */
+    agentPlaneReady() {
+        const tools = this.agentPlaneTools();
+        return tools.askUser && tools.present;
+    }
+    /**
+     * Repair an already-configured profile at boot and say a restart is needed.
      *
-     * The write only takes effect on the next launch — the loader composes the
-     * patch tree once at boot — so the report says so instead of pretending the
-     * running session gained a roster.
+     * A first run deliberately does not call this: its wizard save is the point
+     * where settings and credentials exist, and `onboardDone` repairs immediately
+     * after that write. This method serves the old/partial profile upgrade path,
+     * where there is no wizard to wait for.
+     */
+    async repairAgentPlaneAtBoot() {
+        const profile = profileFromArgv();
+        try {
+            const repaired = await this.ensureProfileAgentPlane(profile);
+            if (repaired === 'written') {
+                this.pushRow(represent('boot', {
+                    kind: 'system',
+                    text: t('onboard.agentPlaneAdded', {
+                        path: rosterPatchPath(resolveDshHome(), profile),
+                        profile,
+                    }),
+                }));
+                this.refreshRosterHealth();
+                this.markDirty();
+            }
+        }
+        catch (error) {
+            // A broken or unwritable patch must not be swallowed: the workspace can
+            // still boot, but the missing tools stay visible in the footer and
+            // `/doctor` explains how to repair the file.
+            this.pushRow(represent('boot', {
+                kind: 'error',
+                text: t('onboard.agentPlaneFailed', {
+                    error: errorChain(error),
+                    path: rosterPatchPath(resolveDshHome(), profile),
+                }),
+            }));
+            this.markDirty();
+        }
+    }
+    /**
+     * Add only the profile rows whose tools are missing from this composition.
+     *
+     * A row that is already present in the patch is never written again, even if
+     * its service failed to activate: the planner sees overrides and disables by
+     * id or module name, and `ensureRosterRows` creates a backup first. This is
+     * the first-run/upgrade repair, not an install-hook claim: it changes what
+     * the next boot composes, not what this process has already composed.
      */
+    async ensureProfileAgentPlane(profile = profileFromArgv()) {
+        const generation = this.settingsGeneration;
+        const tools = this.agentPlaneTools();
+        const missing = generation === 'forms'
+            ? rosterRows(generation).filter(row => row.id === 'tool-ask-user' ? !tools.askUser : !tools.present)
+            : rosterRows(generation).filter(row => row.id === 'agent-presets'
+                ? this.ctx.get('agentPresets') === undefined
+                : row.id === 'code-runtime'
+                    ? !this.hasHostService('codeRuntime')
+                    : true);
+        if (missing.length === 0)
+            return 'present';
+        return ensureRosterRows(resolveDshHome(), profile, missing, generation);
+    }
     /** Re-read the roster fact this process was composed with (cheap, no IO). */
     refreshRosterHealth() {
         // 0.1.7 has no roster to be missing: what a terminal profile owns there is
-        // the agent-plane rows, so the chip reports those instead.
+        // the agent-plane tools, so the chip follows the tools the composition
+        // actually registered. Reading the patch alone would call a broken load
+        // healthy as soon as the row text was written.
         this.rosterMissing = this.settingsGeneration === 'forms'
-            ? !formsRowsDeclared(resolveDshHome(), profileFromArgv())
+            ? !this.agentPlaneReady()
             : this.ctx.get('agentPresets') === undefined;
     }
     /** Which settings protocol this host speaks; decides what "missing" means. */
@@ -10971,6 +11060,14 @@ export class SshTui {
             ? [first, t('mode.formsHost'), t('mode.formsHint', { profile, patch })].join('\n')
             : [first, t('mode.missingServiceHint', { profile, patch })].join('\n');
     }
+    /**
+     * `/mode fix`: write the missing profile rows into the user patch layer.
+     *
+     * The write only takes effect on the next launch — the loader composes the
+     * patch tree once at boot — so the report says so instead of pretending the
+     * running session gained a roster. The helper consults the actual tools, so
+     * a row a bundle already supplies is not mounted a second time.
+     */
     async repairRoster() {
         const profile = profileFromArgv();
         const patch = rosterPatchPath(resolveDshHome(), profile);
@@ -10979,8 +11076,7 @@ export class SshTui {
             // process-wide and owns the agent-plane rows instead of the roster. Both
             // the list and the header come from the same generation `/doctor` uses,
             // or this writes rows the running host cannot resolve.
-            const generation = this.settingsGeneration;
-            const result = await ensureRosterRows(resolveDshHome(), profile, rosterRows(generation), generation);
+            const result = await this.ensureProfileAgentPlane(profile);
             this.refreshRosterHealth();
             this.pushRow(represent('repair-result', {
                 kind: 'system',
@@ -11328,10 +11424,7 @@ export class SshTui {
     }
     // ── keyboard ────────────────────────────────────────────────────────────
     handleData = (chunk) => {
-        const decoded = this.decoder.write(chunk);
-        if (decoded === '')
-            return;
-        this.inputGuard.push(decoded);
+        this.reader.push(chunk);
     };
     /**
      * One key, handled by the Screen that is up.
@@ -11357,30 +11450,13 @@ export class SshTui {
         }
         // A burst of line breaks in one read is a paste from a console that cannot say so
         // (`looksLikePasteBurst`): it belongs in the field as one edit, which is how a
-        // pasted key or model list survives a terminal without bracketed paste. It is
-        // asked *before* the split below, because splitting is what would turn one paste
-        // into a step's worth of Enters.
-        if (looksLikePasteBurst(combined)) {
+        // pasted key or model list survives a terminal without bracketed paste. The Reader
+        // keeps such a read whole for exactly this check — splitting it is what would turn
+        // one paste into a step's worth of Enters.
+        if (InputReader.looksLikePasteBurst(combined)) {
             this.pasteIntoScreen(combined);
             return;
         }
-        // A read is not a key (`screenKeys`). This is the only path a Screen's input
-        // arrives on, so a read carrying several keys — `text\r` from a fast typist on a
-        // slow link, an arrow batched with the key after it — has to be taken apart here
-        // or the keys after the first are spent on a step that cannot read them. Each key
-        // is handed on its own, and the rest of the read is dropped once the Screen it was
-        // addressed to is gone: the keys after a dismissal belong to whatever comes next,
-        // and guessing that here is how a paste ended up in the composer in the first
-        // place.
-        const keys = screenKeys(combined);
-        if (keys.length > 1) {
-            for (const key of keys) {
-                if (this.screen === undefined)
-                    return;
-                this.handleScreenInput(key, this.keymap.sequences.get(key));
-            }
-            return;
-        }
         // The setup Screen owns its own field, its own navigation and its own keys: it
         // consumes everything while it is up, and nothing reaches the workspace's
         // composer, history or transcript (B2.6 §4).
@@ -11524,31 +11600,86 @@ export class SshTui {
         screen.notice = caveat ?? notice;
         this.markDirty();
     }
+    /**
+     * One read, as the Reader framed it: paste traffic is dispatched per frame,
+     * everything else is routed (W-2 lifts the routing itself into a Router).
+     */
     handleInputText(text) {
-        const combined = this.escapeBuffer + text;
-        this.escapeBuffer = '';
-        if (this.escapeTimer !== undefined) {
-            clearTimeout(this.escapeTimer);
-            this.escapeTimer = undefined;
-        }
-        // Bracketed paste: terminals wrap pasted content in \x1b[200~ ... \x1b[201~.
-        // While inside a paste, CR/LF are literal input characters rather than
-        // submit, so copying a multi-line error message arrives as one message.
-        if (this.inPaste || combined.includes('\x1b[200~') || combined.includes('\x1b[201~')) {
-            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.
+        const combined = this.reader.assemble(text);
+        // A read is not a key. The Reader decides where one unit ends — complete
+        // sequences, Alt chords, control bytes, CR/LF, and runs of typing — and each unit
+        // is framed once and routed once, whichever owner it belongs to (AD-20 §3, W-3a).
+        // Bracketed paste is framed there too: while inside a paste, CR/LF are literal
+        // characters rather than submit, so a copied multi-line error message arrives as
+        // one message.
+        //
+        // A Screen owns the read it was sent, including the units after it closes: 0.8.3
+        // dropped the rest of such a read (`handleScreenInput` returned as soon as its
+        // Screen was gone) and that rule is a safety one, not an artefact — the keys after
+        // a dismissal were addressed to the Screen, and letting them land on whatever is
+        // behind it is how a paste ended up in the composer. A Surface is the other way
+        // round, and deliberately: its answer is a character like any other, and the rest
+        // of the read is routed on (`yes` typed at a confirm is refused by the Surface and
+        // leaves the draft alone — pinned by `yes-typed-at-dialog`).
+        const dismissals = this.screenDismissals;
+        for (const frame of this.reader.read(combined)) {
+            if (this.screenDismissals !== dismissals)
+                return;
+            this.consumeFrame(frame);
+        }
+    }
+    /** One framed unit, at the owner that takes it. */
+    consumeFrame(frame) {
+        switch (frame.kind) {
+            case 'paste':
+                this.dispatchPaste(frame.text);
+                return;
+            // A sequence tail, an Alt remainder or a released hold: typed as it is, with
+            // no keymap lookup — which is what the inline version did at those three sites.
+            case 'literal':
+                this.handlePlainText(frame.text);
+                return;
+            case 'escape':
+                this.handleChar('\x1b');
+                return;
+            // A device reply is the prober's input, never an owner's. W-1 keeps today's
+            // behaviour (dropped here); W-2 wires it to the prober that asked.
+            case 'reply': return;
+            // `key` and `burst` reach the same routing today. The distinction is what W-2
+            // routes on (one key versus several in one read), so the Reader decides it.
+            case 'key':
+                this.route(frame.sequence);
+                return;
+            case 'burst':
+                this.route(frame.text);
+                return;
+        }
+    }
+    /**
+     * One read from the Reader, as the ladder has always taken it.
+     *
+     * Two kinds of table live here and they are not the same thing:
+     *
+     *   - **binding** — which byte means which action (the keymap's rebindable actions,
+     *     the Alt chords, the SS3 tail). Those stay; AD-20 F-5 wants one table per key.
+     *   - **ownership** — who takes the unit. That question is the Router's now, and it
+     *     is asked exactly once per unit, before any binding table is consulted: a
+     *     Screen owns the read outright, so the tables below are for the unlayered case,
+     *     which is the order the ladder always had.
+     *
+     * The parsing branches that are neither (a read that could still grow — the Reader
+     * holds it; an escape sequence nobody claimed — dropped) stay here as well.
+     */
+    route(combined) {
+        // A key the user moved, and a key their move displaced.
         const moved = combined === '' ? undefined : this.keymap.sequences.get(combined);
-        // A Screen replaces the workspace and owns every key outright. There is no
-        // composer behind it, no transcript to fall through to and no Surface it could
-        // share with: one gate, instead of the ten `dialog?.kind === 'inspect'` checks
-        // this replaced (B2.1).
-        if (this.screen !== undefined) {
-            this.handleScreenInput(combined, moved);
+        const kind = this.readKind(combined);
+        this.observe(kind, combined);
+        const owner = this.router.route(kind, combined, this.ownershipView);
+        // A Screen owns the read outright (AD-20 §4.3 priority 3): nothing below this
+        // line runs for it — no keymap action, no Alt chord, no bare ESC for the composer.
+        if (owner === 'screen') {
+            this.ownerScreen(combined, moved);
             return;
         }
         if (this.dialog === undefined && combined !== '') {
@@ -11559,124 +11690,14 @@ export class SshTui {
             if (this.dialog === undefined && this.keymap.suppressed.has(combined))
                 return;
         }
-        const escape = /^\x1b\[([A-D])$/u;
-        const match = combined.match(escape);
-        if (match !== null) {
-            switch (match[1]) {
-                case 'A':
-                    if (this.moveQuestionCursor(-1)) {
-                        return;
-                        return;
-                        return;
-                    }
-                    else if (this.dialog !== undefined) {
-                        // A surface owns the keyboard: an arrow it does not use is not the
-                        // transcript's. Falling through moved the selection behind the dialog,
-                        // and with a non-empty field it rewrote the field from history.
-                        return;
-                    }
-                    else if (this.suggestionsVisible()) {
-                        this.suggestionIndex = Math.max(0, this.suggestionIndex - 1);
-                        this.markDirty();
-                    }
-                    else if (this.fieldText() === '' && this.collapsibleRows().length > 0) {
-                        this.moveFocus(-1);
-                    }
-                    else {
-                        this.historyBack();
-                    }
-                    return;
-                case 'B':
-                    if (this.moveQuestionCursor(1)) {
-                        return;
-                        return;
-                        return;
-                    }
-                    else if (this.dialog !== undefined) {
-                        return;
-                    }
-                    else if (this.suggestionsVisible()) {
-                        this.suggestionIndex = Math.min(this.commandSuggestions.length - 1, this.suggestionIndex + 1);
-                        this.markDirty();
-                    }
-                    else if (this.fieldText() === '' && this.collapsibleRows().length > 0) {
-                        this.moveFocus(1);
-                    }
-                    else {
-                        this.historyForward();
-                    }
-                    return;
-                case 'C':
-                    if (this.textIsEditable())
-                        this.moveCursor(1);
-                    return;
-                case 'D':
-                    if (this.textIsEditable())
-                        this.moveCursor(-1);
-                    return;
-            }
-        }
-        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) {
-                    this.scrollActiveSurface(3);
-                    return;
-                }
-                if (button === 65) {
-                    this.scrollActiveSurface(-3);
-                    return;
-                }
-                // 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 || 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 || button === 4)
-                this.endMouseSelection(y, x);
+        if (this.reader.isDeviceReply(combined)) {
+            this.consumeFrame({ kind: 'reply', sequence: combined });
             return;
         }
-        if (combined === '\x1b[5~') {
-            this.scrollActiveSurface(Math.max(3, Math.floor(this.screenRows() / 2)));
-            return;
-        }
-        if (combined === '\x1b[6~') {
-            this.scrollActiveSurface(-Math.max(3, Math.floor(this.screenRows() / 2)));
-            return;
-        }
-        if (parseCursorPositionReply(combined) !== undefined)
-            return;
-        if (combined === '\x1b[H' || combined === '\x1b[1~') {
-            this.cursor = 0;
-            this.markDirty();
-            return;
-        }
-        if (combined === '\x1b[F' || combined === '\x1b[4~') {
-            this.cursor = this.input.length;
-            this.markDirty();
-            return;
-        }
-        if (combined === '\x1b[3~') {
-            this.deleteAtCursor();
-            return;
-        }
-        // kitty / CSI-u Ctrl+Shift+C (codepoint 99, mods 6 = Ctrl+Shift)
-        if (combined === '\x1b[99;6u') {
-            this.copyKey();
+        // The sequence shapes the ladder matched before its hold window: they go to their
+        // owner as one unit, and only what is left over can still grow (the Reader holds it).
+        if (this.isSequenceShape(combined)) {
+            this.dispatchWith(owner, combined, moved);
             return;
         }
         const ss3 = /^\x1bO[A-Z]/u.exec(combined);
@@ -11686,30 +11707,10 @@ export class SshTui {
                 this.handlePlainText(rest);
             return;
         }
-        if (isEscapePrefix(combined)) {
-            this.escapeBuffer = combined;
-            this.escapeTimer = setTimeout(() => {
-                this.escapeTimer = undefined;
-                const pending = this.escapeBuffer;
-                this.escapeBuffer = '';
-                if (pending === '\x1b') {
-                    this.handleChar('\x1b');
-                }
-                else if (pending === '\x1bO') {
-                    // ESC O without an SS3 final byte is an Alt+O keystroke, not a
-                    // function key.
-                    this.handlePlainText('O');
-                }
-                else if (pending.startsWith('\x1b[') || pending.startsWith('\x1bO')) {
-                    // An escape sequence that never completed: consume it silently
-                    // instead of treating its ESC byte as a cancel.
-                }
-                else if (pending !== '') {
-                    this.handlePlainText(pending);
-                }
-            }, 60);
+        // A read that could still grow into a sequence is the Reader's to hold, and the
+        // window is the same 60 ms it always was (AD-21: moved, not changed).
+        if (this.reader.hold(combined))
             return;
-        }
         if (combined.startsWith('\x1b[') || combined.startsWith('\x1bO')) {
             // Unknown escape sequence (including SS3 function keys) — consume
             // without side effects.
@@ -11741,167 +11742,321 @@ export class SshTui {
                 this.stepSearch(-1);
                 return;
             }
+            // The `/find` seed is composer *text*, so it may only be typed into a field
+            // the composer owns (W-3b.3a). This branch runs before any owner is asked
+            // (the Alt chords are workspace-global, AD-20 §1.3 step 13), so with a
+            // Surface up it used to write the hidden draft — the one thing F-2 forbids —
+            // and the reader saw their next message replaced by `/find `. A chord is not
+            // an owner, so the key is consumed here instead of reaching behind the
+            // Surface. `textIsEditable()` alone is not this question: it answers "a field
+            // is editable", and a borrowed answer is one — the seed is the *composer's*
+            // field, which is exactly `borrowedText === undefined`.
             if (alt === 'f' || alt === 'F' || alt === '/') {
-                this.input = '/find ';
-                this.cursor = this.input.length;
-                this.markDirty();
+                if (this.textIsEditable() && this.borrowedText === undefined) {
+                    this.input = '/find ';
+                    this.cursor = this.input.length;
+                    this.markDirty();
+                }
                 return;
             }
             // Other Alt+<key>: ignore ESC so it does not cancel, type the remainder.
             this.handlePlainText(alt);
             return;
         }
-        this.handlePlainText(combined);
+        this.dispatchWith(owner, combined, moved);
     }
-    /** Handle one data chunk that may contain bracketed-paste markers. */
-    processPasteChunk(combined) {
-        let index = 0;
-        while (index < combined.length) {
-            if (combined.startsWith('\x1b[200~', index)) {
-                this.inPaste = true;
-                index += 6;
-                continue;
-            }
-            if (combined.startsWith('\x1b[201~', index)) {
-                this.inPaste = false;
-                index += 6;
-                continue;
-            }
-            let end = index;
-            while (end < combined.length
-                && !combined.startsWith('\x1b[200~', end)
-                && !combined.startsWith('\x1b[201~', end)) {
-                end += 1;
-            }
-            if (end > index) {
-                const part = combined.slice(index, end);
-                if (this.inPaste)
-                    this.handlePasteText(part);
-                else
-                    this.handlePlainText(part);
-                index = end;
-            }
-            else {
-                index += 1;
-            }
+    /**
+     * The Router's read-only view, rewritten per decision (no allocation).
+     *
+     * The card question is the only expensive one — `collapsibleRows()` walks the
+     * visible transcript — so it is answered only for the arrow that asks it, and only
+     * when nothing is layered over the workspace.
+     */
+    observe(kind, unit) {
+        const view = this.ownershipView;
+        const screen = this.screen;
+        const surface = this.dialog;
+        view.screenKind = screen?.kind;
+        view.surfaceKind = surface?.kind;
+        view.surfaceHasField = this.borrowedText !== undefined;
+        view.composerEmpty = this.fieldText() === '';
+        view.workspaceCards = screen === undefined && surface === undefined
+            && kind === 'sequence'
+            && (unit === '\x1b[A' || unit === '\x1b[B')
+            && view.composerEmpty
+            && this.collapsibleRows().length > 0;
+    }
+    /**
+     * Whether a read is one of the sequence shapes the ladder claims as a whole.
+     *
+     * These are matched *before* the Reader's hold window — the order the ladder always
+     * had (`ESC [ 5 ~` is a page key, not a prefix that might still grow).
+     */
+    isSequenceShape(unit) {
+        return /^\x1b\[[A-D]$/u.test(unit)
+            || SGR_MOUSE_RE.test(unit)
+            || unit === '\x1b[5~' || unit === '\x1b[6~'
+            || unit === '\x1b[H' || unit === '\x1b[1~' || unit === '\x1b[F' || unit === '\x1b[4~'
+            || unit === '\x1b[3~' || unit === '\x1b[99;6u';
+    }
+    /** The unit class of one read, by shape (the Reader's classification, allocation-free). */
+    readKind(combined) {
+        if (combined === '\x1b')
+            return 'escape';
+        if (combined.length === 1)
+            return combined < ' ' || combined === '\x7f' ? 'control' : 'text';
+        return combined.startsWith('\x1b') ? 'sequence' : 'text';
+    }
+    /** The unit class of one character — what `handleChar` routes. */
+    charKind(char) {
+        if (char === '\x1b')
+            return 'escape';
+        return char < ' ' || char === '\x7f' ? 'control' : 'text';
+    }
+    /** One unit, one owner: the Router decides, the owner adapter runs it. */
+    dispatch(kind, unit, moved) {
+        this.observe(kind, unit);
+        this.dispatchWith(this.router.route(kind, unit, this.ownershipView), unit, moved);
+    }
+    /** Run a unit at the owner the Router already named. */
+    dispatchWith(owner, unit, moved) {
+        switch (owner) {
+            case 'screen':
+                this.ownerScreen(unit, moved);
+                return;
+            case 'surface':
+                this.ownerSurface(unit, moved);
+                return;
+            case 'composer':
+                this.ownerComposer(unit, moved);
+                return;
+            case 'workspace':
+                this.ownerWorkspace(unit, moved);
+                return;
         }
     }
     /**
-     * Insert pasted text into the field that owns the keyboard; CR/LF are literal
-     * newlines.
+     * A paste payload: the Router decides, the paste path executes.
      *
-     * A paste is text input, so it goes through the same ownership question ordinary
-     * typing does: into the composer's draft when the composer owns the keyboard, and
-     * into a borrowed field when a surface that has one does. A surface without a
-     * text field (a confirmation, a menu, a report) takes no paste at all — the
-     * alternative was writing the composer's hidden draft behind it, which is how a
-     * paste into an approval dialog could silently rewrite the message being written.
+     * A paste is text, so the field that owns the keyboard takes it — and a Screen that
+     * owns the interaction terminates it (its own field or nothing), never a field
+     * behind it (AD-20 §4.3 priority 1). `handlePasteText` still re-asks that per owner;
+     * that is the compat path W-3 folds into the Router (marked there).
+     */
+    dispatchPaste(text) {
+        this.observe('paste', text);
+        if (this.router.route('paste', text, this.ownershipView) === 'workspace')
+            return;
+        this.handlePasteText(text);
+    }
+    /**
+     * The Screen adapter: a Screen owns the keyboard outright (AD-20 §4.3 priority 3).
      *
-     * A **Screen** is that same question with a different answer, and it is asked
-     * first because `textIsEditable()` only ever answers for the composer's field: the
-     * setup Screen keeps a field of its own, which the composer's helpers cannot see
-     * and must never be handed (B2.6 §4).
+     * One unit goes in — the Reader split the read, so a Screen sees the same keys the
+     * composer would (W-3a) and `handleScreenInput` is where the paste-burst rule stays.
+     * Its own `screen === undefined` guard stays too: a release raced by a teardown
+     * reaches it, and refusing there is the adapter's own business rather than a second
+     * ownership decision.
      */
-    handlePasteText(text) {
-        const normalized = text.replaceAll('\r\n', '\n').replaceAll('\r', '\n');
-        if (normalized === '')
+    ownerScreen(unit, moved) {
+        this.handleScreenInput(unit, moved ?? this.keymap.sequences.get(unit));
+    }
+    /**
+     * The Surface adapter: a dialog owns the keyboard while it is up.
+     *
+     * Its arrows move a question's cursor (or nothing — an arrow a Surface does not use
+     * is not the transcript's), the page keys are not its business, and its mouse reports
+     * take the same path they always did so the refusal happens where it always did, down
+     * to the remembered press. Its own editing keys are `Home`/`End`/`Delete` (W-3b.1):
+     * they act on the field the Surface borrowed — the one row the reader can see — and a
+     * Surface that borrowed none has no field for them, so it consumes them. The kitty
+     * copy key falls out with the other sequences below: a Surface has no copy contract,
+     * and this round did not invent one. Everything else goes to the shared
+     * composer/Surface body, whose `dialog` branches are the Surface's own behaviour.
+     */
+    ownerSurface(unit, moved) {
+        if (unit === '\x1b[A') {
+            this.moveQuestionCursor(-1);
             return;
-        if (this.screen !== undefined) {
-            this.pasteIntoScreen(normalized);
+        }
+        if (unit === '\x1b[B') {
+            this.moveQuestionCursor(1);
             return;
         }
-        if (!this.textIsEditable())
+        const sgr = SGR_MOUSE_RE.exec(unit);
+        if (sgr !== null) {
+            const button = Number(sgr[1]);
+            if (button === 64 || button === 65)
+                return;
+            this.mouseGesture(sgr);
             return;
-        this.leaveHistoryBrowse();
-        const current = this.fieldText();
-        const at = this.fieldCursor();
-        this.setField(`${current.slice(0, at)}${normalized}${current.slice(at)}`, at + normalized.length);
-        if (this.borrowedText === undefined) {
-            const cols = Math.max(10, this.screenColumns());
-            const lineWidth = Math.max(1, cols - 2);
-            if (normalized.includes('\n') || displayWidth(this.fieldText()) > lineWidth)
-                this.inputFolded = true;
         }
-        this.markDirty();
+        if (unit === '\x1b[H' || unit === '\x1b[1~') {
+            this.moveFieldCursor('start');
+            return;
+        }
+        if (unit === '\x1b[F' || unit === '\x1b[4~') {
+            this.moveFieldCursor('end');
+            return;
+        }
+        if (unit === '\x1b[3~') {
+            // Only a borrowed field can be edited: the draft behind the Surface is not the
+            // field on screen, and an answer the reader cannot see is not an answer.
+            if (this.textIsEditable())
+                this.deleteAtCursor();
+            return;
+        }
+        if (unit.startsWith('\x1b[') || unit.startsWith('\x1bO'))
+            return;
+        this.composerUnit(unit, moved);
     }
     /**
-     * Give a paste to the field the Screen owns, or to nobody.
+     * The Composer adapter.
      *
-     * The setup Screen is the only Screen with a field, and it is the one place a
-     * paste matters most: an API key, a base URL and a model list are all copied from
-     * somewhere else, and a first run that could only be typed by hand is the
-     * difference between a working session and an empty one. A step without a field —
-     * the model pickers, the confirmation — is not a text field, so the paste is
-     * dropped exactly as a menu drops it: a paste is text, never an answer.
+     * Text — one character or many — is typed: the burst rule first, then one character
+     * at a time through the Router, which is what lets ownership change inside a single
+     * read (a Surface answering `y` with the composer taking the `es` behind it). The
+     * sequence shapes the composer owns are the arrows (the suggestion list, else
+     * history) and the caret keys — which it now only ever gets while it owns the
+     * keyboard: with a Surface up, the Router hands those keys to the Surface (W-3b.1).
      */
-    pasteIntoScreen(text) {
-        const state = this.onboarding;
-        if (this.screen?.kind !== 'setup' || state === undefined || state.saving)
+    ownerComposer(unit, moved) {
+        if (unit === '\x1b[A') {
+            this.arrowHistory(-1);
             return;
-        if (!SETUP_FIELD_STEPS.has(state.step))
+        }
+        if (unit === '\x1b[B') {
+            this.arrowHistory(1);
             return;
-        // The field is drawn on one row, so it takes the value and not the line breaks
-        // around it: a key copied off a web page carries the newline that ended its
-        // line, and a pasted list or `.env` block means the breaks as separators. Both
-        // are folded here rather than inserted literally, which would leave the field
-        // holding text no step can parse and no row can draw.
-        const flat = text.split('\n').map(part => part.trim()).filter(part => part !== '').join(' ');
-        if (flat === '')
+        }
+        if (unit === '\x1b[C') {
+            if (this.textIsEditable())
+                this.moveCursor(1);
             return;
-        this.setupInsert(state, flat);
-        this.markDirty();
+        }
+        if (unit === '\x1b[D') {
+            if (this.textIsEditable())
+                this.moveCursor(-1);
+            return;
+        }
+        // The caret keys go through the field the keyboard is editing, like Ctrl+A/Ctrl+E
+        // below: with no Surface up that field *is* the draft, so this is the write it
+        // always was — and it can no longer be the wrong field if a later round routes a
+        // unit here while a field is borrowed.
+        if (unit === '\x1b[H' || unit === '\x1b[1~') {
+            this.moveFieldCursor('start');
+            return;
+        }
+        if (unit === '\x1b[F' || unit === '\x1b[4~') {
+            this.moveFieldCursor('end');
+            return;
+        }
+        if (unit === '\x1b[3~') {
+            this.deleteAtCursor();
+            return;
+        }
+        if (unit === '\x1b[99;6u') {
+            this.copyKey();
+            return;
+        }
+        this.composerUnit(unit, moved);
     }
     /**
-     * Whether the keys that edit text belong to a field right now.
-     *
-     * The composer always has one; an open surface only has one when it borrowed it
-     * (a free-text answer). Everything else — a confirmation, a menu, the inspect
-     * overlay, every Screen — owns the keyboard without owning the composer's text,
-     * and those keys must do nothing rather than reach the draft behind the surface.
-     * A Screen is included by name: the setup Screen has a field of its own, and it
-     * is reached through the Screen's own keys, never through the composer's.
+     * The Workspace adapter: the transcript owns the mouse, the page keys and the focus
+     * ring — and the ring only when the Router said so (empty field, a card to land on).
      */
-    textIsEditable() {
-        if (this.screen !== undefined)
-            return false;
-        return this.dialog === undefined || this.borrowedText !== undefined;
+    ownerWorkspace(unit, moved) {
+        void moved;
+        const sgr = SGR_MOUSE_RE.exec(unit);
+        if (sgr !== null) {
+            const button = Number(sgr[1]);
+            if (button === 64) {
+                this.scrollWorkspace(3);
+                return;
+            }
+            if (button === 65) {
+                this.scrollWorkspace(-3);
+                return;
+            }
+            this.mouseGesture(sgr);
+            return;
+        }
+        const page = Math.max(3, Math.floor(this.screenRows() / 2));
+        if (unit === '\x1b[5~') {
+            this.scrollWorkspace(page);
+            return;
+        }
+        if (unit === '\x1b[6~') {
+            this.scrollWorkspace(-page);
+            return;
+        }
+        if (unit === '\x1b[A') {
+            this.moveFocus(-1);
+            return;
+        }
+        if (unit === '\x1b[B') {
+            this.moveFocus(1);
+            return;
+        }
     }
-    handlePlainText(text) {
-        // Fallback for terminals without bracketed paste: a burst of multiple line
-        // breaks in one chunk is a paste, not repeated Enter presses.
-        if (looksLikePasteBurst(text)) {
-            this.handlePasteText(text);
+    /** An arrow the composer keeps: the suggestion list while it is up, else history. */
+    arrowHistory(direction) {
+        if (this.suggestionsVisible()) {
+            this.suggestionIndex = direction < 0
+                ? Math.max(0, this.suggestionIndex - 1)
+                : Math.min(this.commandSuggestions.length - 1, this.suggestionIndex + 1);
+            this.markDirty();
             return;
         }
-        let previous = '';
-        for (const char of text) {
-            // Windows terminals may deliver Enter as CRLF; consume only the first half.
-            if (char === '\n' && previous === '\r') {
-                previous = char;
-                continue;
+        if (direction < 0)
+            this.historyBack();
+        else
+            this.historyForward();
+    }
+    /** Press, motion and release: selection, links and card toggles — the transcript's. */
+    mouseGesture(sgr) {
+        const button = Number(sgr[1]);
+        const x = Number(sgr[2]);
+        const y = Number(sgr[3]);
+        if (sgr[4] === 'M') {
+            // 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 must drag exactly like an unshifted one.
+            if (button === 32 || button === 36) {
+                this.extendMouseSelection(y, x);
+                return;
             }
-            if (char === '\r' && previous === '\n') {
-                previous = char;
-                continue;
+            if (button === 0 || button === 4) {
+                this.beginMouseSelection(y, x);
+                return;
             }
-            this.handleChar(char);
-            previous = char;
+            return;
         }
+        // A release ends either a drag (copy what it covered) or a plain click.
+        if (button === 0 || button === 4)
+            this.endMouseSelection(y, x);
     }
-    handleChar(char) {
-        // A Screen owns every key outright, and the gate comes first for the same reason
-        // `handleInputText` puts it first: the switch below spends its keys on the
-        // composer — Enter submits the draft, Backspace/Ctrl+U/Ctrl+K edit it, Ctrl+R
-        // folds the transcript behind the Screen. A Screen is not a dialog, so none of
-        // the `dialog === undefined` guards in that switch ever saw it, and every one of
-        // those keys used to reach a draft the reader could not see. The Screen decides
-        // what it uses (Enter and Ctrl+C close it, Esc leaves it, the wizard answers with
-        // them); anything it does not use is dropped, never forwarded (B2.6 §4).
-        if (this.screen !== undefined) {
-            this.handleScreenInput(char, this.keymap.sequences.get(char));
+    /**
+     * The composer/Surface body — the switch and the tail the ladder always had.
+     *
+     * It is shared by two adapters on purpose: its `dialog` guards *are* the Surface's
+     * behaviour for those keys (a borrowed field takes them, a field-less dialog refuses
+     * them), and splitting them is W-3's job. What the Router guarantees is that a Screen
+     * never reaches it, so every key below can only spend itself on a field the reader
+     * has in front of them — the composer's or a borrowed one. The unreachable second
+     * Screen gate the old body carried is gone with it (G-6).
+     */
+    composerUnit(unit, moved) {
+        void moved;
+        // A run of text is split and re-judged per code point; a single one — ASCII, CJK, or
+        // an astral character the Reader framed as one unit — falls through to the switch and
+        // its owner. Counting UTF-16 code units here sent `🚀` back into this method forever
+        // (W-3b.1b), which is why the test is by code point.
+        if (carriesMultipleCodePoints(unit)) {
+            this.handlePlainText(unit);
             return;
         }
-        switch (char) {
+        switch (unit) {
             case '\x1b':
                 this.handleEscape();
                 return;
@@ -11924,16 +12079,11 @@ export class SshTui {
             // exit semantics of its own, and falling through to the process exit left a
             // dialog on screen killing the session it was waiting for.
             case '\x04':
-                if (this.dialog === undefined && this.screen === undefined)
+                if (this.dialog === undefined)
                     void this.requestExit(0);
                 return;
             case '\x0c':
-                this.lastPaintRows = [];
-                this.lastChromeKey = '';
-                this.lastPaintWidth = 0;
-                this.lastPaintHeight = 0;
-                this.dirty = true;
-                this.render();
+                this.repaintNow();
                 return;
             case '\x01':
                 if (this.textIsEditable())
@@ -11965,11 +12115,11 @@ export class SshTui {
             // under it changed what a later copy would take while the screen showed
             // nothing of the sort.
             case '\x0e':
-                if (this.dialog === undefined && this.screen === undefined)
+                if (this.dialog === undefined)
                     this.moveFocus(1);
                 return;
             case '\x10':
-                if (this.dialog === undefined && this.screen === undefined)
+                if (this.dialog === undefined)
                     this.moveFocus(-1);
                 return;
             case '\x12':
@@ -11986,33 +12136,21 @@ export class SshTui {
                 this.markDirty();
                 return;
         }
-        // A Screen owns the keyboard here too. This is the path a plain character
-        // takes (`handleChar`), and the Screen branch must come first or a `y` typed at
-        // a Screen's confirmation would fall through to the composer behind it.
-        if (this.screen !== undefined) {
-            this.handleScreenInput(char, this.keymap.sequences.get(char));
-            return;
-        }
         if (this.dialog !== undefined) {
-            this.handleDialogChar(char);
+            this.handleDialogChar(unit);
             return;
         }
-        if (char === '\x07') {
-            if (this.dialog === undefined)
-                this.stepSearch(1);
+        if (unit === '\x07') {
+            this.stepSearch(1);
             return;
         }
-        if (char === '\x1f') {
-            if (this.dialog !== undefined)
-                return;
+        if (unit === '\x1f') {
             this.input = '/find ';
             this.cursor = this.input.length;
             this.markDirty();
             return;
         }
-        if (char === '\t') {
-            if (this.dialog !== undefined)
-                return;
+        if (unit === '\t') {
             if (this.suggestionsVisible()) {
                 const selected = this.commandSuggestions[this.suggestionIndex];
                 if (selected !== undefined) {
@@ -12029,14 +12167,154 @@ export class SshTui {
             this.markDirty();
             return;
         }
-        if (char >= ' ' && char !== '\x7f') {
+        if (unit >= ' ' && unit !== '\x7f') {
             if (!this.textIsEditable())
                 return;
             this.leaveHistoryBrowse();
-            this.insertIntoField(char);
+            this.insertIntoField(unit);
             this.markDirty();
         }
     }
+    /**
+     * Ctrl+L's repaint, in one place for the owners that share it (G-6).
+     *
+     * The Screen has its own implementation (`screenNeedsFullPaint`, because it repaints
+     * a Screen's frame); this one drops the cached rows so the next full frame is rebuilt
+     * from scratch. W-2 does not merge them — only a test that proves both owners repaint
+     * identically may (AD-20 §6) — but it does give the composer's copy a name.
+     */
+    repaintNow() {
+        this.lastPaintRows = [];
+        this.lastChromeKey = '';
+        this.lastPaintWidth = 0;
+        this.lastPaintHeight = 0;
+        this.dirty = true;
+        this.render();
+    }
+    /**
+     * Insert pasted text into the field that owns the keyboard; CR/LF are literal
+     * newlines.
+     *
+     * A paste is text input, so it goes through the same ownership question ordinary
+     * typing does: into the composer's draft when the composer owns the keyboard, and
+     * into a borrowed field when a surface that has one does. A surface without a
+     * text field (a confirmation, a menu, a report) takes no paste at all — the
+     * alternative was writing the composer's hidden draft behind it, which is how a
+     * paste into an approval dialog could silently rewrite the message being written.
+     *
+     * A **Screen** is that same question with a different answer, and it is asked
+     * first because `textIsEditable()` only ever answers for the composer's field: the
+     * setup Screen keeps a field of its own, which the composer's helpers cannot see
+     * and must never be handed (B2.6 §4).
+     */
+    handlePasteText(text) {
+        const normalized = text.replaceAll('\r\n', '\n').replaceAll('\r', '\n');
+        if (normalized === '')
+            return;
+        if (this.screen !== undefined) {
+            this.pasteIntoScreen(normalized);
+            return;
+        }
+        if (!this.textIsEditable())
+            return;
+        this.leaveHistoryBrowse();
+        const current = this.fieldText();
+        const at = this.fieldCursor();
+        this.setField(`${current.slice(0, at)}${normalized}${current.slice(at)}`, at + normalized.length);
+        if (this.borrowedText === undefined) {
+            const cols = Math.max(10, this.screenColumns());
+            const lineWidth = Math.max(1, cols - 2);
+            if (normalized.includes('\n') || displayWidth(this.fieldText()) > lineWidth)
+                this.inputFolded = true;
+        }
+        this.markDirty();
+    }
+    /**
+     * Give a paste to the field the Screen owns, or to nobody.
+     *
+     * The setup Screen is the only Screen with a field, and it is the one place a
+     * paste matters most: an API key, a base URL and a model list are all copied from
+     * somewhere else, and a first run that could only be typed by hand is the
+     * difference between a working session and an empty one. A step without a field —
+     * the model pickers, the confirmation — is not a text field, so the paste is
+     * dropped exactly as a menu drops it: a paste is text, never an answer.
+     */
+    pasteIntoScreen(text) {
+        const state = this.onboarding;
+        if (this.screen?.kind !== 'setup' || state === undefined || state.saving)
+            return;
+        if (!SETUP_FIELD_STEPS.has(state.step))
+            return;
+        // The field is drawn on one row, so it takes the value and not the line breaks
+        // around it: a key copied off a web page carries the newline that ended its
+        // line, and a pasted list or `.env` block means the breaks as separators. Both
+        // are folded here rather than inserted literally, which would leave the field
+        // holding text no step can parse and no row can draw.
+        const flat = text.split('\n').map(part => part.trim()).filter(part => part !== '').join(' ');
+        if (flat === '')
+            return;
+        this.setupInsert(state, flat);
+        this.markDirty();
+    }
+    /**
+     * Whether the keys that edit text belong to a field right now.
+     *
+     * The composer always has one; an open surface only has one when it borrowed it
+     * (a free-text answer). Everything else — a confirmation, a menu, the inspect
+     * overlay, every Screen — owns the keyboard without owning the composer's text,
+     * and those keys must do nothing rather than reach the draft behind the surface.
+     * A Screen is included by name: the setup Screen has a field of its own, and it
+     * is reached through the Screen's own keys, never through the composer's.
+     */
+    textIsEditable() {
+        if (this.screen !== undefined)
+            return false;
+        return this.dialog === undefined || this.borrowedText !== undefined;
+    }
+    handlePlainText(text) {
+        // Fallback for terminals without bracketed paste: a burst of multiple line
+        // breaks in one chunk is a paste, not repeated Enter presses.
+        if (InputReader.looksLikePasteBurst(text)) {
+            this.dispatchPaste(text);
+            return;
+        }
+        // A text unit is delivered one character at a time and each character is routed
+        // again — that is what lets ownership change inside one unit (a Surface answers `y`
+        // and the composer takes the `es` behind it, W-2). A Screen is the one owner that
+        // does not work that way: it owns the read it was sent, and the read-level guard in
+        // `handleInputText` drops the units after it closes. This is the same rule one level
+        // down, for the units that carry several characters: without it a character that
+        // closes the Screen — the `ESC` of a paste tail, a `q`, an Enter — ended the Screen
+        // and the rest of the same unit was typed into the composer behind it (W-3a.1).
+        const dismissals = this.screenDismissals;
+        let previous = '';
+        for (const char of text) {
+            if (this.screenDismissals !== dismissals)
+                return;
+            // Windows terminals may deliver Enter as CRLF; consume only the first half.
+            if (char === '\n' && previous === '\r') {
+                previous = char;
+                continue;
+            }
+            if (char === '\r' && previous === '\n') {
+                previous = char;
+                continue;
+            }
+            this.handleChar(char);
+            previous = char;
+        }
+    }
+    /**
+     * One character, from a read or from the typing loop: the Router decides, again.
+     *
+     * It is asked per character rather than per read because ownership can change inside
+     * one read — a Surface that answers the first character of `yes` is gone for the rest
+     * (pinned by the `yes-typed-at-dialog` trace). A Screen never reaches the body below:
+     * the Router answered `screen` and the Screen adapter took the character.
+     */
+    handleChar(char) {
+        this.dispatch(this.charKind(char), char, this.keymap.sequences.get(char));
+    }
     /**
      * Run one rebindable action.
      * @param action - the action the pressed key was moved to.
@@ -12044,11 +12322,14 @@ export class SshTui {
      */
     runKeyAction(action) {
         switch (action) {
+            // Only reachable with nothing layered over the workspace (the ladder asks this
+            // table first thing, and a Screen returns before it), so the target is the
+            // transcript — named here rather than re-derived inside a shared scroller.
             case 'pageUp':
-                this.scrollActiveSurface(Math.max(3, Math.floor(this.screenRows() / 2)));
+                this.scrollWorkspace(Math.max(3, Math.floor(this.screenRows() / 2)));
                 return true;
             case 'pageDown':
-                this.scrollActiveSurface(-Math.max(3, Math.floor(this.screenRows() / 2)));
+                this.scrollWorkspace(-Math.max(3, Math.floor(this.screenRows() / 2)));
                 return true;
             case 'toggleCard':
                 this.toggleCollapsible();
@@ -12864,7 +13145,7 @@ export class SshTui {
                     this.setupMessage(state, 'system', t('onboard.baseSaved', { path: displayDshPath('settings.yaml') }));
                 }
                 if (saved) {
-                    this.onboardDone(t('onboard.officialDone', { model }));
+                    await this.onboardDone(t('onboard.officialDone', { model }));
                 }
             }
             else {
@@ -13037,7 +13318,7 @@ export class SshTui {
                     this.onSelectionChanged?.(selection);
                     await this.rememberRoute(selection);
                     await this.syncSubagentToProvider(ownerId, state.models, previousParentProvider !== ownerId);
-                    this.onboardDone(t('onboard.customDone', { id: ownerId, model }));
+                    await this.onboardDone(t('onboard.customDone', { id: ownerId, model }));
                 }
             }
         }
@@ -13081,8 +13362,40 @@ export class SshTui {
      * answer: `command-status` routes to the transcript, exactly like the boot line
      * that asked for the setup in the first place.
      */
-    onboardDone(text) {
+    async onboardDone(text) {
+        const profile = profileFromArgv();
+        let repairNote;
+        try {
+            // The wizard wrote settings and the model selection through the profile
+            // patch. Only after those writes are complete does the agent-plane repair
+            // run, so it cannot be undone by the wizard's own patch update.
+            const repaired = await this.ensureProfileAgentPlane(profile);
+            if (repaired === 'written') {
+                repairNote = t('onboard.agentPlaneAdded', {
+                    path: rosterPatchPath(resolveDshHome(), profile),
+                    profile,
+                });
+            }
+            else if (this.settingsGeneration === 'forms' && !this.agentPlaneReady()) {
+                // The rows are there but this process was composed before them (or a
+                // row failed to activate). Saying "saved" alone would hide that the
+                // tools are still absent from this session.
+                repairNote = t('onboard.agentPlaneRestart', {
+                    path: rosterPatchPath(resolveDshHome(), profile),
+                    profile,
+                });
+            }
+        }
+        catch (error) {
+            repairNote = t('onboard.agentPlaneFailed', {
+                error: errorChain(error),
+                path: rosterPatchPath(resolveDshHome(), profile),
+            });
+        }
         this.pushRow(represent('command-status', { kind: 'system', text }));
+        if (repairNote !== undefined) {
+            this.pushRow(represent('runtime-warning', { kind: 'system', text: repairNote }));
+        }
         this.markDirty();
     }
     /** Store one credential, falling back to a launch-environment override on shadow/absence. */
@@ -13452,10 +13765,14 @@ export class SshTui {
         // *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;
-        this.leaveHistoryBrowse();
+        //
+        // **The composer's draft is not this function's to write** (input-ownership
+        // AD-20, F-2). It used to be: `this.input = ''` + caret + fold + the history
+        // browse reset sat here from the 0.5.5 era, when `/copy` was *text submitted
+        // from the composer* and clearing it was housekeeping. The command line is
+        // `runCommand`'s to consume (it clears the composer for every command), and the
+        // key, a drag, a link click and a Screen's copy are not commands at all — a
+        // reader who typed half a message and then copied a reply lost it.
         this.write(osc52Clipboard(text));
         this.pushRow(represent('copy-feedback', { kind: 'system', text: notice }));
         // The write is a request the terminal may ignore: VTE (GNOME/XFCE/…) has
@@ -13592,13 +13909,7 @@ export class SshTui {
      * inspect overlay owns the keyboard and takes no scroll at all: the transcript
      * behind a dialog must not move.
      */
-    scrollActiveSurface(up) {
-        if (this.screen !== undefined) {
-            this.scrollScreen(up);
-            return;
-        }
-        if (this.dialog !== undefined)
-            return;
+    scrollWorkspace(up) {
         if (this.paintTailBudget > 0) {
             this.paintTailBudget = 0;
             this.forceFullPaint = true;
@@ -13987,7 +14298,7 @@ export class SshTui {
                             break;
                         }
                         const targets = ids.map(id => SessionId(id));
-                        void subagents.drainContinuableChildren(this.agent, targets).then(() => {
+                        void drainChildSubagents(subagents, this.agent, targets).then(() => {
                             this.pushRow(represent('subagent-notice', { kind: 'system', text: t('sub.killRequested', { ids: ids.join(', ') }) }));
                             this.markDirty();
                         }).catch((error) => {
@@ -14167,13 +14478,21 @@ export class SshTui {
         this.inputFolded = false;
         this.markDirty();
     }
-    /** Grapheme cluster immediately before `cursor`; cursor-internal positions delete it whole. */
+    /**
+     * Grapheme cluster immediately before `cursor`; cursor-internal positions delete it whole.
+     *
+     * The cluster is measured in the field that owns the keyboard, like `backspace` and
+     * `deleteAtCursor` above, which is what makes their ranges mean the same thing as the
+     * cursor they were handed (W-3b.1b): segmenting the *draft* while editing a borrowed
+     * answer gave offsets from another string, so a borrowed `a🚀` lost one surrogate and
+     * kept the caret inside the pair.
+     */
     graphemeBefore(cursor) {
         if (cursor <= 0)
             return { start: 0, end: 0 };
         let previousStart = 0;
         let previousEnd = 0;
-        for (const segment of GRAPHEME_SEGMENTER.segment(this.input)) {
+        for (const segment of GRAPHEME_SEGMENTER.segment(this.fieldText())) {
             const start = segment.index;
             const end = start + segment.segment.length;
             if (cursor === start)
@@ -14185,9 +14504,9 @@ export class SshTui {
         }
         return { start: previousStart, end: previousEnd };
     }
-    /** Grapheme cluster containing or following `cursor`. */
+    /** Grapheme cluster containing or following `cursor`, in the field that owns the keyboard. */
     graphemeAfter(cursor) {
-        for (const segment of GRAPHEME_SEGMENTER.segment(this.input)) {
+        for (const segment of GRAPHEME_SEGMENTER.segment(this.fieldText())) {
             const start = segment.index;
             const end = start + segment.segment.length;
             if (cursor === start || (cursor > start && cursor < end))
@@ -14269,8 +14588,19 @@ export class SshTui {
         this.cursor = this.input.length;
         this.markDirty();
     }
-    /** Typing while browsing history detaches from the saved item. */
+    /**
+     * Typing while browsing history detaches from the saved item.
+     *
+     * The browse is the **composer's**, so only the composer's own field may end it
+     * (W-3b.3a). Every editing key a Surface borrowed the field for arrives here —
+     * `backspace`, `deleteAtCursor`, `handlePasteText`, and `composerUnit`'s Ctrl+U /
+     * Ctrl+K — and detaching on that path wrote the hidden composer's state from the
+     * visible answer: the recalled entry replaced `historyDraft`, so the unsent draft
+     * the browse was holding could never be reached again with `↓`.
+     */
     leaveHistoryBrowse() {
+        if (this.borrowedText !== undefined)
+            return;
         if (this.historyIndex >= 0 && this.historyIndex < this.history.length) {
             this.historyIndex = this.history.length;
             this.historyDraft = this.input;