dsh-ssh-tui 0.7.1 → 0.7.2

package/lib/tui.js

@@ -43,37 +43,74 @@ import { flattenGroups, groupPresets, optionMatches } from './preset-picker.js';
 import { isRefusal, planCopy, planDelete, planMetadata, presetDirectory, } from './preset-authoring.js';
 import { ensureRosterRows, planDuplicateRepair, planRosterRepair, rosterPatchPath, writePatchWithBackup, ROSTER_ROWS, } from './preset-rows.js';
 import { SessionStatsTracker, statsRowOf } from './stats.js';
-import { QUESTION_OPTION_KEYS, applyQuestionFilter, backspaceQuestionFilter, clearQuestionFilter, typeQuestionFilter, visibleQuestionIndexes, confirmAnswer, inspectClosesOn, moveQuestionCursor, optionsLength, questionSubmit, selectQuestionOptionByKey, } from './dialogs.js';
+import { QUESTION_OPTION_KEYS, applyQuestionFilter, backspaceQuestionFilter, clearQuestionFilter, typeQuestionFilter, visibleQuestionIndexes, confirmAnswer, inspectClosesOn, moveQuestionCursor, optionsLength, questionOptionIndex, questionSubmit, selectQuestionOptionByKey, } from './dialogs.js';
 import { commandSuggestions, localizedCommands } from './commands.js';
 import { archiveStalePlans, boundTranscriptRows, findLivePlanRow, findMergeableToolRow, findToolRowByCallId, mergeToolCard, planShouldDefaultExpand, windowTranscript, } from './rows.js';
 import { detachFromSshSession, DisplayHost, isTuiHostProcess, resolveDshHome, sessionSockPath } from './display-sock.js';
+import { sameSessionRoute, sessionRouteInput } from './session-route.js';
+import { GATEWAY_PROTOCOL_SUFFIX, GATEWAY_PROTOCOL_ENDPOINT, GATEWAY_PROTOCOL_PREFERENCE, advertisedProtocols, baseProviderIdOf, declaredProtocol, gatewayModelTable, gatewayServesModel, siblingProviderId, splitModelsByProtocol, } from './gateway-protocol.js';
 import { applySavedLocale, getLocale, localeDisplayName, localeFromTag, setLocale, t, UI_LOCALE_NAMESPACE, } from './i18n/index.js';
 import { defaultReasoningEffort } from './reasoning.js';
 import { checkForPluginUpdate, installPluginLatest } from './update-check.js';
 import { ROUTE_MEMORY_NAMESPACE, parseRouteMemory, rememberedRouteFor, upsertRememberedRoute, } from './route-memory.js';
 import { AGENT_DEFAULT_MODEL_SETTINGS_NAMESPACE } from '@deepseek-ai/dsh-agent-default-model';
-import { DEFAULT_SUBAGENT_MODEL, SUBAGENT_SETTINGS_NAMESPACE, defaultSubagentModelForProvider, subagentModelMatchesProvider, subagentSettingsValue, } from './subagent-model.js';
+import { DEFAULT_SUBAGENT_MODEL, SUBAGENT_SETTINGS_NAMESPACE, defaultSubagentModelForProvider, subagentModelMatchesProvider, subagentProviderDiffers, subagentSettingsValue, } from './subagent-model.js';
 import { resolveFreshSuperGrokToken } from './supergrok-token.js';
 import { copyTextFromRow, copyTextFromTranscript } from './copy-text.js';
+import { displayToolName, subagentCourtesyName } from './job-label.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 { TerminalInputGuard } from './terminal-input.js';
-import { contextPressureAlertText, contextPressureRingColor, contextPressureView, formatContextPressureRing, describeProviderRoute, fitFooterChips, fitFooterStatusLine, footerActivity, footerHealthChip, footerIdentityParts, footerStatsGroups, formatContextPressureChip, providerHasQuotaSurface, formatStatusReport, shortQuotaPlanName, formatTokens, parseContextPressure, promptPressureTokens, providerUsesLocalOAuth, shouldIdleAutoCompact, } from './footer.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';
-import { appendSubagentLog, applyTurnEndToPlan, cardCategoryLabel, cardCategoryOf, compactionHeaderText, formatCompactCommandError, isPromptInjectionMessage, matchTranscriptRows, parseFindQuery, parsePlanTodos, planCloseNudgeText, planMarkdownFromArgs, planDockNote, planIsLive, planTitleFromMarkdown, planTurnLeftOpen, promptInjectionSources, promptInjectionTitle, subagentHeaderText, todoItemKind, todoProgressLabel, TODO_STATUS_MARK, } from './plan.js';
-import { buildToolHeader, compactEditPath, compactFailureLines, compactFileStats, compactToolBursts, countDiffAddDel, countDiffLines, countOutputLines, diffMetaDiffs, diffStatToken, formatModelList, HIDDEN_TOOL_NAMES, parseExitStatus, planReviewOf, presentToolCall, READ_TOOL_NAMES, SHELL_TOOL_NAMES, toolBodyFitsWorkspace, toolBodyLines, toolTitle, wrappedToolBodyLineCount, } from './tool-present.js';
+import { appendSubagentLog, foldSubagentUserLog, applyTurnEndToPlan, buildSubagentHeader, cardCategoryLabel, cardCategoryOf, clipSubagentActivity, compactionHeaderText, formatCompactCommandError, isPromptInjectionMessage, matchTranscriptRows, parseFindQuery, parsePlanTodos, planCloseNudgeText, planMarkdownFromArgs, planDockNote, planIsLive, planTitleFromMarkdown, planTurnLeftOpen, promptInjectionSources, promptInjectionTitle, describeSubagentFailure, subagentChipSummary, subagentDisplayName, subagentInspectLines, subagentRowFromSpawnTool, todoItemKind, todoProgressLabel, TODO_STATUS_MARK, } from './plan.js';
+import { buildToolHeader, compactEditPath, compactFailureLines, compactFileStats, compactToolBursts, countDiffAddDel, countDiffLines, countOutputLines, diffMetaDiffs, diffStatToken, formatModelList, HIDDEN_TOOL_NAMES, parseExitStatus, planReviewOf, presentToolCall, READ_TOOL_NAMES, SHELL_TOOL_NAMES, SUBAGENT_TOOL_NAMES, toolBodyFitsWorkspace, toolBodyLines, toolTitle, wrappedToolBodyLineCount, } from './tool-present.js';
 export { clipAnsiToWidth, cursorVisualPosition, displayWidth, foldInputView, hrefAtColumn, osc52Clipboard, osc8Enabled, paintedLinkHits, fmtElapsedCompact, padAnsiToWidth, padToWidth, renderMarkdownLines, repeatToWidth, shimmerText, truncateToWidth, visibleWidth, waitCardCopy, waitSummaryFromReasoning, wrapWaitDetails, } from './term-text.js';
 export { captureHangupSignals, composePaintOutput, detectSshSession, formatLinkQualityChip, ignoreFurtherHangupSignals, isEscapePrefix, findCursorPositionReply, isHangupErrno, linkQualityOf, linkSignalPips, paintIntervalForRtt, paintLinkLabel, parseCursorPositionReply, pickerWindowStart, probeTerminalRttMs, releaseHangupSignals, resolvePaintIntervalMs, waitUntilIdleOrTimeout, writeBootSplash, } from './paint.js';
-export { CONTEXT_IDLE_COMPACT_RATIO, CONTEXT_PRESSURE_DANGER_RATIO, CONTEXT_PRESSURE_WARN_RATIO, CONTEXT_RING_EMPTY, CONTEXT_RING_SEGMENTS, contextPressureAlertText, contextPressureRingColor, contextPressureUsedTokens, contextPressureView, describeProviderRoute, dropFooterQuotaPlanName, fitFooterStatsLine, fitFooterStatusLine, footerActivity, footerIdentityParts, footerStatsGroups, formatContextPressureChip, formatContextPressureRing, formatContextPressureStatusLine, formatDuration, formatFooterQuota, formatQuotaBar, formatQuotaUnknown, formatStatusReport, providerHasQuotaSurface, quotaWindowTag, shortModelName, shortQuotaPlanName, formatTokens, formatTokensPerSecond, parseContextPressure, promptPressureTokens, providerShortCode, providerUsesLocalOAuth, shouldIdleAutoCompact, subagentRouteLabel, } from './footer.js';
+export { CONTEXT_IDLE_COMPACT_RATIO, CONTEXT_PRESSURE_DANGER_RATIO, CONTEXT_PRESSURE_WARN_RATIO, CONTEXT_RING_EMPTY, CONTEXT_RING_SEGMENTS, contextPressureAlertText, contextPressureRingColor, contextPressureUsedTokens, contextPressureView, describeProviderRoute, dropFooterQuotaPlanName, fitFooterStatsLine, fitFooterStatusLine, footerActivity, footerIdentityParts, footerStatsGroups, footerSubagentForeign, paintFooterSubagentChip, formatContextPressureChip, formatContextPressureRing, formatContextPressureStatusLine, formatDuration, formatFooterQuota, formatQuotaBar, formatQuotaUnknown, formatStatusReport, providerHasQuotaSurface, quotaWindowTag, shortModelName, shortQuotaPlanName, formatTokens, formatTokensPerSecond, parseContextPressure, promptPressureTokens, providerShortCode, providerUsesLocalOAuth, shouldIdleAutoCompact, subagentRouteLabel, } from './footer.js';
 export { commandCodePeriodStart, commandCodeSourceFor, crossedQuotaThresholds, formatAccountBalance, formatFooterBalance, formatOpenCodeGoUsage, formatQuotaSnapshot, formatQuotaStatusLine, joinUrl, openCodeSourceFor, parseCommandCodeQuota, parseDeepSeekBalance, parseOpenAiCompatibleBalance, parseOpenCodeGoQuota, parseSuperGrokBilling, preferredQuotaWindow, quotaAlertText, quotaRefreshEverySteps, quotaRefreshEveryTurns, remainingPercentFromUsed, tightestQuotaWindow, } from './quota.js';
 export { commandAcceptsAttachments, forEachSessionEvent, isAssistantStreamEvent, isTokenDeltaChunk, listPersistenceHeaders, inspectPersistenceSession, sessionEventType, sessionEvents, settingsNamespace, streamChunkOf, streamFirstTokenTime, streamFrameAttemptId, streamFrameOwner, } from './dsh-compat.js';
-export { applyTurnEndToPlan, askSummary, cardCategoryOf, compactionHeaderText, formatCompactCommandError, isPromptInjectionMessage, matchTranscriptRows, parseFindQuery, parsePlanTodos, planCloseNudgeText, planDockNote, planIsLive, planTitleFromMarkdown, planTurnLeftOpen, promptInjectionSources, promptInjectionTitle, subagentHeaderText, todoProgressLabel, todoSummary, } from './plan.js';
+export { applyTurnEndToPlan, askSummary, cardCategoryOf, compactionHeaderText, formatCompactCommandError, isPromptInjectionMessage, matchTranscriptRows, parseFindQuery, parsePlanTodos, planCloseNudgeText, planDockNote, planIsLive, planTitleFromMarkdown, planTurnLeftOpen, promptInjectionSources, promptInjectionTitle, buildSubagentHeader, clipSubagentActivity, describeSubagentFailure, subagentChipSummary, subagentDisplayName, subagentInspectLines, subagentRowFromSpawnTool, foldSubagentUserLog, todoProgressLabel, todoSummary, } from './plan.js';
 export { buildToolHeader, canMergeToolCall, compactEditPath, compactToolBursts, compactToolGroups, countDiffAddDel, countDiffLines, countOutputLines, diffMetaDiffs, diffStatToken, friendlyJsonLines, parseExitStatus, presentToolCall, READ_TOOL_NAMES, renderToolDiff, toolBodyFitsWorkspace, toolBodyLines, toolStateColor, toolStateLabel, wrappedToolBodyLineCount, } from './tool-present.js';
 function discoverProviderModels(llm, request, signal) {
     return llm.discoverModels(settingsNamespace('llm-pi-ai'), { ...request, signal }, signal);
 }
+/**
+ * Ask a gateway which routes each of its models answers (`supported_endpoints`
+ * in an OpenAI-shaped `GET {baseURL}/models` reply). Command Code publishes
+ * them; most gateways do not, and the split then falls back to the built-in
+ * table. Best-effort by design: no key, no field, a network error or a shape we
+ * do not recognise all mean "no answer", never a failed setup.
+ */
+async function fetchModelEndpoints(baseURL, apiKey, signal) {
+    if (baseURL === '' || apiKey === '')
+        return undefined;
+    try {
+        const response = await fetch(`${baseURL.replace(/\/+$/u, '')}/models`, {
+            headers: { authorization: `Bearer ${apiKey}`, accept: 'application/json' },
+            // An outer signal (a picker that must not stall) wins when it is shorter.
+            signal: signal ?? AbortSignal.timeout(10_000),
+        });
+        if (!response.ok)
+            return undefined;
+        const body = (await response.json());
+        const endpoints = new Map();
+        for (const entry of body.data ?? []) {
+            const id = typeof entry?.id === 'string' ? entry.id : '';
+            const list = Array.isArray(entry?.supported_endpoints)
+                ? entry.supported_endpoints.filter((value) => typeof value === 'string')
+                : [];
+            if (id !== '' && list.length > 0)
+                endpoints.set(id, list);
+        }
+        return endpoints.size === 0 ? undefined : endpoints;
+    }
+    catch {
+        return undefined;
+    }
+}
 function installUserQuestionAnswerer(ctx, questions, ask) {
     const provider = questions;
     if (typeof provider.registerProvider === 'function') {
@@ -105,20 +142,27 @@ function providerTemplates() {
             defaultBaseUrl: 'https://api.deepseek.com',
             defaultModels: ['deepseek-v4-pro', 'deepseek-v4-flash'],
         },
+        // One row, both routes: the wizard files each model under the protocol it
+        // speaks (the gateway publishes `supported_endpoints`, and its pinned
+        // defaults are verified on responses), so nobody has to pick a protocol by
+        // hand or discover later that half the catalogue needs the other one.
         'opencode-go': {
             label: t('onboard.providerGo'),
             defaultId: 'opencode-go',
             defaultBaseUrl: 'https://opencode.ai/zen/go/v1',
             api: 'openai-responses',
+            protocols: ['openai-responses', 'openai-completions', 'anthropic-messages'],
             defaultModels: ['deepseek-v4-flash', 'deepseek-v4-pro'],
         },
-        // A fixed provider: its chat route is OpenAI-completions, but billing uses
-        // Command Code's own `/alpha/billing/credits` surface on the API root.
+        // Same shape for Command Code: its chat route bills through the API root's
+        // `/alpha/billing/credits`, and its catalogue is split across three
+        // protocols, which the splitter reads off `GET /provider/v1/models`.
         'command-code': {
             label: t('onboard.providerCommandCode'),
             defaultId: 'command-code',
             defaultBaseUrl: 'https://api.commandcode.ai/provider/v1',
-            api: 'openai-completions',
+            api: 'openai-responses',
+            protocols: ['openai-responses', 'openai-completions', 'anthropic-messages'],
             defaultModels: ['deepseek/deepseek-v4.1-flash'],
             defaultModelCapacity: { 'deepseek/deepseek-v4.1-flash': { contextWindow: 1_048_576 } },
         },
@@ -160,6 +204,23 @@ function onboardTemplate(state) {
     }
     return providerTemplates()[state.providerType];
 }
+/**
+ * The wizard steps that choose models, however they are presented: the id
+ * prompt, the multi-select picker, and the session-model pick.
+ */
+function isModelsStep(step) {
+    return step === 'models' || step === 'models-pick' || step === 'model-default';
+}
+/**
+ * How long a compaction may claim to be running before it is treated as
+ * abandoned. A real one finishes in seconds to a couple of minutes; the Host
+ * dying mid-compaction leaves `compaction/start` in the log with no end, and
+ * that row would otherwise keep the footer on 压缩中 and refuse /compact for
+ * the rest of the session's life.
+ */
+const COMPACTION_STALE_MS = 15 * 60_000;
+/** How many `<family>\0<model>` → row decisions are remembered. */
+const FAMILY_OWNER_CACHE_MAX = 512;
 /**
  * A short duration in the shortest useful unit: `12s` / `3m` / `1h`.
  * Locale-neutral on purpose — it reads the same in both catalogs.
@@ -204,6 +265,17 @@ const PLUGIN_VERSION = (() => {
 })();
 /** Files named on a collapsed compact burst before the rest are counted. */
 const MAX_COMPACT_FILE_STATS = 4;
+/** Lines of an inspect body that line mode writes into the log before trimming. */
+const LINE_MODE_INSPECT_LINES = 80;
+/**
+ * Emphasis inside a filled diff row: a lighter shade of the row's own fill, so
+ * a changed word is marked without stepping outside the muted palette. The
+ * fills they lighten live in `styleLine` (`diff-add` / `diff-del`).
+ */
+const DIFF_EMPHASIS_SGR = {
+    'diff-add': '38;2;198;232;190;48;2;34;72;44',
+    'diff-del': '38;2;246;206;206;48;2;86;34;34',
+};
 const STALL_WARNING_MS = 60000;
 /** Bytes already queued for the terminal before a frame is skipped instead. */
 const STDOUT_BACKLOG_BYTES = 32 * 1024;
@@ -478,6 +550,22 @@ export function parseWorkspaceView(raw) {
     return undefined;
 }
 const GRAPHEME_SEGMENTER = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/** One line naming the route a resumed session came back on. */
+function sessionRouteNotice(route) {
+    const effort = route.reasoningEffort === undefined || route.reasoningEffort === ''
+        ? ''
+        : ` (${route.reasoningEffort})`;
+    const subagent = route.subagent;
+    const sub = subagent === undefined
+        ? ''
+        : t('session.routeSubagent', {
+            route: `${subagent.provider === undefined ? '' : `${subagent.provider}/`}${subagent.model}`
+                + (subagent.reasoningEffort === undefined || subagent.reasoningEffort === ''
+                    ? ''
+                    : `(${subagent.reasoningEffort})`),
+        });
+    return t('session.routeRestored', { route: `${route.provider}/${route.model}${effort}`, sub });
+}
 /** Owns one interactive terminal channel and its agent event wiring. */
 export class SshTui {
     ctx;
@@ -500,6 +588,19 @@ export class SshTui {
     catalogLoad;
     /** Memoized id→window index over {@link catalogPresets}. */
     catalogWindows;
+    /** Wizard drafts whose models step is already asking the gateway, so a
+     *  second Enter cannot start a duplicate listing. */
+    finishingModels = new WeakSet();
+    /** `<base>\0<model>` → the family row last seen serving that model. */
+    /**
+     * `<base>\0<model>` → the family row last seen serving that model.
+     *
+     * Bounded: a gateway can publish hundreds of models and their rows are
+     * re-learned on every listing, so the oldest entries are dropped once the map
+     * passes FAMILY_OWNER_CACHE_MAX rather than growing for the life of the
+     * session. Losing an entry only costs one future "which row?" lookup.
+     */
+    familyModelOwner = new Map();
     input = '';
     cursor = 0;
     inputFolded = false;
@@ -545,10 +646,13 @@ export class SshTui {
     selectionRef;
     subagentSelection;
     onSelectionChanged;
+    onRouteSettled;
     disposers = [];
     userQuestionDisposer;
     presetId = 'standard';
     presetName = t('mode.preset.standard');
+    /** Last route reported to the launcher; a repaint must not report it again. */
+    lastSessionRoute;
     useAlternateScreen;
     agentGone = false;
     onboarding;
@@ -564,6 +668,8 @@ export class SshTui {
     seenCommandDoneIds = new Set();
     activeSubagents = new Map();
     subagentSessions = new Set();
+    /** Parent `subagent` tool descriptions waiting for the matching child card. */
+    pendingSubagentTasks = [];
     openToolCalls = new Map();
     /** Survives result settlement so a card-less result can still be labelled. */
     toolCallNames = new Map();
@@ -711,6 +817,7 @@ export class SshTui {
         // 8-colour terminal is not a cosmetic loss, it is the wrong colour.
         this.colorDepth = config.color === false ? 'none' : colorDepth(process.env);
         this.color = this.colorDepth !== 'none';
+        this.lastSessionRoute = config.restoredRoute;
         this.maxToolOutputLines = Math.max(1, config.maxToolOutputLines ?? 6);
         this.showReasoning = config.showReasoning !== false;
         this.workspaceView = this.readWorkspaceView();
@@ -723,6 +830,7 @@ export class SshTui {
         this.selectionRef = config.selectionRef;
         this.subagentSelection = config.subagentSelection ?? { current: { model: DEFAULT_SUBAGENT_MODEL } };
         this.onSelectionChanged = config.onSelectionChanged;
+        this.onRouteSettled = config.onRouteSettled;
         this.onHangup = config.onHangup;
         this.onReattach = config.onReattach;
         this.headlessDisplay = config.headlessDisplay === true;
@@ -758,6 +866,12 @@ export class SshTui {
         if (config.cwdNotice !== undefined && config.cwdNotice !== '') {
             this.pushRow({ kind: /进入|Entered/u.test(config.cwdNotice) ? 'system' : 'error', text: config.cwdNotice });
         }
+        if (config.restoredRoute !== undefined) {
+            this.pushRow({ kind: 'system', text: sessionRouteNotice(config.restoredRoute) });
+        }
+        for (const notice of config.launchNotices ?? []) {
+            this.pushRow({ kind: notice.kind, text: notice.text });
+        }
     }
     /** Enter raw mode, switch to the alternate screen, and start listening. */
     start() {
@@ -772,7 +886,12 @@ export class SshTui {
         });
         if (this.headlessDisplay) {
             this.displayDetached = true;
-            this.startRenderTimer();
+            // Line mode has no frames and no window title. The Host still listens on
+            // the display socket; typing arrives as FRAME_STDIN, not process.stdin.
+            // Starting the paint timer here is what leaked OSC titles into the log
+            // (`\x1b]0;dsh …\x07`) the moment a turn began.
+            if (!this.lineMode)
+                this.startRenderTimer();
             this.bootBackgroundTasks();
             return;
         }
@@ -787,10 +906,8 @@ export class SshTui {
         process.stdout.on('error', this.handleIoError);
         process.stdin.on('error', this.handleIoError);
         if (this.lineMode) {
-            // Typing still works — commands are how the user drives the session — but
-            // there is no screen to paint and no animation to run.
-            process.stdin.setRawMode(true);
-            process.stdin.resume();
+            // Direct (non-Host) line mode: typing still works, but there is no
+            // screen to paint and no animation to run.
             process.stdin.on('data', this.handleData);
             this.bootBackgroundTasks();
             return;
@@ -1072,8 +1189,8 @@ export class SshTui {
             const collapsed = truncateToWidth(header.plain, Math.max(1, width - 2));
             const styled = headerSegments.length === 0
                 ? this.styleLine('tool', collapsed)
-                : paintSegmentedLine(collapsed, 0, collapsed.length, headerSegments);
-            addDisplay(this.focusedRow === anchor && this.color ? `\x1b[7m${styled}\x1b[27m` : styled, anchor);
+                : paintSegmentedLine(collapsed, 0, collapsed.length, headerSegments, this.colorDepth);
+            addDisplay(this.selectLine(styled, this.focusedRow === anchor), anchor);
             // A collapsed burst is all the reader sees, so the two things that decide
             // whether to expand belong on it: which files moved, and what failed.
             if (kind === 'edits') {
@@ -1094,9 +1211,9 @@ export class SshTui {
         }
         const expandedHeaderLines = headerSegments.length === 0
             ? wrap(header.plain, width).map(line => this.styleLine('tool', line))
-            : wrapSegmented(header.plain, Math.max(1, width), headerSegments);
+            : wrapSegmented(header.plain, Math.max(1, width), headerSegments, this.colorDepth);
         for (const wrapped of expandedHeaderLines) {
-            addDisplay(this.focusedRow === anchor && this.color ? `\x1b[7m${wrapped}\x1b[27m` : wrapped, anchor);
+            addDisplay(this.selectLine(wrapped, this.focusedRow === anchor), anchor);
         }
         for (const item of items) {
             if (kind === 'edits') {
@@ -1132,7 +1249,7 @@ export class SshTui {
                     || (row.kind === 'question' && row.status === 'waiting')
                     || (row.kind === 'plan' && (row.active || row.pending || row.todos.some(item => item.status === 'in_progress')))
                     || (row.kind === 'goal' && (row.phase === 'active' || row.phase === 'blocked'))
-                    || (row.kind === 'compaction' && row.status === 'running'));
+                    || (row.kind === 'compaction' && this.compactionRunning()));
             if (animating && now - this.lastPaintAt >= Math.max(this.paintIntervalMs, 200)) {
                 this.dirty = true;
             }
@@ -1186,6 +1303,14 @@ export class SshTui {
         finally {
             this.replaying = false;
             this.replayQueue = undefined;
+            // Replay synthesizes chips from parent spawn tools; it never sees
+            // `subagent/start`, so those descriptions must not sit in the live queue
+            // and become the next child's courtesy name after --resume.
+            this.pendingSubagentTasks = [];
+            this.settleUnfinishedReplayChips();
+            // A compaction whose start has no end anywhere in the durable log was
+            // abandoned by the Host; nothing more can arrive for it.
+            this.settleUnfinishedCompactions();
         }
         for (const item of parked) {
             if (this.disposed)
@@ -1200,6 +1325,36 @@ export class SshTui {
         this.paintTailBudget = Math.max(24, this.screenRows() * 3);
         this.dirty = true;
     }
+    /**
+     * Close the chips replay could not settle.
+     *
+     * A spawn `tool/call` with no `tool/result` in the log means the wrapper was
+     * still in flight when the log was last written. Replay only runs in a Host
+     * that has just started, and the child lived in the Host running back then,
+     * so that child is gone and no `subagent/end` will ever arrive for it.
+     * Leaving the chip "running" made every resume of an interrupted turn show a
+     * child counting up forever while `/status` reported none.
+     *
+     * `stopReason: 'unknown'` is also what lets a late live end adopt this row
+     * instead of adding a twin beside it.
+     */
+    settleUnfinishedReplayChips() {
+        if (this.disposed)
+            return;
+        for (const row of this.rows) {
+            if (row.kind !== 'subagent')
+                continue;
+            if (row.status !== 'running' || row.childSessionId !== undefined)
+                continue;
+            row.status = 'aborted';
+            row.endedAt = row.startedAt;
+            row.stopReason = 'unknown';
+            const text = t('sub.endedMissing');
+            row.lastActivity = text;
+            appendSubagentLog(row, { kind: 'system', text });
+            this.refreshOpenSubagentInspect(row);
+        }
+    }
     /** Show the first-launch provider/API-key onboarding when nothing is configured. */
     async maybeRunOnboarding() {
         const credentials = this.ctx.get('credentials');
@@ -1269,6 +1424,9 @@ export class SshTui {
                 baseUrl: '',
                 key: '',
                 models: [],
+                modelCandidates: [],
+                modelChecked: new Set(),
+                modelCursor: 0,
                 modelCapacity: new Map(),
                 catalogPresets: undefined,
                 catalog: undefined,
@@ -1344,18 +1502,24 @@ export class SshTui {
         catch {
             // ignore
         }
-        try {
-            process.stdout.write('\x1b]0;\x07');
-            process.stdout.write('\x1b[0m\x1b[2J\x1b[3J\x1b[H');
-            process.stdout.write(`\x1b[?1000l\x1b[?1002l\x1b[?1006l\x1b[?2004l\x1b[?25h${this.useAlternateScreen ? '\x1b[?1049l' : ''}`);
-        }
-        catch (error) {
-            if (!isHangupErrno(error)) {
-                try {
-                    process.stderr.write(`dsh-ssh-tui: failed to restore terminal: ${errorChain(error)}\n`);
-                }
-                catch {
-                    // both pipes gone
+        // Line mode never entered the alternate screen or hid the cursor; writing
+        // the restore sequence here would dump CSI into a `tee` the moment SSH
+        // dropped. The Host's stdout is usually a discarded pipe, but the same
+        // path is shared with a direct (non-Host) line-mode process.
+        if (!this.lineMode) {
+            try {
+                process.stdout.write('\x1b]0;\x07');
+                process.stdout.write('\x1b[0m\x1b[2J\x1b[3J\x1b[H');
+                process.stdout.write(`\x1b[?1000l\x1b[?1002l\x1b[?1006l\x1b[?2004l\x1b[?25h${this.useAlternateScreen ? '\x1b[?1049l' : ''}`);
+            }
+            catch (error) {
+                if (!isHangupErrno(error)) {
+                    try {
+                        process.stderr.write(`dsh-ssh-tui: failed to restore terminal: ${errorChain(error)}\n`);
+                    }
+                    catch {
+                        // both pipes gone
+                    }
                 }
             }
         }
@@ -1461,7 +1625,7 @@ export class SshTui {
             ...(model === undefined ? {} : { model }),
             routes: Object.keys(providers),
             routeModels: models.map(modelEntryId).filter((id) => id !== undefined),
-            ...(sub.provider === undefined ? {} : { subProvider: sub.provider }),
+            ...(sub.provider === undefined ? {} : { subProvider: this.displayProviderId(sub.provider) }),
             ...(sub.model === undefined ? {} : { subModel: sub.model }),
         };
     }
@@ -1602,7 +1766,7 @@ export class SshTui {
             return true;
         if (this.llmRetry !== undefined)
             return true;
-        if (this.rows.some(row => row.kind === 'compaction' && row.status === 'running'))
+        if (this.compactionRunning())
             return true;
         return false;
     }
@@ -1928,7 +2092,8 @@ export class SshTui {
         this.paintRttMs = rttMs;
         if (!(Number.isFinite(envOverride) && envOverride > 0)) {
             this.paintIntervalMs = resolvePaintIntervalMs(undefined, {}, { ssh: true, rttMs });
-            this.startRenderTimer();
+            if (!this.lineMode)
+                this.startRenderTimer();
         }
         this.markDirty();
     }
@@ -2042,7 +2207,7 @@ export class SshTui {
             return false;
         if (this.streaming?.text)
             return false;
-        if (this.rows.some(row => row.kind === 'compaction' && row.status === 'running'))
+        if (this.compactionRunning())
             return false;
         if (this.dialog?.kind === 'questions' || this.dialog?.kind === 'confirm')
             return false;
@@ -2061,12 +2226,25 @@ export class SshTui {
             ...(liveTool === undefined ? {} : { toolTitle: liveTool.title, toolSummary: liveTool.summary }),
             ...(liveTool !== undefined || liveSub === undefined
                 ? {}
-                : { toolTitle: liveSub.label, toolSummary: liveSub.lastActivity }),
+                : { toolTitle: subagentDisplayName(liveSub), toolSummary: subagentChipSummary(liveSub) }),
             ...(this.streaming?.reasoning ? { reasoning: this.streaming.reasoning } : {}),
         };
     }
     findSubagentRow(sessionId) {
-        return this.rows.findLast((row) => row.kind === 'subagent' && row.sessionId === sessionId);
+        return this.rows.findLast((row) => row.kind === 'subagent' && (row.sessionId === sessionId || row.childSessionId === sessionId));
+    }
+    subagentInspectId(row) {
+        return row.childSessionId ?? row.sessionId;
+    }
+    /** Courtesy name for a child session; never the raw session hash. */
+    subagentNameFor(sessionId) {
+        const id = sessionId === undefined ? '' : String(sessionId);
+        if (id === '' || id === String(this.agent.id))
+            return t('approval.thisSession');
+        const row = this.findSubagentRow(id);
+        if (row !== undefined)
+            return subagentDisplayName(row);
+        return subagentCourtesyName({ sessionId: id, fallback: t('card.subagent') });
     }
     findLivePlanRow() {
         return findLivePlanRow(this.rows);
@@ -2254,7 +2432,7 @@ export class SshTui {
                 return;
             const body = buffer
                 .map(piece => (piece.emphasis
-                ? `\x1b[7m${this.styleLine(line.kind, piece.text)}\x1b[27m`
+                ? this.styleEmphasisedPiece(line.kind, piece.text)
                 : this.styleLine(line.kind, piece.text)))
                 .join('');
             rows.push(`  ${body}`);
@@ -2276,9 +2454,59 @@ export class SshTui {
         flush();
         return rows.length === 0 ? [this.styleLine(line.kind, '')] : rows;
     }
+    /**
+     * A body row whose parts carry different roles: the two columns of a
+     * side-by-side diff.
+     *
+     * No single kind fits such a row — the left column is a removal, the right an
+     * addition — so each part is painted with its own style, the gutter keeps the
+     * row's own (neutral) one, and a word emphasis rides inside whichever column
+     * it belongs to. The first column takes the leading indent and the last one
+     * runs to the end of the row, so both bars are flush.
+     */
+    styleColumnedLine(line, width) {
+        const indent = 2;
+        const padded = padToWidth(`  ${line.text}`, Math.max(1, width));
+        const cut = (at) => Math.max(0, Math.min(padded.length, at + indent));
+        const columns = (line.columns ?? []).map((column, index, all) => ({
+            start: index === 0 ? 0 : cut(column.start),
+            end: index === all.length - 1 ? padded.length : cut(column.end),
+            kind: column.kind,
+        }));
+        const cuts = new Set([0, padded.length]);
+        for (const span of line.spans ?? []) {
+            cuts.add(cut(span.start));
+            cuts.add(cut(span.end));
+        }
+        for (const column of line.columns ?? []) {
+            cuts.add(cut(column.start));
+            cuts.add(cut(column.end));
+        }
+        const ordered = [...cuts].sort((left, right) => left - right);
+        const pieces = [];
+        for (let at = 0; at + 1 < ordered.length; at += 1) {
+            const from = ordered[at] ?? 0;
+            const to = ordered[at + 1] ?? from;
+            if (to <= from)
+                continue;
+            const column = columns.find(item => item.start <= from && item.end >= to);
+            const emphasis = (line.spans ?? []).some(span => cut(span.start) <= from && cut(span.end) >= to);
+            const text = padded.slice(from, to);
+            const kind = column?.kind ?? line.kind;
+            pieces.push(emphasis ? this.styleEmphasisedPiece(kind, text) : this.styleLine(kind, text));
+        }
+        return pieces.length === 0 ? [this.styleLine(line.kind, '')] : [pieces.join('')];
+    }
     paintToolBodyLine(addDisplay, row, line, width) {
         const inner = Math.max(1, width - 2);
         const fillRow = line.kind === 'diff-add' || line.kind === 'diff-del';
+        // A line that holds two roles (the columns of a side-by-side diff) is
+        // painted part by part; its emphasis rides inside whichever part it is in.
+        if (line.columns !== undefined && line.columns.length > 0) {
+            for (const painted of this.styleColumnedLine(line, width))
+                addDisplay(painted, row);
+            return;
+        }
         // An emphasised line is styled in parts: the escapes wrap *styled* pieces,
         // because the painter's sanitiser strips any escape that reaches it inside
         // the text — which is how a literal `[7m` once appeared on screen.
@@ -2312,7 +2540,7 @@ export class SshTui {
         const dialog = this.dialog;
         if (dialog === undefined || dialog.kind !== 'inspect')
             return;
-        const header = this.styleLine('system', truncateToWidth(t('tool.inspectTitle', { title: dialog.title }), width));
+        const header = this.styleLine('system', truncateToWidth(dialog.title, width));
         const hint = this.styleLine('system', truncateToWidth(t('tool.inspectHint'), width));
         const divider = this.styleLine('system', repeatToWidth('─', width));
         const bodyBudget = Math.max(1, height - 4);
@@ -2323,18 +2551,19 @@ export class SshTui {
             for (const wrapped of wrap(line.text, inner)) {
                 const body = fillRow ? padToWidth(`  ${wrapped}`, width) : `  ${wrapped}`;
                 const kind = line.kind;
-                rendered.push(kind === 'diff-add' || kind === 'diff-del' || kind === 'diff-path'
-                    ? this.styleLine(kind, body)
-                    : kind === 'todo-done' || kind === 'todo-active' || kind === 'todo-pending'
-                        || kind === 'todo-failed' || kind === 'todo-skipped'
-                        ? this.styleLine(kind, body)
-                        : kind === 'error'
-                            ? this.styleLine('error', body)
-                            : kind === 'assistant'
-                                ? this.styleLine('assistant', body)
-                                : this.styleLine('tool-result', body));
+                const styled = this.styleLine(kind === 'subagent' ? 'subagent-header' : kind, body);
+                rendered.push(this.markSearchRow(styled, wrapped));
             }
         }
+        // `/find` reported a hit inside this body, so put it on screen: the overlay
+        // used to open at the top and leave the reader scrolling for it. Done once,
+        // so PgDn afterwards keeps the reader's own position.
+        if (dialog.searchRevealed !== true && this.searchNeedle !== '') {
+            const at = rendered.findIndex(row => searchContains(stripAnsi(row), this.searchNeedle));
+            if (at >= 0)
+                dialog.offset = Math.max(0, at - 1);
+            dialog.searchRevealed = true;
+        }
         const maxOffset = Math.max(0, rendered.length - bodyBudget);
         if (dialog.offset > maxOffset)
             dialog.offset = maxOffset;
@@ -2369,15 +2598,67 @@ export class SshTui {
         this.lastChromeStart = 0;
         this.lastTranscriptStart = -1;
     }
+    /**
+     * Reverse-video (or a `»` in monochrome) on the overlay row that holds the
+     * current `/find` needle, matching what the transcript does for the same hit.
+     */
+    markSearchRow(styled, plain) {
+        const needle = this.searchNeedle;
+        if (needle === '' || !searchContains(plain, needle))
+            return styled;
+        return this.color ? highlightAnsiNeedle(styled, needle) : `» ${styled}`;
+    }
     openToolInspect(row) {
         const lines = toolBodyLines(row, Number.MAX_SAFE_INTEGER);
+        const title = t('tool.inspectTitle', { title: `${row.title}${row.summary === '' ? '' : `  ${row.summary}`}` });
+        if (this.echoInspectToLog(title, lines))
+            return;
+        this.openDialog({
+            kind: 'inspect',
+            title,
+            lines,
+            offset: 0,
+        });
+    }
+    openSubagentInspect(row) {
+        const dialog = this.dialog;
+        if (dialog?.kind === 'inspect' && dialog.subagentSessionId === this.subagentInspectId(row)) {
+            dialog.title = t('sub.inspectTitle', { title: subagentDisplayName(row) });
+            dialog.lines = subagentInspectLines(row);
+            this.markDirty();
+            return;
+        }
+        const title = t('sub.inspectTitle', { title: subagentDisplayName(row) });
+        const lines = subagentInspectLines(row);
+        if (this.echoInspectToLog(title, lines))
+            return;
         this.openDialog({
             kind: 'inspect',
-            title: `${row.title}${row.summary === '' ? '' : `  ${row.summary}`}`,
+            title,
             lines,
             offset: 0,
+            subagentSessionId: this.subagentInspectId(row),
         });
     }
+    /**
+     * Line mode has no framed scroller, so an inspect body goes into the log.
+     *
+     * Opening the modal there printed nothing and then swallowed the next Enter:
+     * an invisible dialog. The log is the only detail surface line mode has, and
+     * writing it keeps the input free.
+     */
+    echoInspectToLog(title, lines) {
+        if (!this.lineMode)
+            return false;
+        const shown = lines.slice(0, LINE_MODE_INSPECT_LINES);
+        const body = [title, ...shown.map(line => line.text)];
+        if (lines.length > shown.length) {
+            body.push(t('tool.bodyMoreLines', { count: lines.length - shown.length }));
+        }
+        this.pushRow({ kind: 'system', text: body.join('\n') });
+        this.markDirty();
+        return true;
+    }
     closeInspect() {
         if (this.dialog?.kind !== 'inspect')
             return;
@@ -2395,12 +2676,12 @@ export class SshTui {
         if (!row.expanded) {
             const collapsed = truncateToWidth(plain, Math.max(1, width - 2));
             const styled = paint(collapsed);
-            addDisplay(focused && this.color ? `\x1b[7m${styled}\x1b[27m` : styled, row);
+            addDisplay(this.selectLine(styled, focused), row);
             return;
         }
         for (const wrapped of wrap(plain, width)) {
             const styled = paint(wrapped);
-            addDisplay(focused && this.color ? `\x1b[7m${styled}\x1b[27m` : styled, row);
+            addDisplay(this.selectLine(styled, focused), row);
         }
     }
     /** Move the expand/collapse focus among reasoning and tool rows. */
@@ -2434,13 +2715,31 @@ export class SshTui {
             return;
         this.toggleCard(target);
     }
+    /**
+     * Whether an inline tool body would be cut short.
+     *
+     * Two things stop a body short: it cannot fit the workspace, or the measured
+     * link is slow enough that the paint budget trims it. Both leave the reader
+     * looking at part of a diff under a header that counts all of it, and both
+     * are what the overlay is for — so both answers are the overlay, and the
+     * card's own `Enter 全览` hint stays true.
+     */
+    toolBodyTruncated(target, width, height) {
+        const body = toolBodyLines(target, Number.MAX_SAFE_INTEGER);
+        if (body.length > toolBodyLineLimit(linkQualityOf(this.paintLink, this.paintRttMs)))
+            return true;
+        return !toolBodyFitsWorkspace(wrappedToolBodyLineCount(body, width), this.workspaceRowsFor(width, height));
+    }
     toggleCard(target) {
-        if (target.kind === 'tool' && !target.expanded) {
+        if (target.kind === 'subagent') {
+            this.focusedRow = target;
+            this.openSubagentInspect(target);
+            return;
+        }
+        if (target.kind === 'tool') {
             const width = Math.max(10, this.screenColumns());
             const height = Math.max(6, this.screenRows());
-            const body = toolBodyLines(target, Number.MAX_SAFE_INTEGER);
-            const bodyRows = wrappedToolBodyLineCount(body, width);
-            if (!toolBodyFitsWorkspace(bodyRows, this.workspaceRowsFor(width, height))) {
+            if (this.toolBodyTruncated(target, width, height)) {
                 this.focusedRow = target;
                 this.openToolInspect(target);
                 return;
@@ -2467,6 +2766,8 @@ export class SshTui {
             const height = Math.max(6, this.screenRows());
             const workspace = this.workspaceRowsFor(width, height);
             for (const row of rows) {
+                if (row.kind === 'subagent')
+                    continue;
                 if (row.kind === 'tool') {
                     const bodyRows = wrappedToolBodyLineCount(toolBodyLines(row, Number.MAX_SAFE_INTEGER), width);
                     if (!toolBodyFitsWorkspace(bodyRows, workspace))
@@ -2519,12 +2820,15 @@ export class SshTui {
     revealRow(row) {
         if (row === undefined)
             return;
+        if (row.kind === 'subagent') {
+            this.focusedRow = row;
+            this.openSubagentInspect(row);
+            return;
+        }
         if (row.kind === 'tool') {
             const width = Math.max(10, this.screenColumns());
             const height = Math.max(6, this.screenRows());
-            const body = toolBodyLines(row, Number.MAX_SAFE_INTEGER);
-            const bodyRows = wrappedToolBodyLineCount(body, width);
-            if (!toolBodyFitsWorkspace(bodyRows, this.workspaceRowsFor(width, height))) {
+            if (this.toolBodyTruncated(row, width, height)) {
                 this.focusedRow = row;
                 this.openToolInspect(row);
                 return;
@@ -2696,7 +3000,7 @@ export class SshTui {
                 const header = t('reason.done', { marker, lines }) + (row.expanded ? '' : t('card.expand'));
                 const line = `${focused ? '▶ ' : '  '}${header}`;
                 const styled = this.styleLine('reasoning', line);
-                addDisplay(focused && this.color ? `\x1b[7m${styled}\x1b[27m` : styled, row);
+                addDisplay(this.selectLine(styled, focused), row);
                 if (row.expanded) {
                     for (const wrapped of wrap(row.text, width)) {
                         addDisplay(this.styleLine('reasoning', wrapped), row);
@@ -2727,13 +3031,13 @@ export class SshTui {
                     const collapsed = truncateToWidth(header.plain, Math.max(1, width - 2));
                     const styled = headerSegments.length === 0
                         ? collapsed
-                        : paintSegmentedLine(collapsed, 0, collapsed.length, headerSegments);
-                    addDisplay(focused && this.color ? `\x1b[7m${styled}\x1b[27m` : styled, row);
+                        : paintSegmentedLine(collapsed, 0, collapsed.length, headerSegments, this.colorDepth);
+                    addDisplay(this.selectLine(styled, focused), row);
                     continue;
                 }
                 const expandedHeaderLines = headerSegments.length === 0
                     ? wrap(header.plain, width)
-                    : wrapSegmented(header.plain, Math.max(1, width), headerSegments);
+                    : wrapSegmented(header.plain, Math.max(1, width), headerSegments, this.colorDepth);
                 for (const wrapped of expandedHeaderLines) {
                     addDisplay(wrapped, row);
                 }
@@ -2752,46 +3056,24 @@ export class SshTui {
             }
             if (row.kind === 'subagent') {
                 const running = row.status === 'running';
-                const ok = row.status === 'ok';
-                const aborted = row.status === 'aborted';
-                const dotColor = !this.color ? undefined : running ? '33' : ok ? '32' : aborted ? '33' : '31';
-                const styleHeader = (line) => {
-                    const safe = sanitizeTerminalText(line);
-                    if (!this.color)
-                        return safe;
-                    const dotIndex = safe.indexOf('●');
-                    if (dotColor === undefined || dotIndex === -1)
-                        return safe;
-                    return `${safe.slice(0, dotIndex)}\x1b[${dotColor}m●\x1b[0m${safe.slice(dotIndex + 1)}`;
-                };
-                const spinner = running ? ` ${this.spinnerFrame()}` : '';
-                const header = `● ${subagentHeaderText(row)}${spinner}${row.expanded ? '' : t('card.expand')}`;
-                this.paintCollapsibleHeader(addDisplay, row, 'system', header, width, styleHeader);
-                if (row.expanded) {
-                    addDisplay(this.styleLine('system', t('sub.cardSession', {
-                        id: row.sessionId,
-                        provider: row.provider,
-                        external: row.local ? '' : t('sub.external'),
-                    })), row);
-                    if (row.stopReason !== undefined) {
-                        addDisplay(this.styleLine('system', t('sub.stopReason', { reason: row.stopReason })), row);
-                    }
-                    if (row.logs.length === 0) {
-                        addDisplay(this.styleLine('system', running ? t('sub.cardWait') : t('sub.cardEmpty')), row);
-                    }
-                    else {
-                        for (const entry of row.logs) {
-                            const kind = entry.kind === 'assistant'
-                                ? 'assistant'
-                                : entry.kind === 'result' && row.status === 'error'
-                                    ? 'error'
-                                    : 'system';
-                            for (const wrapped of wrap(entry.text, Math.max(1, width - 2))) {
-                                addDisplay(this.styleLine(kind, `  ${wrapped}`), row);
-                            }
-                        }
-                    }
-                }
+                const elapsed = Math.max(0, Math.floor(((row.endedAt ?? Date.now()) - row.startedAt) / 1000));
+                const elapsedLabel = elapsed >= 60 ? `${Math.floor(elapsed / 60)}m${elapsed % 60}s` : `${elapsed}s`;
+                const header = buildSubagentHeader({
+                    focused: this.focusedRow === row,
+                    title: subagentDisplayName(row),
+                    status: row.status,
+                    elapsedLabel,
+                    summary: subagentChipSummary(row),
+                    spinner: running ? ` ${this.spinnerFrame()}` : '',
+                    inspectHint: t('card.inspect'),
+                    foreign: subagentProviderDiffers(this.currentProviderId(), row.modelProvider),
+                });
+                const headerSegments = this.color ? header.segments : [];
+                const collapsed = truncateToWidth(header.plain, Math.max(1, width - 2));
+                const styled = headerSegments.length === 0
+                    ? this.styleLine('subagent-header', collapsed)
+                    : paintSegmentedLine(collapsed, 0, collapsed.length, headerSegments, this.colorDepth);
+                addDisplay(this.selectLine(styled, this.focusedRow === row), row);
                 continue;
             }
             if (row.kind === 'plan') {
@@ -2922,7 +3204,7 @@ export class SshTui {
                     + (elapsed > 0 ? t('reason.elapsed', { seconds: elapsed }) : '');
                 const line = `${focused ? '▶ ' : '  '}${header}`;
                 const styled = this.styleLine('reasoning', line);
-                addDisplay(focused && this.color ? `\x1b[7m${styled}\x1b[27m` : styled, block);
+                addDisplay(this.selectLine(styled, focused), block);
                 if (block.expanded) {
                     for (const wrapped of wrap(this.streaming.reasoning, width)) {
                         addDisplay(this.styleLine('reasoning', wrapped), block);
@@ -3041,8 +3323,50 @@ export class SshTui {
                                 addDialog(t('onboard.ctrlF'));
                             if (ob.providerType === 'catalog')
                                 addDialog(t('onboard.modelsCatalogHint'));
+                            addDialog(t('onboard.modelsPickHint'));
                             addDialog(t('onboard.enterEsc'));
                             break;
+                        case 'models-pick': {
+                            const candidates = ob.modelCandidates ?? [];
+                            addDialog(t('onboard.providerLine', { label: providerLabel }));
+                            addDialog(t('onboard.modelsPick', { count: candidates.length }));
+                            const start = pickerWindowStart(ob.modelCursor ?? 0, candidates.length);
+                            const end = Math.min(candidates.length, start + PICKER_WINDOW);
+                            if (start > 0)
+                                addDialog(`  ${t('picker.moreAbove', { count: start })}`);
+                            for (let index = start; index < end; index += 1) {
+                                const id = candidates[index];
+                                if (id === undefined)
+                                    continue;
+                                const focused = index === (ob.modelCursor ?? 0) ? '›' : ' ';
+                                const mark = (ob.modelChecked ?? new Set()).has(index) ? '◉' : '○';
+                                addDialog(` ${focused} ${mark} ${id}`);
+                            }
+                            if (end < candidates.length)
+                                addDialog(`  ${t('picker.moreBelow', { count: candidates.length - end })}`);
+                            addDialog(t('onboard.modelsCheckHint'));
+                            break;
+                        }
+                        case 'model-default': {
+                            const checked = this.checkedOnboardingModels(ob);
+                            addDialog(t('onboard.providerLine', { label: providerLabel }));
+                            addDialog(t('onboard.defaultModelPick'));
+                            const start = pickerWindowStart(ob.modelCursor ?? 0, checked.length);
+                            const end = Math.min(checked.length, start + PICKER_WINDOW);
+                            if (start > 0)
+                                addDialog(`  ${t('picker.moreAbove', { count: start })}`);
+                            for (let index = start; index < end; index += 1) {
+                                const id = checked[index];
+                                if (id === undefined)
+                                    continue;
+                                const focused = index === (ob.modelCursor ?? 0) ? '›' : ' ';
+                                addDialog(` ${focused} ○ ${id}`);
+                            }
+                            if (end < checked.length)
+                                addDialog(`  ${t('picker.moreBelow', { count: checked.length - end })}`);
+                            addDialog(t('onboard.pickHint'));
+                            break;
+                        }
                         case 'context':
                             addDialog(t('onboard.providerLine', { label: providerLabel }));
                             addDialog(t('onboard.contextPrompt'));
@@ -3061,6 +3385,9 @@ export class SshTui {
                                 api: template.api ?? (ob.providerType === 'catalog' ? t('onboard.apiCatalog') : 'deepseek-official'),
                             }));
                             addDialog(t('onboard.confirmModels', { list: formatModelList(ob.models, 8) }));
+                            if (ob.defaultModel !== undefined) {
+                                addDialog(t('onboard.confirmDefaultModel', { model: ob.defaultModel }));
+                            }
                             if (ob.routeContextWindow !== undefined) {
                                 addDialog(t('onboard.confirmContext', { value: String(ob.routeContextWindow) }));
                             }
@@ -3158,8 +3485,8 @@ export class SshTui {
                 continue;
             const marker = index === this.suggestionIndex ? '›' : ' ';
             const line = `  ${marker} /${command.name.padEnd(14)} ${command.description}${command.local ? '' : '  (dsh)'}`;
-            suggestionLines.push(index === this.suggestionIndex && this.color
-                ? `\x1b[7m${fitLine(line)}\x1b[27m`
+            suggestionLines.push(index === this.suggestionIndex
+                ? this.selectLine(fitLine(line), true)
                 : this.styleLine('system', fitLine(line)));
         }
         if (suggestionEnd < this.commandSuggestions.length) {
@@ -3265,7 +3592,7 @@ export class SshTui {
             ? formatFooterBalance(this.balanceSnapshot)
             : undefined;
         const waitingQuestions = this.rows.some(row => row.kind === 'question' && row.status === 'waiting');
-        const compacting = this.rows.some(row => row.kind === 'compaction' && row.status === 'running');
+        const compacting = this.compactionRunning();
         const parentModel = current?.model ?? this.agent.options.model ?? '';
         const sub = this.subagentSelection.current;
         const footer = {
@@ -3289,7 +3616,7 @@ export class SshTui {
             provider,
             parentModel,
             subModel: sub.model,
-            ...(sub.provider === undefined ? {} : { subProvider: sub.provider }),
+            ...(sub.provider === undefined ? {} : { subProvider: this.displayProviderId(sub.provider) }),
             ...(sub.reasoningEffort === undefined ? {} : { subEffort: String(sub.reasoningEffort) }),
             // Quota and context pressure stay on the identity line, where they have
             // always been: B-1 moved them one row up into the strip, and a user
@@ -3326,11 +3653,18 @@ export class SshTui {
                 : activity.text;
         const identity = footerIdentityParts(footer);
         const statusText = fitFooterStatusLine(activityText, identity, Math.max(1, width));
-        // The context ring is the one accent on an otherwise muted line; the mute
-        // has to be resumed after its reset, exactly as the pre-strip footer did.
-        const statusLine = this.contextPressure === undefined || !this.color
-            ? this.styleLine('system', statusText)
-            : this.styleLine('system', statusText).replace(formatContextPressureRing(this.contextPressure.percent), `\x1b[${contextPressureRingColor(this.contextPressure.level)}m${formatContextPressureRing(this.contextPressure.percent)}\x1b[0m\x1b[90m`);
+        // Accents on an otherwise muted line: the context ring, then the `sub:`
+        // chip. Each reset reopens mute (`90`), the same way the pre-strip footer
+        // did. `styleLine` sanitises first, so the accents are spliced in after.
+        let statusLine = this.styleLine('system', statusText);
+        if (this.color && this.contextPressure !== undefined) {
+            const ring = formatContextPressureRing(this.contextPressure.percent);
+            statusLine = statusLine.replace(ring, `\x1b[${contextPressureRingColor(this.contextPressure.level)}m${ring}\x1b[0m\x1b[90m`);
+        }
+        if (this.color) {
+            const chip = identity.find(part => part.startsWith('sub:')) ?? '';
+            statusLine = paintFooterSubagentChip(statusLine, chip, footerSubagentForeign(footer), this.mutedSgr() || '90', this.colorDepth);
+        }
         // The strip: one loss order for the groups a narrow terminal can do without.
         // Health leads because it is the only group that reports a broken install;
         // the session counters go before the operational signals. Quota and context
@@ -3480,7 +3814,7 @@ export class SshTui {
     }
     currentSelectionLabel() {
         const current = this.selectionRef?.current;
-        const provider = this.currentProviderId();
+        const provider = this.displayProviderId(this.currentProviderId());
         const model = current?.model ?? this.agent.options.model ?? 'unknown';
         const effort = current?.reasoningEffort;
         const kind = describeProviderRoute(provider).short;
@@ -3492,7 +3826,7 @@ export class SshTui {
     }
     /** Refresh the terminal window title (throttled while running). */
     updateTerminalTitle() {
-        if (this.exiting)
+        if (this.exiting || this.lineMode)
             return;
         const now = Date.now();
         // Completion wins over a still-running agent status: the turn/end event
@@ -3503,16 +3837,20 @@ export class SshTui {
             this.write(t('title.done', { suffix: titleSuffix }));
             return;
         }
-        if (this.agent.status === 'running') {
+        // A compaction is work in progress even when it runs between turns (the
+        // idle auto-compact), so it keeps the spinner title the way a running turn
+        // does — the same rule the footer's activity chip follows.
+        const compacting = this.compactionRunning();
+        if (this.agent.status === 'running' || compacting) {
             if (now - this.lastTitleUpdateAt < 800)
                 return;
             this.lastTitleUpdateAt = now;
             const spinner = SPINNER[Math.floor(now / 800) % SPINNER.length];
-            let detail = t('title.running');
+            let detail = compacting ? t('title.compacting') : t('title.running');
             if (this.dialog?.kind === 'questions') {
                 detail = planReviewOf(this.dialog.question) ? t('question.planTitle') : t('title.waitAnswer');
             }
-            else if (this.rows.some(row => row.kind === 'compaction' && row.status === 'running')) {
+            else if (compacting) {
                 detail = t('title.compacting');
             }
             else if (this.activeSubagents.size > 0) {
@@ -3538,6 +3876,8 @@ export class SshTui {
     }
     /** Terminal bell on completion (opt out with DSH_TUI_NO_BELL=1). */
     playCompletionSignal() {
+        if (this.lineMode)
+            return;
         const disabled = process.env.DSH_TUI_NO_BELL === '1' || process.env.DSH_TUI_NO_BELL === 'true';
         if (disabled)
             return;
@@ -3999,15 +4339,50 @@ export class SshTui {
                                                     kind === 'todo-skipped' ? '2;33' :
                                                         kind === 'todo-pending' ? '90' :
                                                             kind === 'plan-dock' ? '38;5;180' :
-                                                                kind === 'diag' ? '2;36' :
-                                                                    kind === 'error' ? '31' :
-                                                                        '90';
+                                                                kind === 'subagent-header' ? '38;5;141' :
+                                                                    kind === 'diag' ? '2;36' :
+                                                                        kind === 'error' ? '31' :
+                                                                            '90';
         const code = downgradeSgr(requested, this.colorDepth);
         // Nothing left to paint: the text stands on its own.
         if (code === '')
             return safe;
         return `\x1b[${code}m${safe}\x1b[0m`;
     }
+    /**
+     * One emphasised piece of a body line — the words a diff changed.
+     *
+     * Inside a filled diff row the mark is a lighter shade of that same fill.
+     * Inverse video was there first, and it inverted the *fill*: a line replaced
+     * wholesale is emphasised from end to end, so it came out a bright block
+     * beside rows that kept the muted tone — visibly from another palette. On a
+     * terminal with no colour left to shift, the attribute is what survives, so
+     * the inverse video stays for that case.
+     */
+    styleEmphasisedPiece(kind, text) {
+        const requested = DIFF_EMPHASIS_SGR[kind];
+        if (requested !== undefined && this.color) {
+            const code = downgradeSgr(requested, this.colorDepth);
+            if (code !== '')
+                return `\x1b[${code}m${sanitizeTerminalText(text)}\x1b[0m`;
+        }
+        return `\x1b[7m${this.styleLine(kind, text)}\x1b[27m`;
+    }
+    /**
+     * Paint a row the reader has selected.
+     *
+     * The obvious `7`…`27` wrap only reaches the part before the line's first
+     * reset, and every painted segment ends with one: a focused card kept its
+     * marker and status dot highlighted while the title, the state word and the
+     * summary stayed plain, so ↑/↓ gave no visible clue which card was picked —
+     * on exactly the rows that carry a segmented header. Re-opening the attribute
+     * after every reset covers the whole row, whatever colours sit on top of it.
+     */
+    selectLine(styled, selected) {
+        if (!selected || !this.color)
+            return styled;
+        return `\x1b[7m${styled.replaceAll('\x1b[0m', '\x1b[0m\x1b[7m')}\x1b[27m`;
+    }
     /**
      * Fold one live or durable stream chunk into the in-progress assistant
      * row. 0.1.2 hosts append `assistant/chunk`; 0.1.5 emits the same chunk
@@ -4080,6 +4455,12 @@ export class SshTui {
      * The parent request is left untouched (its own `/model` waterfall already
      * owns the route); direct children created by tool-subagent inherit the
      * parent provider unless `/submodel` stored an explicit subagent provider.
+     *
+     * Effort is not inherited from the parent. `next()` copies the live parent
+     * config, so a grok-4.6 `xhigh` parent would otherwise send `xhigh` with
+     * the light grok-4.5 child and fail with UNSUPPORTED_REASONING_EFFORT
+     * before the child writes a closing message. An explicit `/subeffort`
+     * still wins; otherwise the child's own adapter default is used.
      */
     handleAgentRequest = async ({ agent }, next) => {
         const resolved = await next();
@@ -4088,14 +4469,23 @@ export class SshTui {
         const selection = this.subagentSelection.current;
         const parentProvider = this.selectionRef?.current?.provider ?? this.agent.options.provider ?? this.providerName;
         const provider = selection.provider ?? parentProvider;
-        const model = subagentModelMatchesProvider(provider, selection.model)
+        // A pinned provider keeps the stored model even when it is a different
+        // family from the parent. Only an inherited (follow-parent) route is
+        // rewritten onto a same-family default.
+        const model = selection.provider !== undefined || subagentModelMatchesProvider(provider, selection.model)
             ? selection.model
             : defaultSubagentModelForProvider(provider, [], this.selectionRef?.current?.model);
+        const { reasoningEffort: parentEffort, ...withoutParentEffort } = resolved;
+        // `/subeffort` wins. Otherwise keep the parent effort only when the child
+        // is still on that same model — grok-4.6 xhigh is legal on grok-4.6 and
+        // rejected on grok-4.5.
+        const effort = selection.reasoningEffort
+            ?? (model === resolved.model ? parentEffort : undefined);
         return {
-            ...resolved,
+            ...withoutParentEffort,
             provider,
             model,
-            ...(selection.reasoningEffort === undefined ? {} : { reasoningEffort: selection.reasoningEffort }),
+            ...(effort === undefined ? {} : { reasoningEffort: effort }),
         };
     };
     handleSessionEvent = (session, event) => {
@@ -4225,6 +4615,30 @@ export class SshTui {
                 this.statsTracker.noteToolStart(String(event.data.callId), event.time);
                 if (!HIDDEN_TOOL_NAMES.has(event.data.name)) {
                     const present = presentToolCall(event.data.name, event.data.arguments);
+                    if (SUBAGENT_TOOL_NAMES.has(event.data.name)) {
+                        const task = present.summary.trim();
+                        const callId = String(event.data.callId);
+                        // Replay never gets `subagent/start` to drain this queue, so only a
+                        // live spawn waits for its child card. The pair is dropped again at
+                        // `tool/result` when the spawn never started a child (denied,
+                        // cancelled): a description left behind would name the next child.
+                        if (task !== '' && !this.replaying)
+                            this.pendingSubagentTasks.push({ task, callId });
+                        if (this.replaying && !this.rows.some(candidate => candidate.kind === 'subagent' && candidate.runId === callId)) {
+                            // Live `subagent/start` is not in the parent log. Resume still
+                            // needs a courtesy chip; a live Host already has the real card.
+                            this.pushRow(subagentRowFromSpawnTool({
+                                callId,
+                                task,
+                                modelProvider: this.currentProviderId(),
+                                status: 'running',
+                                startedAt: typeof event.time === 'number' ? event.time : Date.now(),
+                            }));
+                        }
+                        this.streaming = undefined;
+                        this.markDirty();
+                        break;
+                    }
                     const previous = this.findMergeableToolRow({ name: event.data.name, args: event.data.arguments });
                     if (previous !== undefined) {
                         this.mergeIntoToolCard(previous, {
@@ -4267,8 +4681,30 @@ export class SshTui {
                 this.openToolCalls.delete(String(event.data.message.source.callId));
                 this.statsTracker.noteToolEnd(String(event.data.message.source.callId), event.time);
                 const callId = String(event.data.message.source.callId);
-                const row = this.findToolRowByCallId(callId);
+                // A spawn whose wrapper came back without starting a child (approval
+                // denied, provider refused, turn cancelled) must not leave its
+                // description queued: the next child would inherit that name.
+                this.pendingSubagentTasks = this.pendingSubagentTasks.filter(entry => entry.callId !== callId);
+                const spawnCard = this.rows.findLast((candidate) => candidate.kind === 'subagent' && (candidate.runId === callId || candidate.spawnCallId === callId));
                 const output = collectText(event.data.message.content);
+                if (spawnCard !== undefined) {
+                    // A live child already owns this spawn: the parent tool/result is
+                    // just the wrapper settling. Do not stamp a 0s twin chip complete.
+                    if (spawnCard.childSessionId !== undefined) {
+                        this.markDirty();
+                        break;
+                    }
+                    const failed = event.data.error !== undefined || event.data.message.content[0]?.isError === true;
+                    spawnCard.status = failed ? 'error' : 'ok';
+                    spawnCard.endedAt = typeof event.time === 'number' ? event.time : Date.now();
+                    if (output !== '') {
+                        spawnCard.lastActivity = clipSubagentActivity(output, 80);
+                        appendSubagentLog(spawnCard, { kind: failed ? 'result' : 'assistant', text: clipSubagentActivity(output, 80) });
+                    }
+                    this.markDirty();
+                    break;
+                }
+                const row = this.findToolRowByCallId(callId);
                 if (row !== undefined) {
                     const metaDiffs = diffMetaDiffs(event.data.meta);
                     if (metaDiffs !== null) {
@@ -4303,11 +4739,14 @@ export class SshTui {
                         ?? (typeof sourceName === 'string' ? sourceName : '');
                     if (recordedName !== '' && HIDDEN_TOOL_NAMES.has(recordedName))
                         break;
+                    // A spawn is drawn as the child's chip, never as a `subagent` tool
+                    // card: without a start there is still no card to settle, and a
+                    // second card beside the chip is exactly the duplicate to avoid.
+                    if (SUBAGENT_TOOL_NAMES.has(recordedName))
+                        break;
                     // Never title a card with the call id (`call-<uuid>`). Prefer the
                     // recorded tool name; fall back to a generic tool card.
-                    const toolName = recordedName === '' || recordedName.startsWith('call-')
-                        ? 'tool'
-                        : recordedName;
+                    const toolName = displayToolName(recordedName);
                     const present = presentToolCall(toolName, '');
                     this.pushRow({
                         kind: 'tool',
@@ -4356,6 +4795,9 @@ export class SshTui {
                 this.stalledWarningShown = 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
+                // names it, whatever changed it (a preset, a settings edit, a resume).
+                this.noteSessionRoute();
                 this.markDirty();
                 break;
             case 'turn/end': {
@@ -4364,6 +4806,10 @@ export class SshTui {
                 this.toolCallNames.clear();
                 this.statsTracker.noteTurnEnd();
                 this.stalledWarningShown = false;
+                // A retry belongs to the turn that scheduled it: once the turn closes,
+                // the chip must not outlive it (a failed retry would otherwise leave
+                // "重试 n/m" on an idle footer until the next turn).
+                this.llmRetry = undefined;
                 this.pendingMessages.clear();
                 // Aborted/errored turns may close without an assembled
                 // assistant/message; never leave a half-streamed thinking block behind.
@@ -4538,6 +4984,12 @@ export class SshTui {
             if (this.llmRetry !== undefined) {
                 this.pushRow({ kind: 'system', text: t('retry.started', { retry: this.llmRetry.retry }) });
             }
+            // The backoff is over and the retried request is in flight: the footer
+            // must go back to the ordinary running/waiting states instead of holding
+            // "retry n/m" until the next turn starts (which could be minutes later,
+            // or never — and a compaction ending in between fell back to this stale
+            // chip rather than to 运行中).
+            this.llmRetry = undefined;
             this.markDirty();
             return;
         }
@@ -4560,7 +5012,54 @@ export class SshTui {
             if (named !== undefined)
                 return named;
         }
-        return undefined;
+        // An event whose id matches no card still belongs to the compaction in
+        // flight: the Host runs at most one at a time, so the newest running card is
+        // the only candidate. Without this a mismatched (or absent) id left the row
+        // running forever — the same stuck state an abandoned Host produces.
+        return this.runningCompactions().at(-1);
+    }
+    /**
+     * Compaction cards that can still be in flight: not finished, and within the
+     * window a real compaction could take. A stale card is treated as not running
+     * so it cannot hold the footer, the spinner, or `/compact` hostage.
+     */
+    runningCompactions(now = Date.now()) {
+        return this.rows.filter((row) => row.kind === 'compaction'
+            && row.status === 'running'
+            && now - row.startedAt < COMPACTION_STALE_MS);
+    }
+    /** Whether a compaction is genuinely in flight right now. */
+    compactionRunning() {
+        return this.runningCompactions().length > 0;
+    }
+    /**
+     * Close compaction cards whose Host is gone.
+     *
+     * `compaction/start` is written before the work and `compaction/end` after it,
+     * so a Host that exits in between leaves an open start in the durable log.
+     * Replaying that log faithfully used to recreate a card stuck on "running"
+     * forever: the footer said 压缩中, the spinner kept animating, and every later
+     * `/compact` was refused as "already compacting". After a full replay nothing
+     * more can arrive for those starts, so they are settled here.
+     *
+     * `staleOnly` keeps the same sweep usable while the session is live, where a
+     * compaction that is merely slow must not be closed under it.
+     */
+    settleUnfinishedCompactions(options = {}) {
+        const now = Date.now();
+        let settled = false;
+        for (const row of this.rows) {
+            if (row.kind !== 'compaction' || row.status !== 'running')
+                continue;
+            if (options.staleOnly === true && now - row.startedAt < COMPACTION_STALE_MS)
+                continue;
+            row.status = 'error';
+            row.endedAt = row.startedAt === 0 ? now : row.startedAt;
+            row.error = t('compact.interrupted');
+            settled = true;
+        }
+        if (settled)
+            this.markDirty();
     }
     handleCompactionEvent(type, event) {
         const payload = event.data;
@@ -4671,11 +5170,14 @@ export class SshTui {
     canRunCompactCommand() {
         if (this.replaying || this.agentGone || this.exiting)
             return false;
+        // A card left running by a Host that died would otherwise refuse /compact
+        // for the rest of the session; its age decides whether it is still real.
+        this.settleUnfinishedCompactions({ staleOnly: true });
         if (this.agent.status === 'running')
             return false;
         if (this.idleCompactInFlight)
             return false;
-        if (this.rows.some(row => row.kind === 'compaction' && row.status === 'running'))
+        if (this.compactionRunning())
             return false;
         return this.ctx.get('commands') !== undefined;
     }
@@ -4695,8 +5197,13 @@ export class SshTui {
                 this.pushRow({ kind: 'error', text: t('cmd.unknown', { command: 'compact' }) });
             return;
         }
+        // A card left running by a Host that died is closed here rather than
+        // refusing the user for the rest of the session: its age decides whether it
+        // is still real. The footer already ignores a stale card, but the card
+        // itself must stop rendering as running too.
+        this.settleUnfinishedCompactions({ staleOnly: true });
         if (this.agent.status === 'running'
-            || this.rows.some(row => row.kind === 'compaction' && row.status === 'running')) {
+            || this.compactionRunning()) {
             if (reason === 'user')
                 this.pushRow({ kind: 'error', text: t('compact.busy') });
             this.markDirty();
@@ -4727,7 +5234,7 @@ export class SshTui {
                     this.pushRow({ kind: 'error', text: t('cmd.unknown', { command: 'compact' }) });
                 return;
             }
-            const compactionRunning = () => this.rows.some(row => row.kind === 'compaction' && row.status === 'running');
+            const compactionRunning = () => this.compactionRunning();
             const releaseIfSettled = () => {
                 queueMicrotask(() => {
                     if (!compactionRunning())
@@ -4828,7 +5335,7 @@ export class SshTui {
             if (this.status.startsWith(t('compact.short')) || this.status.startsWith('compact')) {
                 this.status = this.agent.status === 'running' ? 'running' : 'idle';
             }
-            if (!this.rows.some(row => row.kind === 'compaction' && row.status === 'running')) {
+            if (!this.compactionRunning()) {
                 this.idleCompactInFlight = false;
             }
             this.markDirty();
@@ -4916,35 +5423,72 @@ export class SshTui {
         switch (event.type) {
             case 'user/message': {
                 const text = collectText(event.data.content);
-                if (text !== '')
-                    appendSubagentLog(row, { kind: 'user', text: `❯ ${truncate(text, 4)}` });
+                const source = event.data.source;
+                const sourceKind = typeof source?.kind === 'string' ? source.kind : 'user';
+                const plugin = typeof source?.plugin === 'string' ? source.plugin : undefined;
+                foldSubagentUserLog(row, text, sourceKind, plugin);
                 break;
             }
             case 'assistant/message': {
                 const text = collectText(event.data.message.content);
+                // Long enough to be worth opening the overlay for; the collapsed chip
+                // reads `lastActivity`, not this entry.
                 if (text !== '')
-                    appendSubagentLog(row, { kind: 'assistant', text: truncate(text, 8) });
+                    appendSubagentLog(row, { kind: 'assistant', text: clipSubagentActivity(text, 200) });
                 break;
             }
             case 'tool/call': {
                 if (HIDDEN_TOOL_NAMES.has(event.data.name))
                     break;
+                this.toolCallNames.set(String(event.data.callId), event.data.name);
                 const present = presentToolCall(event.data.name, event.data.arguments);
-                appendSubagentLog(row, { kind: 'tool', text: `▶ ${present.title} ${present.summary}` });
+                appendSubagentLog(row, {
+                    kind: 'tool',
+                    text: `▶ ${present.title} ${clipSubagentActivity(present.summary, 48)}`.trimEnd(),
+                    callId: String(event.data.callId),
+                });
                 break;
             }
             case 'tool/result': {
-                const output = truncate(collectText(event.data.message.content), 3);
                 const ok = event.data.error === undefined && event.data.message.content[0]?.isError !== true;
+                const callId = String(event.data.message.source.callId);
+                const sourceName = event.data.message.source.name;
+                const recorded = this.toolCallNames.get(callId)
+                    ?? (typeof sourceName === 'string' ? sourceName : '');
+                const title = toolTitle(displayToolName(recorded));
+                // The overlay is the only place a child's tool output can be read, so
+                // keep a few lines of it — the call line itself carries the title.
+                const output = truncate(collectText(event.data.message.content), 3).trim();
                 appendSubagentLog(row, {
                     kind: 'result',
-                    text: `${ok ? '✓' : '✗'} ${event.data.message.source.callId}${output === '' ? '' : ` · ${output}`}`,
+                    text: `${ok ? '✓' : '✗'} ${title}`,
+                    ...(output === '' ? {} : { detail: output }),
+                    callId,
                 });
                 break;
             }
-            case 'turn/end':
-                appendSubagentLog(row, { kind: 'turn', text: t('sub.turnEnd', { reason: event.data.reason.kind }) });
+            case 'turn/end': {
+                const reason = event.data.reason;
+                const error = reason.kind === 'error'
+                    ? String(reason.error?.message ?? '')
+                    : '';
+                const explained = describeSubagentFailure({
+                    stopReason: reason.kind,
+                    message: error,
+                    provider: row.modelProvider ?? this.currentProviderId(),
+                });
+                if (explained !== undefined)
+                    row.failHint = explained.hint;
+                appendSubagentLog(row, {
+                    kind: error === '' ? 'turn' : 'result',
+                    text: explained === undefined
+                        ? (error === ''
+                            ? t('sub.turnEnd', { reason: reason.kind })
+                            : t('sub.turnEndError', { reason: reason.kind, error }))
+                        : explained.hint,
+                });
                 break;
+            }
             case 'approval/asked':
                 appendSubagentLog(row, { kind: 'approval', text: t('sub.approval', { tool: event.data.toolName }) });
                 break;
@@ -4953,6 +5497,7 @@ export class SshTui {
                 break;
         }
         this.lastActivity = Date.now();
+        this.refreshOpenSubagentInspect(row);
         this.markDirty();
     };
     handleSubagentStart = (info) => {
@@ -4964,31 +5509,53 @@ export class SshTui {
         });
         this.subagentSessions.add(sessionId);
         this.lastActivity = Date.now();
+        // The spawn description is a FIFO pair (task + parent call id). A card that
+        // is already linked to a spawn keeps it: only a fresh child may take the
+        // oldest waiting description, or two parallel spawns swap names.
         const existing = this.findSubagentRow(sessionId);
+        const pending = existing?.spawnCallId === undefined ? this.pendingSubagentTasks.shift() : undefined;
+        const task = pending?.task;
+        const modelProvider = this.subagentSelection.current.provider ?? this.currentProviderId();
+        const startedText = t('sub.startedDetail', {
+            provider: modelProvider,
+            external: info.local ? '' : t('sub.external'),
+        });
         if (existing !== undefined) {
+            existing.childSessionId = sessionId;
             existing.runId = String(info.runId);
             existing.provider = info.provider;
+            existing.modelProvider = modelProvider;
             existing.local = info.local;
             existing.status = 'running';
             existing.startedAt = Date.now();
             existing.endedAt = undefined;
             existing.stopReason = undefined;
+            delete existing.failHint;
             existing.lastActivity = t('sub.started');
             existing.expanded = false;
-            appendSubagentLog(existing, { kind: 'system', text: t('sub.startedDetail', { provider: info.provider, external: info.local ? '' : t('sub.external') }) });
+            if (pending !== undefined)
+                existing.spawnCallId = pending.callId;
+            if (task !== undefined)
+                existing.task = task;
+            appendSubagentLog(existing, { kind: 'system', text: startedText });
+            this.refreshOpenSubagentInspect(existing);
         }
         else {
             this.pushRow({
                 kind: 'subagent',
                 sessionId,
+                childSessionId: sessionId,
+                ...(pending === undefined ? {} : { spawnCallId: pending.callId }),
                 runId: String(info.runId),
                 provider: info.provider,
+                modelProvider,
                 local: info.local,
                 label: t('sub.label', { provider: info.provider }),
+                ...(task === undefined ? {} : { task }),
                 status: 'running',
                 startedAt: Date.now(),
                 lastActivity: t('sub.started'),
-                logs: [{ kind: 'system', text: t('sub.startedDetail', { provider: info.provider, external: info.local ? '' : t('sub.external') }) }],
+                logs: [{ kind: 'system', text: startedText }],
                 expanded: false,
             });
         }
@@ -5000,37 +5567,79 @@ export class SshTui {
         this.lastActivity = Date.now();
         const output = info.lastAssistantMessage === undefined
             ? ''
-            : truncate(collectText(info.lastAssistantMessage), 6);
-        const row = this.findSubagentRow(String(info.id)) ?? this.rows.findLast((candidate) => candidate.kind === 'subagent' && candidate.runId === String(info.runId));
+            : clipSubagentActivity(collectText(info.lastAssistantMessage), 80);
+        const row = this.findSubagentRow(String(info.id))
+            ?? this.rows.findLast((candidate) => candidate.kind === 'subagent' && candidate.runId === String(info.runId))
+            // A chip rebuilt from the parent spawn tool has no child id yet: adopt the
+            // oldest one so an end event settles it instead of adding a twin. A chip
+            // replay already closed as `unknown` is adopted too, and corrected.
+            ?? this.rows.find((candidate) => candidate.kind === 'subagent'
+                && (candidate.status === 'running' || candidate.stopReason === 'unknown')
+                && candidate.childSessionId === undefined);
         const failed = info.stopReason !== 'completed';
+        const modelProvider = row?.modelProvider
+            ?? this.subagentSelection.current.provider
+            ?? this.currentProviderId();
+        const explained = failed
+            ? describeSubagentFailure({
+                stopReason: info.stopReason,
+                message: output,
+                provider: modelProvider,
+            })
+            : undefined;
+        // A healthy end clears any hint an earlier failed attempt left on the row.
+        const hint = explained?.hint;
+        const endText = hint === undefined
+            ? t('sub.ended', { reason: info.stopReason }) + (output === '' ? '' : ` · ${output}`)
+            : hint;
         if (row !== undefined) {
             row.status = info.stopReason === 'aborted' ? 'aborted' : failed ? 'error' : 'ok';
             row.endedAt = Date.now();
             row.stopReason = info.stopReason;
+            row.childSessionId = String(info.id);
+            row.modelProvider = modelProvider;
+            if (hint === undefined)
+                delete row.failHint;
+            else
+                row.failHint = hint;
             appendSubagentLog(row, {
                 kind: failed ? 'result' : 'assistant',
-                text: t('sub.ended', { reason: info.stopReason }) + (output === '' ? '' : ` · ${output}`),
+                text: endText,
             });
+            this.refreshOpenSubagentInspect(row);
         }
         else {
             this.pushRow({
                 kind: 'subagent',
                 sessionId: String(info.id),
+                childSessionId: String(info.id),
                 runId: String(info.runId),
                 provider: info.provider,
+                modelProvider,
                 local: info.local,
                 label: t('sub.label', { provider: info.provider }),
                 status: info.stopReason === 'aborted' ? 'aborted' : failed ? 'error' : 'ok',
                 startedAt: Date.now(),
                 endedAt: Date.now(),
                 stopReason: info.stopReason,
-                lastActivity: t('sub.ended', { reason: info.stopReason }),
-                logs: [{ kind: 'system', text: t('sub.ended', { reason: info.stopReason }) + (output === '' ? '' : ` · ${output}`) }],
+                ...(explained === undefined ? {} : { failHint: explained.hint }),
+                lastActivity: endText,
+                logs: [{ kind: failed ? 'result' : 'system', text: endText }],
                 expanded: false,
             });
         }
         this.markDirty();
     };
+    /** Keep an open inspect overlay in sync with the live child log. */
+    refreshOpenSubagentInspect(row) {
+        const dialog = this.dialog;
+        if (dialog === undefined || dialog.kind !== 'inspect')
+            return;
+        if (dialog.subagentSessionId !== this.subagentInspectId(row))
+            return;
+        dialog.title = t('sub.inspectTitle', { title: subagentDisplayName(row) });
+        dialog.lines = subagentInspectLines(row);
+    }
     // ── approval and questions ──────────────────────────────────────────────
     hasLiveDisplay() {
         if (this.disposed || this.exiting)
@@ -5120,7 +5729,7 @@ export class SshTui {
         const selection = this.subagentSelection.current;
         const parentProvider = this.selectionRef?.current?.provider ?? this.agent.options.provider ?? this.providerName;
         const provider = selection.provider ?? parentProvider;
-        const model = subagentModelMatchesProvider(provider, selection.model)
+        const model = selection.provider !== undefined || subagentModelMatchesProvider(provider, selection.model)
             ? selection.model
             : defaultSubagentModelForProvider(provider, [], this.selectionRef?.current?.model);
         return { provider, model };
@@ -5346,9 +5955,7 @@ export class SshTui {
                 return 'cancelled';
             }
         }
-        const agentLabel = request.agent.id === this.agent.id
-            ? t('approval.thisSession')
-            : t('sub.agentLabel', { id: request.agent.id });
+        const agentLabel = t('sub.agentLabel', { name: this.subagentNameFor(String(request.agent.id)) });
         return new Promise((resolve) => {
             if (request.signal?.aborted === true) {
                 resolve('cancelled');
@@ -5386,7 +5993,7 @@ export class SshTui {
         const answers = [];
         const agentLabel = request.agent === undefined || request.agent.id === this.agent.id
             ? undefined
-            : t('sub.agentLabel', { id: request.agent.id });
+            : t('sub.agentLabel', { name: this.subagentNameFor(String(request.agent.id)) });
         const cards = [];
         for (const question of request.questions) {
             const card = {
@@ -5463,6 +6070,7 @@ export class SshTui {
     openDialog(dialog) {
         if (this.dialog === undefined) {
             this.dialog = dialog;
+            this.echoLineModeDialog(dialog);
         }
         else {
             this.dialogQueue.push(dialog);
@@ -5475,9 +6083,53 @@ export class SshTui {
         const next = this.dialogQueue.shift();
         if (next !== undefined) {
             this.dialog = next;
+            this.echoLineModeDialog(next);
             this.markDirty();
         }
     }
+    /**
+     * Line mode has no framed dialog. Write the prompt (and its keys) into the
+     * log once when it becomes active, so a `tee` or a screen reader can answer
+     * it. Options stay on the framed path; the log only needs the question.
+     */
+    echoLineModeDialog(dialog) {
+        if (!this.lineMode)
+            return;
+        if (dialog.kind === 'confirm') {
+            this.pushRow({ kind: 'system', text: dialog.prompt });
+            this.pushRow({ kind: 'system', text: dialog.hint });
+            return;
+        }
+        if (dialog.kind === 'questions') {
+            const header = t('dialog.ask', {
+                index: dialog.index + 1,
+                total: dialog.total,
+                question: dialog.question.question,
+            });
+            this.pushRow({ kind: 'system', text: header });
+            if (dialog.question.header !== undefined && dialog.question.header !== '') {
+                this.pushRow({ kind: 'system', text: dialog.question.header });
+            }
+            const options = dialog.question.options ?? [];
+            for (const [index, option] of options.entries()) {
+                if (option === undefined)
+                    continue;
+                const key = QUESTION_OPTION_KEYS[index] ?? String(index + 1);
+                const extra = option.description === undefined ? '' : ` — ${option.description}`;
+                this.pushRow({ kind: 'system', text: `  ${key} ${option.label}${extra}` });
+            }
+            this.pushRow({
+                kind: 'system',
+                text: options.length === 0
+                    ? t('dialog.freeform')
+                    : dialog.question.multiSelect === true ? t('dialog.multiHint') : t('dialog.singleHint'),
+            });
+            return;
+        }
+        if (dialog.kind === 'onboarding') {
+            this.pushRow({ kind: 'system', text: t('onboard.title') });
+        }
+    }
     removeQueuedDialog(dialog) {
         const index = this.dialogQueue.indexOf(dialog);
         if (index !== -1)
@@ -5560,43 +6212,281 @@ export class SshTui {
         const section = this.ctx.get('settings')?.get(settingsNamespace('llm-pi-ai'));
         return section?.providers?.[provider];
     }
-    /** Default listing endpoint for a built-in OpenCode route with no stored base URL. */
-    openCodeListingBaseURL(provider) {
-        if (provider === 'opencode-go')
-            return providerTemplates()['opencode-go'].defaultBaseUrl;
-        if (provider === 'opencode')
-            return OPENCODE_ZEN_BASE_URL;
-        return undefined;
-    }
     /**
-     * Fetch the live model list for an OpenCode or third-party provider from its
-     * OpenAI-compatible listing endpoint. The provider route is deliberately not
-     * passed to discovery: pi-ai would answer a catalog route from its installed
-     * registry, while the TUI wants the endpoint's current list.
+     * Every settings-backed row one gateway family occupies, base first.
+     *
+     * `llm-pi-ai` puts the wire protocol on the provider entry, so a gateway
+     * whose catalogue spans protocols (Command Code, OpenCode Go) is stored as
+     * sibling rows. To the user they are one supplier: the TUI lists, picks and
+     * remembers them under the family's base id, and files each picked model on
+     * the row that actually serves it.
+     *
+     * The `-responses` / `-completions` / `-messages` suffix is only a naming
+     * convention, so a row is adopted into the family only when it corroborates:
+     * it must speak the protocol its suffix names, point at the same endpoint,
+     * and (when both name one) carry the same display name. A provider someone
+     * legitimately called `foo-messages` on another host therefore stays its own
+     * supplier instead of vanishing from `/provider` behind `foo`. A family of
+     * one — the ordinary case, and a sibling whose base row is missing — stays
+     * exactly as configured.
      */
-    async discoverEndpointModels(provider) {
-        const llmPiAi = this.ctx.get('settings')?.get(settingsNamespace('llm-pi-ai'));
-        const profile = this.piAiProviderProfile(provider);
-        const source = openCodeSourceFor(provider, llmPiAi);
-        const baseURL = typeof profile?.baseURL === 'string' && profile.baseURL.trim() !== ''
-            ? profile.baseURL.trim()
-            : this.openCodeListingBaseURL(provider);
-        if (baseURL === undefined)
-            return [];
-        const api = typeof profile?.api === 'string' && profile.api.trim() !== '' ? profile.api.trim() : undefined;
-        const apiKeyEnv = typeof profile?.apiKeyEnv === 'string' && profile.apiKeyEnv.trim() !== ''
-            ? profile.apiKeyEnv.trim()
-            : source?.apiKeyEnv;
-        const apiKey = apiKeyEnv === undefined ? undefined : await this.resolveCredential(apiKeyEnv);
-        const llm = this.ctx.get('llm');
-        if (llm === undefined)
+    providerFamilyRows(provider) {
+        if (provider === '')
             return [];
-        const discovered = await discoverProviderModels(llm, {
-            baseURL,
-            ...(api === undefined ? {} : { api }),
-            ...(apiKey === undefined ? {} : { apiKey }),
-        }, AbortSignal.timeout(15_000));
-        return discovered.map(model => ({ id: model.id, label: model.name || model.id }));
+        const base = baseProviderIdOf(provider);
+        const baseRow = this.piAiProviderProfile(base);
+        const rows = [base];
+        for (const protocol of GATEWAY_PROTOCOL_PREFERENCE) {
+            const sibling = siblingProviderId(base, protocol);
+            if (sibling === provider || rows.includes(sibling)) {
+                if (this.isFamilyRow(baseRow, sibling, protocol))
+                    rows.push(sibling);
+                continue;
+            }
+            if (this.isFamilyRow(baseRow, sibling, protocol))
+                rows.push(sibling);
+        }
+        const present = rows.filter(row => this.piAiProviderProfile(row) !== undefined);
+        if (present.length <= 1) {
+            // A lone sibling is not a family — it is just this provider.
+            return baseRow !== undefined || present.includes(provider) ? present : [provider];
+        }
+        return present;
+    }
+    /**
+     * Whether `sibling` is genuinely the same gateway as `base`, on another
+     * protocol: its `api` matches its suffix, its endpoint matches the base row's,
+     * and the two labels agree when both are set.
+     */
+    isFamilyRow(baseRow, sibling, protocol) {
+        if (baseRow === undefined)
+            return false;
+        const profile = this.piAiProviderProfile(sibling);
+        if (profile === undefined)
+            return false;
+        const endpoint = (value) => typeof value === 'string' ? value.replace(/\/+$/u, '').toLowerCase() : '';
+        const api = declaredProtocol(profile.api);
+        if (api !== undefined && api !== protocol)
+            return false;
+        const baseUrl = endpoint(baseRow.baseURL);
+        const siblingUrl = endpoint(profile.baseURL);
+        if (baseUrl !== '' && siblingUrl !== '' && baseUrl !== siblingUrl)
+            return false;
+        const baseLabel = typeof baseRow.displayName === 'string' ? baseRow.displayName.trim() : '';
+        const siblingLabel = typeof profile.displayName === 'string' ? profile.displayName.trim() : '';
+        if (baseLabel !== '' && siblingLabel !== '' && baseLabel !== siblingLabel)
+            return false;
+        return true;
+    }
+    /** The id the TUI shows for a route: its family's base when it is spread. */
+    displayProviderId(provider) {
+        const rows = this.providerFamilyRows(provider);
+        return rows.length > 1 ? (rows[0] ?? provider) : provider;
+    }
+    /** The models one row configures, as ids with the labels settings carry. */
+    configuredModelsOf(row) {
+        const models = this.piAiProviderProfile(row)?.models;
+        if (!Array.isArray(models))
+            return [];
+        const out = [];
+        for (const raw of models) {
+            if (typeof raw === 'string') {
+                if (raw !== '')
+                    out.push({ id: raw });
+                continue;
+            }
+            if (raw === null || typeof raw !== 'object')
+                continue;
+            const entry = raw;
+            if (typeof entry.id !== 'string' || entry.id === '')
+                continue;
+            out.push({
+                id: entry.id,
+                ...(typeof entry.name === 'string' && entry.name !== '' ? { label: entry.name } : {}),
+            });
+        }
+        return out;
+    }
+    /**
+     * The protocols the gateway publishes for one model, best-effort.
+     *
+     * Used when a model is being filed but no picker listed it yet (`/model <id>`
+     * on a new id, a `--model` override, a `/submodel` pin): the gateway's own
+     * answer is the only thing that can put it on a route that can send it.
+     * Any failure is "no opinion", never a blocked selection.
+     */
+    async advertisedFor(family, model) {
+        const rows = this.providerFamilyRows(family);
+        if (rows.length <= 1)
+            return [];
+        // A model the last listing already filed needs no second opinion, and that
+        // is the common case: `/model` re-picking a listed model must never wait on
+        // the gateway again. Only an unlisted id (a hand-typed one, a `--model`
+        // override) asks, and even then the wait is bounded — an unreachable gateway
+        // must not stall a selection for the endpoint's full timeout.
+        if (this.familyModelOwner.has(`${family}\u0000${model}`))
+            return [];
+        if (this.configuredModelsOf(rows[0] ?? family).some(entry => entry.id === model))
+            return [];
+        try {
+            const listing = await this.discoverGatewayListing(rows[0] ?? family, AbortSignal.timeout(5_000));
+            return advertisedProtocols(listing.endpoints, model);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * The row of a gateway family that serves `model`: the one learned from the
+     * last listing, else the one that already configures it, else the base —
+     * where a brand-new model lands and is re-filed from.
+     */
+    /**
+     * Record which row a family's model belongs to, keeping the map bounded.
+     *
+     * Re-inserting keeps a key fresh, and the oldest half is dropped once the cap
+     * is crossed, so a gateway whose catalogue is re-listed on every `/model`
+     * does not accumulate a second copy of itself each time.
+     */
+    rememberFamilyOwner(base, model, row) {
+        const key = `${base}\u0000${model}`;
+        this.familyModelOwner.delete(key);
+        this.familyModelOwner.set(key, row);
+        if (this.familyModelOwner.size <= FAMILY_OWNER_CACHE_MAX)
+            return;
+        let remaining = Math.floor(FAMILY_OWNER_CACHE_MAX / 2);
+        for (const oldest of this.familyModelOwner.keys()) {
+            if (remaining <= 0)
+                break;
+            this.familyModelOwner.delete(oldest);
+            remaining -= 1;
+        }
+    }
+    familyOwnerRow(base, model, advertised) {
+        const rows = this.providerFamilyRows(base);
+        if (rows.length <= 1)
+            return base;
+        // What the gateway itself says comes first: a model no row configures and
+        // no picker listed (`/model <id>` on a new id, a `--model` override) still
+        // has a protocol, and filing it anywhere else makes the guard below refuse
+        // a model the gateway is happy to serve.
+        for (const protocol of advertised ?? []) {
+            const row = rows.find(candidate => declaredProtocol(this.piAiProviderProfile(candidate)?.api) === protocol);
+            if (row !== undefined)
+                return row;
+        }
+        // The row that actually served the model in the last listing is evidence,
+        // not a hint: it is the row the gateway said could send it. A row that
+        // merely has the model configured used to win here, which sent an explicit
+        // `/model <id>` back to the protocol the listing had just ruled out (the
+        // completions row is still listed first for a stale responses entry).
+        const learned = this.familyModelOwner.get(`${base}\u0000${model}`);
+        if (learned !== undefined && rows.includes(learned))
+            return learned;
+        // No listing this run (a direct `/model <id>`, or an unreachable gateway):
+        // keep the placement that is already configured. A model on two rows takes
+        // the first, which is the family's own preference order — the same order
+        // the wizard would file it under.
+        for (const row of rows) {
+            if (this.configuredModelsOf(row).some(entry => entry.id === model))
+                return row;
+        }
+        return rows[0] ?? base;
+    }
+    /** Default listing endpoint for a built-in OpenCode route with no stored base URL. */
+    openCodeListingBaseURL(provider) {
+        if (provider === 'opencode-go')
+            return providerTemplates()['opencode-go'].defaultBaseUrl;
+        if (provider === 'opencode')
+            return OPENCODE_ZEN_BASE_URL;
+        return undefined;
+    }
+    /**
+     * Fetch the live model list for an OpenCode or third-party provider from its
+     * OpenAI-compatible listing endpoint. The provider route is deliberately not
+     * passed to discovery: pi-ai would answer a catalog route from its installed
+     * registry, while the TUI wants the endpoint's current list.
+     *
+     * A row speaks exactly one protocol (`api` on the provider entry), so with a
+     * gateway that publishes `supported_endpoints` the list is narrowed to the
+     * models that row can actually serve — otherwise `/model` on
+     * `command-code-messages` would offer, and then persist, a model that only
+     * answers `/responses`.
+     */
+    async discoverEndpointModels(provider) {
+        const protocol = declaredProtocol(this.piAiProviderProfile(provider)?.api);
+        // Interactive callers get a shorter budget than the wizard's: `/model`
+        // falling back to the configured list after a few seconds reads as "this
+        // gateway is unreachable", while 15s reads as "the TUI hung".
+        const { models, endpoints } = await this.discoverGatewayListing(provider, AbortSignal.timeout(6_000));
+        return models.filter(model => gatewayServesModel(endpoints, model.id, protocol));
+    }
+    /**
+     * One gateway's own model listing: every model the endpoint returns plus the
+     * route table it publishes. The caller narrows it to a protocol; a gateway
+     * spread over rows asks once and files the answer per row, so opening a
+     * picker costs one listing instead of one per sibling.
+     */
+    async discoverGatewayListing(provider, signal) {
+        const llmPiAi = this.ctx.get('settings')?.get(settingsNamespace('llm-pi-ai'));
+        const profile = this.piAiProviderProfile(provider);
+        const source = openCodeSourceFor(provider, llmPiAi);
+        const baseURL = typeof profile?.baseURL === 'string' && profile.baseURL.trim() !== ''
+            ? profile.baseURL.trim()
+            : this.openCodeListingBaseURL(provider);
+        if (baseURL === undefined)
+            return { models: [], endpoints: undefined };
+        const api = typeof profile?.api === 'string' && profile.api.trim() !== '' ? profile.api.trim() : undefined;
+        const apiKeyEnv = typeof profile?.apiKeyEnv === 'string' && profile.apiKeyEnv.trim() !== ''
+            ? profile.apiKeyEnv.trim()
+            : source?.apiKeyEnv;
+        const apiKey = apiKeyEnv === undefined ? undefined : await this.resolveCredential(apiKeyEnv);
+        const llm = this.ctx.get('llm');
+        if (llm === undefined)
+            return { models: [], endpoints: undefined };
+        const [discovered, endpoints] = await Promise.all([
+            discoverProviderModels(llm, {
+                baseURL,
+                ...(api === undefined ? {} : { api }),
+                ...(apiKey === undefined ? {} : { apiKey }),
+            }, signal ?? AbortSignal.timeout(15_000)).catch(() => []),
+            apiKey === undefined ? Promise.resolve(undefined) : fetchModelEndpoints(baseURL, apiKey, signal),
+        ]);
+        // The route table is the point of asking a gateway that publishes one: it is
+        // what files each model on the protocol that can actually send it, and the
+        // discovered list alone cannot. A gateway whose listing answered from the
+        // installed catalog still gets its endpoints read here, and a gateway that
+        // publishes no table keeps the discovered list as-is.
+        const named = new Map(discovered.map(model => [model.id, model.name || model.id]));
+        const models = endpoints === undefined
+            ? discovered.map(model => ({ id: model.id, label: model.name || model.id }))
+            : [...endpoints.keys()].map(id => ({ id, label: named.get(id) ?? id }));
+        return { models, endpoints };
+    }
+    /**
+     * The row of the same gateway that the gateway itself says serves `model`,
+     * when that is not the row the caller is on. `undefined` when the gateway has
+     * no opinion, when the current row already serves it, or when the model would
+     * need a row that does not exist yet.
+     */
+    rowServingModel(provider, modelId, endpoints) {
+        const protocol = declaredProtocol(this.piAiProviderProfile(provider)?.api);
+        if (gatewayServesModel(endpoints, modelId, protocol))
+            return undefined;
+        const wanted = advertisedProtocols(endpoints, modelId)[0];
+        if (wanted === undefined)
+            return undefined;
+        // The base id is a row of its own: use it when it already speaks `wanted`,
+        // otherwise the sibling that does.
+        const base = baseProviderIdOf(provider);
+        const rows = declaredProtocol(this.piAiProviderProfile(base)?.api) === wanted
+            ? [base, siblingProviderId(base, wanted)]
+            : [siblingProviderId(base, wanted)];
+        for (const row of rows) {
+            if (row !== provider && this.piAiProviderProfile(row) !== undefined)
+                return row;
+        }
+        return undefined;
     }
     /** Add one endpoint-listed model to the stored provider profile when needed. */
     async ensureProviderModelConfigured(provider, modelId) {
@@ -5620,6 +6510,39 @@ export class SshTui {
         }
         if (ids.has(modelId))
             return true;
+        // Reached by a direct `/model <id>` too, where the picker's own filter never
+        // ran: refuse to store a model this row's protocol cannot serve, and say
+        // which sibling row can.
+        const protocol = declaredProtocol(profile.api);
+        const baseURL = typeof profile.baseURL === 'string' && profile.baseURL.trim() !== ''
+            ? profile.baseURL.trim()
+            : this.openCodeListingBaseURL(provider);
+        if (protocol !== undefined && baseURL !== undefined) {
+            const apiKeyEnv = typeof profile.apiKeyEnv === 'string' && profile.apiKeyEnv.trim() !== '' ? profile.apiKeyEnv.trim() : undefined;
+            const apiKey = apiKeyEnv === undefined ? undefined : await this.resolveCredential(apiKeyEnv);
+            const endpoints = apiKey === undefined ? undefined : await fetchModelEndpoints(baseURL, apiKey);
+            if (!gatewayServesModel(endpoints, modelId, protocol)) {
+                const target = this.rowServingModel(provider, modelId, endpoints);
+                // Report both names: the family is what `/provider` offers, the row is
+                // what the settings file calls it. Sending the user to a hidden row was
+                // a dead end — `/provider` lists families, so the hint names the family
+                // and `/model` (which files the pick on the right row itself).
+                const family = this.displayProviderId(provider);
+                this.pushRow({
+                    kind: 'error',
+                    text: t('model.wrongRoute', {
+                        model: modelId,
+                        provider: family === provider ? provider : `${family}（${provider}）`,
+                        endpoint: GATEWAY_PROTOCOL_ENDPOINT[protocol],
+                        hint: target === undefined
+                            ? t('model.wrongRouteSetup')
+                            : t('model.wrongRouteTarget', { provider: family }),
+                    }),
+                });
+                this.markDirty();
+                return false;
+            }
+        }
         const modelEntry = { id: modelId };
         // A model added here skips the wizard, so size it from the installed
         // catalog the same way `/setup` does; the route default covers a miss.
@@ -5629,14 +6552,18 @@ export class SshTui {
             if (contextWindow !== undefined)
                 modelEntry.contextWindow = contextWindow;
         }
-        const reasoningEfforts = reasoningEffortsForDefault(profile.reasoning);
+        // Same rule `/setup` follows: a route whose dialect the installed catalog
+        // does not describe must still declare its offered levels, or the Harness
+        // reads the model as non-reasoning and refuses every effort the TUI offers.
+        const reasoningEfforts = reasoningEffortsForDefault(profile.reasoning)
+            ?? (declaresOfferedReasoning(typeof profile.api === 'string' ? profile.api : '') ? handDeclaredReasoningEfforts() : undefined);
         if (reasoningEfforts !== undefined)
             modelEntry.reasoningEfforts = reasoningEfforts;
         try {
             await settings.mutate(settingsNamespace('llm-pi-ai'), [
                 { op: 'set', path: ['providers', provider, 'models'], value: [...models, modelEntry] },
             ]);
-            this.pushRow({ kind: 'system', text: t('model.added', { model: modelId, provider }) });
+            this.pushRow({ kind: 'system', text: t('model.added', { model: modelId, provider: this.displayProviderId(provider) }) });
             this.markDirty();
             return true;
         }
@@ -5681,16 +6608,22 @@ export class SshTui {
     /** Live adapter routes the TUI can switch to, plus the current selection. */
     listSelectableProviders() {
         const llm = this.ctx.get('llm');
-        const current = this.currentProviderId();
+        const current = this.displayProviderId(this.currentProviderId());
         const seen = new Set();
         const out = [];
         const add = (id, name) => {
-            if (id === '' || seen.has(id))
+            if (id === '')
                 return;
-            seen.add(id);
-            const kind = describeProviderRoute(id);
-            const display = name !== undefined && name !== '' && name !== id ? name : kind.short;
-            out.push({ id, label: `${display} · ${id}` });
+            // A gateway spread over protocol rows is one choice here: the rows are an
+            // implementation detail of `llm-pi-ai` (one wire protocol per entry), not
+            // something the user should have to pick between.
+            const row = this.displayProviderId(id);
+            if (row === '' || seen.has(row))
+                return;
+            seen.add(row);
+            const kind = describeProviderRoute(row);
+            const display = name !== undefined && name !== '' && name !== row ? name : kind.short;
+            out.push({ id: row, label: `${display} · ${row}` });
         };
         add(current);
         for (const info of llm?.listProviders() ?? [])
@@ -5708,6 +6641,9 @@ export class SshTui {
         { id: 'grok-4.3', label: 'Grok 4.3' },
     ];
     async loadModelOptions(provider) {
+        const family = this.providerFamilyRows(provider);
+        if (family.length > 1)
+            return this.loadFamilyModelOptions(family[0] ?? provider, family);
         const llm = this.ctx.get('llm');
         let options = [];
         let source = t('model.configured');
@@ -5762,16 +6698,86 @@ export class SshTui {
         }
         return { options, source };
     }
+    /**
+     * The model list of a gateway spread over protocol rows.
+     *
+     * Every row is asked what it serves and the answers are merged under the
+     * family's base id, so the user picks from one list. Each model remembers the
+     * row that offered it, which is what routes the pick back to the protocol
+     * that can actually send it — the split stays invisible end to end.
+     */
+    async loadFamilyModelOptions(base, family) {
+        const llm = this.ctx.get('llm');
+        const options = [];
+        const seen = new Set();
+        const add = (row, id, label) => {
+            if (id === '' || seen.has(id))
+                return;
+            seen.add(id);
+            this.rememberFamilyOwner(base, id, row);
+            options.push({ id, label: label !== undefined && label !== '' ? label : id });
+        };
+        const previousStatus = this.status;
+        this.status = t('model.fetching', { provider: base });
+        this.markDirty();
+        try {
+            // The gateway's own listing is what decides which row serves what, so it
+            // is answered first and `add` keeps the first row that claims an id. Doing
+            // the configured rows first would let a leftover entry on the base row
+            // shadow the sibling the gateway actually files the model under — the
+            // picker would then show a model under a protocol that cannot send it,
+            // and `/model` would write it back onto that row.
+            const listings = await this.discoverGatewayListing(base, AbortSignal.timeout(6_000)).catch(() => undefined);
+            if (listings !== undefined) {
+                for (const row of family) {
+                    const protocol = declaredProtocol(this.piAiProviderProfile(row)?.api);
+                    for (const model of listings.models) {
+                        if (gatewayServesModel(listings.endpoints, model.id, protocol))
+                            add(row, model.id, model.label);
+                    }
+                }
+            }
+            // Whatever the endpoint did not answer: the rows that already configure a
+            // model keep it (so a gateway that is down still offers its own list).
+            for (const row of family) {
+                for (const model of this.configuredModelsOf(row))
+                    add(row, model.id, model.label);
+            }
+            // Models the installed catalog knows but neither source listed.
+            for (const row of family) {
+                try {
+                    for (const model of (await llm?.listModels(row)) ?? [])
+                        add(row, model.id, model.name || model.id);
+                }
+                catch {
+                    // The endpoint listing stands alone when the catalog cannot be read.
+                }
+            }
+        }
+        finally {
+            this.status = previousStatus;
+            this.markDirty();
+        }
+        if (options.length === 0) {
+            const remembered = this.rememberedRoute(base)?.model;
+            if (remembered !== undefined)
+                options.push({ id: remembered, label: remembered });
+        }
+        return { options, source: options.length > 0 ? t('model.live') : t('model.configured') };
+    }
     /** /model: models and effort for the current provider only. */
     async runModelCommand() {
         const provider = this.currentProviderId();
+        // The list is the whole family's; the question names the gateway, not the
+        // protocol row the current request happens to use.
+        const display = this.displayProviderId(provider);
         const current = this.selectionRef?.current;
         const loaded = await this.loadModelOptions(provider);
         let modelOptions = loaded.options;
         if (current?.model !== undefined && !modelOptions.some(option => option.id === current.model)) {
             modelOptions = [{ id: current.model, label: current.model }, ...modelOptions];
         }
-        const selected = await this.pickModelOption(modelOptions, provider, loaded.source, current?.model);
+        const selected = await this.pickModelOption(modelOptions, display, loaded.source, current?.model);
         if (selected === undefined)
             return;
         await this.applyModelSelection(provider, selected.id, modelOptions.map(option => option.id));
@@ -5779,7 +6785,10 @@ export class SshTui {
     /** /provider: pick a provider, then its model (remembered route pre-filled). */
     async runProviderCommand() {
         const providers = this.listSelectableProviders();
-        const current = this.currentProviderId();
+        // The list holds family ids, so the highlight must be asked for in the same
+        // vocabulary: a session on `command-code-messages` otherwise matched no row
+        // and fell back to index 0, pre-selecting the wrong supplier.
+        const current = this.displayProviderId(this.currentProviderId());
         if (providers.length === 0) {
             this.pushRow({ kind: 'error', text: t('provider.none') });
             this.markDirty();
@@ -5818,7 +6827,46 @@ export class SshTui {
             : {};
         return rememberedRouteFor(memory, provider);
     }
+    /** The route this session is running right now, record-shaped. */
+    sessionRouteRecord() {
+        const current = this.selectionRef?.current;
+        const subagent = this.subagentSelection.current;
+        // Shaped by the launcher's own builder, so what the TUI reports and what the
+        // launcher writes cannot drift apart.
+        return sessionRouteInput({
+            provider: current?.provider ?? this.currentProviderId(),
+            model: current?.model ?? this.agent.options.model ?? '',
+            ...(current?.reasoningEffort === undefined ? {} : { reasoningEffort: String(current.reasoningEffort) }),
+            subagent: {
+                ...(subagent.provider === undefined ? {} : { provider: subagent.provider }),
+                model: subagent.model,
+                ...(subagent.reasoningEffort === undefined ? {} : { reasoningEffort: String(subagent.reasoningEffort) }),
+            },
+        });
+    }
+    /**
+     * Tell the launcher which route this session has settled on, so resuming it
+     * comes back on the same supplier — the subagent route included, which is what
+     * makes a resumed cross-provider conversation reproducible.
+     *
+     * Reported when a route settles (`/model`, `/submodel`, `/setup`) and at the
+     * start of every turn, which catches a preset or a settings edit moving the
+     * route behind the TUI's back. The launcher owns the file; the TUI only says
+     * what changed, and says nothing when nothing did.
+     */
+    noteSessionRoute() {
+        const route = this.sessionRouteRecord();
+        if (route === undefined)
+            return;
+        if (sameSessionRoute(this.lastSessionRoute, route))
+            return;
+        this.lastSessionRoute = { ...route, updatedAt: Date.now() };
+        this.onRouteSettled?.(route);
+    }
     async rememberRoute(selection) {
+        // The session's record is kept even when the settings service is missing:
+        // coming back to this conversation on the same supplier is the point of it.
+        this.noteSessionRoute();
         const settings = this.ctx.get('settings');
         if (settings === undefined)
             return;
@@ -5835,19 +6883,25 @@ export class SshTui {
         ]);
     }
     async applyModelSelection(provider, modelId, listed = [], preferredEffort) {
-        if (!(await this.ensureProviderModelConfigured(provider, modelId)))
+        // One gateway, one choice: the picker offers the family's merged list, and
+        // the row that actually serves the model is resolved here so the selection
+        // lands on a route whose protocol can send it. The family base id is what
+        // the user sees and what the route memory remembers.
+        const display = this.displayProviderId(provider);
+        const target = this.familyOwnerRow(display, modelId, await this.advertisedFor(display, modelId));
+        if (!(await this.ensureProviderModelConfigured(target, modelId)))
             return;
         const llm = this.ctx.get('llm');
         const current = this.selectionRef?.current;
         let effortOptions = [];
         try {
-            const info = await llm?.resolveModelInfo(provider, modelId);
+            const info = await llm?.resolveModelInfo(target, modelId);
             effortOptions = (info?.reasoning?.efforts ?? []).map(effort => ({ id: String(effort.id), label: effort.name }));
         }
         catch {
             effortOptions = [];
         }
-        if (effortOptions.length === 0 && providerUsesLocalOAuth(provider)) {
+        if (effortOptions.length === 0 && providerUsesLocalOAuth(target)) {
             effortOptions = localOAuthEffortChoices(modelId);
         }
         const isUndeclared = effortOptions.length === 0;
@@ -5864,8 +6918,8 @@ export class SshTui {
                 desc: undefined,
             })),
         ];
-        const rememberedEffort = this.rememberedRoute(provider)?.reasoningEffort ?? preferredEffort ?? '';
-        const currentEffort = current?.provider === provider
+        const rememberedEffort = this.rememberedRoute(display)?.reasoningEffort ?? preferredEffort ?? '';
+        const currentEffort = current?.provider === target
             ? String(current?.reasoningEffort ?? '')
             : rememberedEffort;
         const currentIndex = Math.max(0, choices.findIndex(option => option.id === (currentEffort === '' ? undefined : currentEffort)));
@@ -5881,9 +6935,9 @@ export class SshTui {
         }, 0, 1, currentIndex);
         const effort = choices.find(option => option.label === effortAnswer.selected[0])?.id;
         if (isUndeclared && effort !== undefined)
-            await this.declareReasoningEffort(provider, modelId, effort);
+            await this.declareReasoningEffort(target, modelId, effort);
         const next = {
-            provider,
+            provider: target,
             model: modelId,
             ...(effort === undefined ? {} : { reasoningEffort: ReasoningEffortId(effort) }),
         };
@@ -5891,23 +6945,23 @@ export class SshTui {
             this.selectionRef.current = next;
         this.onSelectionChanged?.(next);
         await this.persistDefaultSelection(next);
-        await this.rememberRoute(next);
-        const kind = describeProviderRoute(provider);
+        await this.rememberRoute({ ...next, provider: display });
+        const kind = describeProviderRoute(display);
         const effortText = effort ?? t('effort.defaultShort');
         const note = isUndeclared && effort !== undefined ? t('effort.manualNote') : '';
         this.pushRow({
             kind: 'system',
-            text: t('effort.switchedModel', { kind: kind.kind, provider, model: modelId, effort: effortText, note }),
+            text: t('effort.switchedModel', { kind: kind.kind, provider: display, model: modelId, effort: effortText, note }),
         });
         const listedIds = listed.filter(id => id !== '__switch_provider__' && id !== '');
         const previousProvider = current?.provider ?? this.agent.options.provider ?? this.providerName;
-        if (previousProvider !== provider) {
-            await this.syncSubagentToProvider(provider, listedIds, true);
-            this.clearQuotaForProvider(provider);
+        if (this.displayProviderId(previousProvider) !== display) {
+            await this.syncSubagentToProvider(display, listedIds, true);
+            this.clearQuotaForProvider(target);
             void this.refreshQuota({ reason: 'command', announce: false }).catch(() => { });
         }
         else {
-            await this.syncSubagentToProvider(provider, listedIds);
+            await this.syncSubagentToProvider(display, listedIds);
         }
         this.markDirty();
     }
@@ -5963,11 +7017,23 @@ export class SshTui {
      * When the parent provider changes (OAuth or API key), keep the subagent
      * on a same-family model. An explicit leftover DeepSeek flash id after
      * switching to xAI is treated as stale.
+     *
+     * A `/submodel` pin is the user's explicit route, so a parent switch asks
+     * before moving the children: dropping the pin silently spends on a route
+     * they pinned away from, and keeping it silently leaves the children on the
+     * old provider.
      */
     async syncSubagentToProvider(provider, listed = [], force = false) {
+        // Children follow the family the user sees, not the protocol row the parent
+        // request happens to use.
+        provider = this.displayProviderId(provider);
         const current = this.subagentSelection.current;
-        if (!force && current.provider !== undefined && current.provider !== provider)
-            return;
+        if (current.provider !== undefined) {
+            if (!force)
+                return;
+            if (await this.confirmKeepSubagentPin(provider, current))
+                return;
+        }
         if (!force && subagentModelMatchesProvider(provider, current.model, listed))
             return;
         let catalog = [...listed];
@@ -5993,6 +7059,31 @@ export class SshTui {
             text: t('sub.followed', { provider, model: nextModel, sessionOnly: persisted ? '' : t('sub.sessionOnly') }),
         });
     }
+    /**
+     * Ask whether a `/submodel` pin survives a parent provider change.
+     *
+     * Returns true when the pin should be kept. Cancelling the dialog keeps it
+     * too: the pin is the user's explicit choice, so only an explicit answer
+     * moves the children onto the new parent route.
+     */
+    async confirmKeepSubagentPin(provider, current) {
+        const pinned = this.displayProviderId(current.provider ?? '');
+        const keepLabel = t('sub.followKeepLabel', { provider: pinned });
+        const followLabel = t('sub.followSwitchLabel', { provider });
+        const answer = await this.askQuestion({
+            id: 'submodel-follow-pick',
+            question: t('sub.followAsk', { pinned, provider, model: current.model }),
+            options: [
+                { label: keepLabel, description: t('sub.followKeepHint') },
+                { label: followLabel, description: t('sub.followSwitchHint', { provider }) },
+            ],
+        }, 0, 1, 0);
+        if (answer.selected[0] === followLabel)
+            return false;
+        this.pushRow({ kind: 'system', text: t('sub.pinKept', { pinned, parent: provider }) });
+        this.markDirty();
+        return true;
+    }
     clearQuotaForProvider(provider) {
         const quotaSame = this.quotaSnapshot !== undefined && this.quotaSnapshot.provider === provider;
         const balanceSame = this.balanceSnapshot !== undefined && this.balanceSnapshot.provider === provider;
@@ -6010,6 +7101,13 @@ export class SshTui {
     /** Persist one subagent selection and publish it to the live request waterfall. */
     async saveSubagentSelection(next) {
         this.subagentSelection.current = next;
+        // An explicit change makes the settings the source again: the next time
+        // this session is resumed, the record — not a stale in-memory override —
+        // decides, and the settings watcher may update the ref again.
+        this.subagentSelection.source = 'settings';
+        // The session record keeps the subagent route too, so a resumed
+        // cross-provider conversation comes back on the same children.
+        this.noteSessionRoute();
         const settings = this.ctx.get('settings');
         if (settings === undefined) {
             this.pushRow({ kind: 'error', text: t('sub.settingsMissing') });
@@ -6021,6 +7119,9 @@ export class SshTui {
     }
     /** Resolve the picker model list for one provider (endpoint first, then catalog). */
     async subagentModelOptions(provider) {
+        const family = this.providerFamilyRows(provider);
+        if (family.length > 1)
+            return this.loadFamilyModelOptions(family[0] ?? provider, family);
         const llm = this.ctx.get('llm');
         let options = [];
         let source = t('model.configured');
@@ -6066,11 +7167,10 @@ export class SshTui {
     }
     /** /submodel: pick (or set) the model subagent children use. */
     async runSubmodelCommand(arg) {
-        const provider = this.effectiveSubagentProvider();
         const current = this.subagentSelection.current;
         const direct = arg.trim();
         if (direct.toLowerCase() === 'reset' || direct === '跟随' || direct === '默认') {
-            const parentProvider = this.currentProviderId();
+            const parentProvider = this.displayProviderId(this.currentProviderId());
             const nextModel = defaultSubagentModelForProvider(parentProvider, [], this.selectionRef?.current?.model ?? this.agent.options.model);
             const persisted = await this.saveSubagentSelection({
                 model: nextModel,
@@ -6083,8 +7183,42 @@ export class SshTui {
             this.markDirty();
             return;
         }
+        const slash = direct.indexOf('/');
+        if (slash > 0) {
+            const providerId = direct.slice(0, slash).trim();
+            const modelId = direct.slice(slash + 1).trim();
+            if (providerId !== '' && modelId !== '') {
+                await this.commitSubagentRoute(providerId, modelId, { pinProvider: true });
+                return;
+            }
+        }
+        let provider = this.displayProviderId(this.effectiveSubagentProvider());
         let selectedId = direct;
         if (selectedId === '') {
+            const parentProvider = this.displayProviderId(this.currentProviderId());
+            const providers = this.listSelectableProviders();
+            const currentIndex = Math.max(0, providers.findIndex(option => option.id === provider));
+            const pinnedProvider = this.displayProviderId(current.provider ?? '');
+            const pickedAnswer = await this.askQuestion({
+                id: 'submodel-provider-pick',
+                question: t('sub.pickProvider'),
+                options: providers.map(option => ({
+                    label: option.label,
+                    // The description says what picking the row does. Picking the parent's
+                    // provider follows it — that is the one explicit way to unpin without
+                    // `/submodel reset` — so the parent row must not read "currently
+                    // pinned" just because the pin happens to name it.
+                    description: option.id === parentProvider
+                        ? t('sub.providerFollowsParent')
+                        : option.id === pinnedProvider
+                            ? t('sub.providerPinned')
+                            : describeProviderRoute(option.id).kind,
+                })),
+            }, 0, 1, currentIndex);
+            const pickedProvider = providers.find(option => option.label === pickedAnswer.selected[0])?.id;
+            if (pickedProvider === undefined)
+                return;
+            provider = pickedProvider;
             const { options, source } = await this.subagentModelOptions(provider);
             if (options.length === 0) {
                 options.push({ id: current.model, label: current.model });
@@ -6094,14 +7228,30 @@ export class SshTui {
                 return;
             selectedId = selected.id;
         }
-        if (!(await this.ensureProviderModelConfigured(provider, selectedId)))
+        await this.commitSubagentRoute(provider, selectedId, {
+            pinProvider: provider !== this.displayProviderId(this.currentProviderId()),
+        });
+    }
+    /** Persist one subagent provider/model pair and say whether it follows or is pinned. */
+    async commitSubagentRoute(provider, modelId, options) {
+        // The picker lists one row per gateway family; the model decides which
+        // protocol row underneath actually serves it.
+        const display = this.displayProviderId(provider);
+        const target = this.familyOwnerRow(display, modelId, await this.advertisedFor(display, modelId));
+        if (!(await this.ensureProviderModelConfigured(target, modelId)))
             return;
-        const persisted = await this.saveSubagentSelection({ ...current, model: selectedId });
+        const effort = this.subagentSelection.current.reasoningEffort;
+        const next = {
+            ...(options.pinProvider ? { provider: target } : {}),
+            model: modelId,
+            ...(effort === undefined ? {} : { reasoningEffort: effort }),
+        };
+        const persisted = await this.saveSubagentSelection(next);
         this.pushRow({
             kind: 'system',
-            text: (current.provider === undefined
-                ? t('sub.modelFollow', { model: selectedId, provider })
-                : t('sub.modelPinned', { model: selectedId, provider }))
+            text: (options.pinProvider
+                ? t('sub.modelPinned', { model: modelId, provider: display })
+                : t('sub.modelFollow', { model: modelId, provider: display }))
                 + (persisted ? '' : t('sub.sessionOnly')),
         });
         this.markDirty();
@@ -6109,6 +7259,7 @@ export class SshTui {
     /** /effort: pick or set the reasoning effort for the current model. */
     async runEffortCommand(arg) {
         const provider = this.currentProviderId();
+        const display = this.displayProviderId(provider);
         const current = this.selectionRef?.current;
         if (current === undefined || current.model === undefined) {
             this.pushRow({ kind: 'error', text: t('effort.noModel') });
@@ -6165,8 +7316,8 @@ export class SshTui {
         const answer = await this.askQuestion({
             id: 'effort-pick',
             question: isUndeclared
-                ? t('effort.pickCurrentUndeclared', { provider, model: modelId })
-                : t('effort.pickCurrent', { provider, model: modelId }),
+                ? t('effort.pickCurrentUndeclared', { provider: display, model: modelId })
+                : t('effort.pickCurrent', { provider: display, model: modelId }),
             options: choices.map(c => ({
                 label: c.label,
                 description: c.id === currentEffort ? t('disconnect.current') : c.desc,
@@ -6940,6 +8091,9 @@ export class SshTui {
                     else if (this.dialog?.kind === 'onboarding' && this.moveProviderCursor(-1)) {
                         return;
                     }
+                    else if (this.dialog?.kind === 'onboarding' && this.moveOnboardingModelCursor(-1)) {
+                        return;
+                    }
                     else if (this.suggestionsVisible()) {
                         this.suggestionIndex = Math.max(0, this.suggestionIndex - 1);
                         this.markDirty();
@@ -6961,6 +8115,9 @@ export class SshTui {
                     else if (this.dialog?.kind === 'onboarding' && this.moveProviderCursor(1)) {
                         return;
                     }
+                    else if (this.dialog?.kind === 'onboarding' && this.moveOnboardingModelCursor(1)) {
+                        return;
+                    }
                     else if (this.suggestionsVisible()) {
                         this.suggestionIndex = Math.min(this.commandSuggestions.length - 1, this.suggestionIndex + 1);
                         this.markDirty();
@@ -7416,8 +8573,8 @@ export class SshTui {
         const templates = providerTemplates();
         const templateEntries = [
             { key: 'template:official', label: templates.official.label, detail: 'api.deepseek.com' },
-            { key: 'template:opencode-go', label: templates['opencode-go'].label, detail: 'opencode.ai/zen/go · Responses' },
-            { key: 'template:command-code', label: templates['command-code'].label, detail: 'api.commandcode.ai · Completions' },
+            { key: 'template:opencode-go', label: templates['opencode-go'].label, detail: t('onboard.protocolAuto') },
+            { key: 'template:command-code', label: templates['command-code'].label, detail: t('onboard.protocolAuto') },
             { key: 'template:openai-completions', label: templates['openai-completions'].label, detail: 'openai-completions' },
             { key: 'template:openai-responses', label: templates['openai-responses'].label, detail: 'openai-responses' },
             { key: 'template:anthropic-messages', label: templates['anthropic-messages'].label, detail: 'anthropic-messages' },
@@ -7464,6 +8621,108 @@ export class SshTui {
         }
         return sized;
     }
+    /**
+     * Leave the models step, after one best-effort trip to the gateway for what
+     * the picks are still missing: the context window / output cap of every model
+     * the listing has not described yet, and — for a gateway that spreads over
+     * several protocols — the endpoints each picked model answers.
+     *
+     * `Ctrl+F` stays as it was, but it is no longer the only way to learn these:
+     * a model typed by hand would otherwise be saved with no capacity at all, and
+     * with no endpoint data the split had nothing to file it by.
+     */
+    async finishModelsStep(state) {
+        if (this.onboarding !== state || !isModelsStep(state.step))
+            return;
+        if (this.finishingModels.has(state))
+            return;
+        this.finishingModels.add(state);
+        try {
+            const previousStatus = this.status;
+            if (this.onboardingWantsEndpoint(state)) {
+                const fetching = t('onboard.fetchingModels');
+                this.status = fetching;
+                this.markDirty();
+                await this.enrichOnboardingModels(state);
+                // Only take back the line this step put up: a turn that started while
+                // the listing was in flight owns the status now, and restoring the
+                // pre-fetch value would erase "turn 7 running" behind its back.
+                if (this.status === fetching)
+                    this.status = previousStatus;
+            }
+            // The wizard may have been cancelled or reset while the fetch was in flight.
+            if (this.onboarding !== state || !isModelsStep(state.step))
+                return;
+            // Size the picks before the confirm step so the route default the wizard
+            // persists is derived, not guessed: the listing first, the installed
+            // catalog second. Only when some pick stayed unsized does the route
+            // default matter, and only then is a step shown for it.
+            const sized = this.sizeOnboardingModels(state);
+            const unsized = state.models.filter(id => !sized.has(id));
+            if (unsized.length === 0) {
+                state.step = 'confirm';
+            }
+            else {
+                state.routeContextWindow = suggestedRouteContextWindow(sized.values())
+                    ?? HARNESS_DEFAULT_CONTEXT_WINDOW;
+                state.step = 'context';
+            }
+            this.input = '';
+            this.cursor = 0;
+            this.markDirty();
+        }
+        finally {
+            this.finishingModels.delete(state);
+        }
+    }
+    /** Whether leaving the models step has anything left to ask the gateway for. */
+    onboardingWantsEndpoint(state) {
+        if (onboardTemplate(state).protocols !== undefined && state.modelEndpoints === undefined)
+            return true;
+        return state.models.some(id => state.modelCapacity?.get(id)?.contextWindow === undefined);
+    }
+    /** Fill the picks' capacities and endpoints from the gateway; never fatal. */
+    async enrichOnboardingModels(state) {
+        const template = onboardTemplate(state);
+        const baseURL = state.baseUrl === '' ? template.defaultBaseUrl : state.baseUrl;
+        if (baseURL === '')
+            return;
+        const wantsEndpoints = template.protocols !== undefined && state.modelEndpoints === undefined;
+        const wantsCapacity = state.models.some(id => state.modelCapacity?.get(id)?.contextWindow === undefined);
+        const llm = this.ctx.get('llm');
+        if (wantsCapacity && llm !== undefined) {
+            try {
+                const discovered = await discoverProviderModels(llm, {
+                    baseURL,
+                    ...(template.api === undefined ? {} : { api: template.api }),
+                    ...(state.key === '' ? {} : { apiKey: state.key }),
+                }, AbortSignal.timeout(8_000));
+                state.modelCapacity ??= new Map();
+                for (const model of discovered) {
+                    if (!state.models.includes(model.id))
+                        continue;
+                    const capacity = { ...(state.modelCapacity.get(model.id) ?? {}) };
+                    if (capacity.contextWindow === undefined && model.contextWindow !== undefined) {
+                        capacity.contextWindow = model.contextWindow;
+                    }
+                    if (capacity.maxTokens === undefined && model.maxTokens !== undefined) {
+                        capacity.maxTokens = model.maxTokens;
+                    }
+                    if (Object.keys(capacity).length > 0)
+                        state.modelCapacity.set(model.id, capacity);
+                }
+            }
+            catch {
+                // The listing is an enrichment, not a gate: the installed catalog and
+                // the route default still cover a gateway that cannot be listed.
+            }
+        }
+        if (wantsEndpoints) {
+            const endpoints = await fetchModelEndpoints(baseURL, state.key);
+            if (endpoints !== undefined)
+                state.modelEndpoints = endpoints;
+        }
+    }
     handleOnboardingChar(text) {
         const state = this.onboarding;
         if (state === undefined)
@@ -7523,7 +8782,77 @@ export class SshTui {
             case 'base-url':
             case 'key':
             case 'models':
+            case 'models-pick':
+            case 'model-default':
             case 'context': {
+                if (state.step === 'models-pick') {
+                    // The step is already being left (the gateway listing is in flight):
+                    // the pick is decided, so a stray key must not reopen it.
+                    if (this.finishingModels.has(state))
+                        return;
+                    const total = state.modelCandidates?.length ?? 0;
+                    if (total === 0) {
+                        state.step = 'models';
+                        this.markDirty();
+                        return;
+                    }
+                    const checked = state.modelChecked ?? (state.modelChecked = new Set());
+                    if (text === '\r' || text === '\n') {
+                        const picked = this.checkedOnboardingModels(state);
+                        if (picked.length === 0) {
+                            this.pushRow({ kind: 'error', text: t('onboard.needModel') });
+                            this.markDirty();
+                            return;
+                        }
+                        state.models = picked;
+                        state.defaultModel = picked[0];
+                        if (picked.length > 1) {
+                            state.step = 'model-default';
+                            state.modelCursor = 0;
+                            this.markDirty();
+                            return;
+                        }
+                        this.advanceOnboarding();
+                        return;
+                    }
+                    if (text === ' ' || text === '　') {
+                        const index = state.modelCursor ?? 0;
+                        if (checked.has(index))
+                            checked.delete(index);
+                        else
+                            checked.add(index);
+                        this.markDirty();
+                        return;
+                    }
+                    const hotkey = questionOptionIndex(text, total);
+                    if (hotkey !== undefined) {
+                        state.modelCursor = hotkey;
+                        if (checked.has(hotkey))
+                            checked.delete(hotkey);
+                        else
+                            checked.add(hotkey);
+                        this.markDirty();
+                    }
+                    return;
+                }
+                if (state.step === 'model-default') {
+                    if (this.finishingModels.has(state))
+                        return;
+                    const picked = this.checkedOnboardingModels(state);
+                    if (text === '\r' || text === '\n') {
+                        const chosen = picked[Math.min(state.modelCursor ?? 0, Math.max(0, picked.length - 1))];
+                        if (chosen !== undefined)
+                            state.defaultModel = chosen;
+                        this.advanceOnboarding();
+                        return;
+                    }
+                    const hotkey = questionOptionIndex(text, picked.length);
+                    if (hotkey !== undefined) {
+                        state.modelCursor = hotkey;
+                        this.markDirty();
+                    }
+                    return;
+                }
                 if (state.step === 'models' && text === '\x06') {
                     void this.fetchOnboardingModels();
                     return;
@@ -7549,19 +8878,26 @@ export class SshTui {
                         state.key = value;
                     }
                     else if (state.step === 'models') {
-                        const template = onboardTemplate(state);
-                        // Ctrl+F has already filled state.models; Enter accepts that
-                        // listing instead of discarding it for the template's placeholder
-                        // ids, which a generic gateway does not serve.
-                        const parsed = value === ''
-                            ? (state.models.length > 0 ? state.models : template.defaultModels)
-                            : value.split(/[\s,，]+/u).filter(Boolean);
+                        // Leaving the step is already under way (the gateway listing is in
+                        // flight): a second Enter must not restart it or reopen the picker.
+                        if (this.finishingModels.has(state))
+                            return;
+                        if (value === '') {
+                            // The default answer is a choice, not "take everything the listing
+                            // returned": the picker shows the models and lets the user pick
+                            // which to configure, then which one to run. A typed list stays
+                            // the power-user path and skips both questions.
+                            this.openOnboardingModelPicker(state);
+                            return;
+                        }
+                        const parsed = value.split(/[\s,，]+/u).filter(Boolean);
                         if (parsed.length === 0) {
                             this.pushRow({ kind: 'error', text: t('onboard.needModel') });
                             this.markDirty();
                             return;
                         }
                         state.models = parsed;
+                        state.defaultModel = parsed[0];
                     }
                     else if (state.step === 'context') {
                         // Enter keeps the pre-filled value; a typed number overrides it.
@@ -7608,6 +8944,12 @@ export class SshTui {
                     state.baseUrl = '';
                     state.key = '';
                     state.models = [];
+                    // A restart must not inherit the previous run's picker: a stale
+                    // `modelChecked` would pre-tick models from the provider being left.
+                    state.defaultModel = undefined;
+                    state.modelCandidates = [];
+                    state.modelChecked = new Set();
+                    state.modelCursor = 0;
                     state.modelCapacity = new Map();
                     this.input = '';
                     this.cursor = 0;
@@ -7632,21 +8974,11 @@ export class SshTui {
         else if (state.step === 'key') {
             state.step = 'models';
         }
-        else if (state.step === 'models') {
-            // Size the picks before the confirm step so the route default the wizard
-            // persists is derived, not guessed: the listing first, the installed
-            // catalog second. Only when some pick stayed unsized does the route
-            // default matter, and only then is a step shown for it.
-            const sized = this.sizeOnboardingModels(state);
-            const unsized = state.models.filter(id => !sized.has(id));
-            if (unsized.length === 0) {
-                state.step = 'confirm';
-            }
-            else {
-                state.routeContextWindow = suggestedRouteContextWindow(sized.values())
-                    ?? HARNESS_DEFAULT_CONTEXT_WINDOW;
-                state.step = 'context';
-            }
+        else if (isModelsStep(state.step)) {
+            // Leaving the models step is asynchronous: the gateway is asked once more
+            // for whatever the picks are still missing (see finishModelsStep).
+            void this.finishModelsStep(state);
+            return;
         }
         else if (state.step === 'context') {
             state.step = 'confirm';
@@ -7655,6 +8987,92 @@ export class SshTui {
         this.cursor = 0;
         this.markDirty();
     }
+    /**
+     * Open the models picker: every model the listing offered — or the template's
+     * pinned ones when nothing was listed — with the template's models checked.
+     *
+     * Enter used to accept the whole listing, which quietly wrote every model of
+     * the gateway into settings and made the session's model whichever id came
+     * first. The picker makes both the set and the session's model explicit; a
+     * typed list still skips it.
+     */
+    openOnboardingModelPicker(state) {
+        const template = onboardTemplate(state);
+        const candidates = [...new Set((state.models.length > 0 ? state.models : template.defaultModels).filter(id => id !== ''))];
+        if (candidates.length === 0) {
+            this.pushRow({ kind: 'error', text: t('onboard.needModel') });
+            this.markDirty();
+            return;
+        }
+        const pinned = new Set(template.defaultModels);
+        const checked = new Set();
+        candidates.forEach((id, index) => {
+            if (pinned.has(id))
+                checked.add(index);
+        });
+        if (checked.size === 0)
+            checked.add(0);
+        state.modelCandidates = candidates;
+        state.modelChecked = checked;
+        state.modelCursor = Math.min(...checked);
+        state.step = 'models-pick';
+        this.input = '';
+        this.cursor = 0;
+        this.markDirty();
+    }
+    /** The checked models of the wizard's picker, in listing order. */
+    checkedOnboardingModels(state) {
+        const candidates = state.modelCandidates ?? [];
+        return [...(state.modelChecked ?? new Set())]
+            .sort((left, right) => left - right)
+            .map(index => candidates[index])
+            .filter((id) => id !== undefined);
+    }
+    /** Move the highlight in either picker step. */
+    moveOnboardingModelCursor(delta) {
+        const state = this.onboarding;
+        if (state === undefined)
+            return false;
+        if (state.step === 'models-pick') {
+            const total = state.modelCandidates?.length ?? 0;
+            if (total === 0)
+                return false;
+            state.modelCursor = Math.max(0, Math.min(total - 1, (state.modelCursor ?? 0) + delta));
+            this.markDirty();
+            return true;
+        }
+        if (state.step === 'model-default') {
+            const picked = this.checkedOnboardingModels(state);
+            if (picked.length === 0)
+                return false;
+            state.modelCursor = Math.max(0, Math.min(picked.length - 1, (state.modelCursor ?? 0) + delta));
+            this.markDirty();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Esc in a picker step goes back one step instead of throwing the wizard
+     * away — the listing is the expensive part and the user is still choosing.
+     */
+    stepBackOnboarding() {
+        const state = this.onboarding;
+        if (state === undefined)
+            return false;
+        if (state.step === 'models-pick') {
+            state.step = 'models';
+            this.markDirty();
+            return true;
+        }
+        if (state.step === 'model-default') {
+            state.step = 'models-pick';
+            const checked = [...(state.modelChecked ?? new Set())];
+            state.modelCursor = checked.length === 0 ? 0 : Math.min(...checked);
+            this.markDirty();
+            return true;
+        }
+        return false;
+    }
     /** Fetch the endpoint's model list into the onboarding wizard's models step. */
     async fetchOnboardingModels() {
         const state = this.onboarding;
@@ -7699,6 +9117,11 @@ export class SshTui {
                 this.pushRow({ kind: 'error', text: t('onboard.noModels') });
             }
             else {
+                // Read the gateway's own route list while the key is still in hand: the
+                // confirm step has no way to ask for it again.
+                if (template.protocols !== undefined) {
+                    state.modelEndpoints = await fetchModelEndpoints(baseURL, key);
+                }
                 state.models = ids;
                 state.modelCapacity = new Map(discovered.flatMap(model => {
                     const capacity = {
@@ -7724,6 +9147,10 @@ export class SshTui {
         const state = this.onboarding;
         if (state === undefined)
             return;
+        // `/setup` can switch the parent route (that is the point of adding a key),
+        // so remember where it pointed before the wizard's answer is applied: the
+        // subagent pin question below needs the old value.
+        const previousParentProvider = this.currentProviderId();
         let saved = true;
         try {
             const credentials = this.ctx.get('credentials');
@@ -7732,14 +9159,14 @@ export class SshTui {
             if (state.providerType === 'official') {
                 const envRef = 'DEEPSEEK_API_KEY';
                 await this.saveCredential(credentials, envRef, state.key);
-                const model = state.models[0] ?? 'deepseek-v4-pro';
+                const model = state.defaultModel ?? state.models[0] ?? 'deepseek-v4-pro';
                 await this.ctx.get('agentDefaultModel')?.saveSelection({ provider: 'deepseek-official', model });
                 if (this.selectionRef !== undefined) {
                     this.selectionRef.current = { provider: 'deepseek-official', model };
                 }
                 this.onSelectionChanged?.({ provider: 'deepseek-official', model });
                 await this.rememberRoute({ provider: 'deepseek-official', model });
-                await this.syncSubagentToProvider('deepseek-official', state.models);
+                await this.syncSubagentToProvider('deepseek-official', state.models, previousParentProvider !== 'deepseek-official');
                 if (state.baseUrl !== '' && settings !== undefined) {
                     await settings.update(settingsNamespace('llm-deepseek'), { baseURL: state.baseUrl });
                     this.pushRow({ kind: 'system', text: t('onboard.baseSaved', { path: displayDshPath('settings.yaml') }) });
@@ -7753,7 +9180,7 @@ export class SshTui {
             }
             else {
                 const envRef = envRefForId(state.providerId);
-                const model = state.models[0];
+                const model = state.defaultModel ?? state.models[0];
                 // OpenCode / third-party (llm-pi-ai) routes have no adapter-level
                 // reasoning default. Re-running setup must not silently drop the
                 // effort that makes thinking arrive as `reasoning` blocks; default it
@@ -7769,7 +9196,44 @@ export class SshTui {
                     : await defaultReasoningEffort(llm, state.providerId, model);
                 const reasoningEfforts = onboardingReasoningEfforts(state.providerType, defaultEffort === undefined ? undefined : String(defaultEffort));
                 const existing = this.piAiProviderProfile(state.providerId);
-                const existingModels = Array.isArray(existing?.models) ? existing.models : [];
+                // One gateway can already be spread over sibling entries (an earlier
+                // setup, or a hand-written profile): the pool is every model the gateway
+                // has, so re-running setup re-homes them instead of duplicating or
+                // dropping any.
+                const baseProtocol = declaredProtocol(existing?.api) ?? template.api ?? 'openai-completions';
+                const siblingEntries = template.protocols === undefined
+                    ? []
+                    : template.protocols
+                        .filter(protocol => protocol !== baseProtocol)
+                        .map(protocol => ({
+                        protocol,
+                        profile: this.piAiProviderProfile(siblingProviderId(state.providerId, protocol)),
+                    }));
+                const existingModels = [
+                    ...(Array.isArray(existing?.models) ? existing.models : []),
+                    ...siblingEntries.flatMap(entry => (Array.isArray(entry.profile?.models) ? entry.profile.models : [])),
+                ];
+                // Where each model already sits, so the split re-homes only what the
+                // gateway itself says moved: a working placement is never relocated by
+                // the table, and `/setup` keeps the promise that an existing model list
+                // only grows.
+                const modelPlacement = new Map();
+                const recordPlacement = (models, protocol) => {
+                    if (!Array.isArray(models))
+                        return;
+                    for (const raw of models) {
+                        const id = typeof raw === 'string'
+                            ? raw
+                            : typeof raw === 'object' && raw !== null && typeof raw.id === 'string'
+                                ? raw.id
+                                : '';
+                        if (id !== '' && !modelPlacement.has(id))
+                            modelPlacement.set(id, protocol);
+                    }
+                };
+                recordPlacement(existing?.models, baseProtocol);
+                for (const entry of siblingEntries)
+                    recordPlacement(entry.profile?.models, entry.protocol);
                 // The confirm step can be reached without walking the models step (and
                 // a saved catalog answer may have landed after it), so size the picks
                 // here too: the call is idempotent and fills only missing windows.
@@ -7798,36 +9262,74 @@ export class SshTui {
                 // and an absent key defers to the provider's own environment auth.
                 const catalogRoute = state.providerType === 'catalog' && state.catalog !== undefined;
                 const keyless = catalogRoute && state.key === '';
-                const profile = {
+                const baseURL = state.baseUrl === ''
+                    ? (typeof existing?.baseURL === 'string' && existing.baseURL !== '' ? existing.baseURL : template.defaultBaseUrl)
+                    : state.baseUrl;
+                // A gateway with `protocols` keeps one wizard row and lands in several
+                // provider entries, one per protocol its models actually speak. The base
+                // id keeps the protocol it already declares (so routes naming it never
+                // change meaning); a fresh gateway takes the template's pinned one.
+                const split = template.protocols === undefined
+                    ? new Map([[baseProtocol, mergedIds]])
+                    : splitModelsByProtocol({
+                        models: mergedIds,
+                        ...(state.modelEndpoints === undefined ? {} : { advertised: state.modelEndpoints }),
+                        ...(modelPlacement.size === 0 ? {} : { existing: modelPlacement }),
+                        ...(gatewayModelTable(baseURL) === undefined ? {} : { table: gatewayModelTable(baseURL) }),
+                        fallback: baseProtocol,
+                        preference: template.protocols,
+                    });
+                const profileFor = (protocol, models) => ({
                     displayName: typeof existing?.displayName === 'string' && existing.displayName.trim() !== ''
                         ? existing.displayName
                         : template.label,
                     ...(keyless ? {} : { apiKeyEnv: envRef }),
-                    api: template.api ?? existing?.api,
-                    ...(catalogRoute && state.baseUrl === ''
-                        ? {}
-                        : {
-                            baseURL: state.baseUrl === ''
-                                ? (typeof existing?.baseURL === 'string' && existing.baseURL !== '' ? existing.baseURL : template.defaultBaseUrl)
-                                : state.baseUrl,
-                        }),
-                    models: mergedIds.map(id => ({
+                    // A catalog route leaves the protocol to the installed catalog: it
+                    // used to write no `api` at all, and pinning one here would override
+                    // whatever that catalog serves.
+                    api: template.protocols === undefined ? (template.api ?? existing?.api) : protocol,
+                    ...(catalogRoute && state.baseUrl === '' ? {} : { baseURL }),
+                    models: models.map(id => ({
                         id,
                         ...(state.modelCapacity?.get(id) ?? template.defaultModelCapacity?.[id] ?? {}),
                         ...(reasoningEfforts === undefined ? {} : { reasoningEfforts }),
                     })),
                     ...(state.routeContextWindow === undefined ? {} : { defaultContextWindow: state.routeContextWindow }),
                     ...(defaultEffort === undefined ? {} : { reasoning: defaultEffort }),
-                };
+                });
+                // Write every protocol that ends up holding models, plus any sibling
+                // that exists but is now empty because its models moved elsewhere.
+                const writes = [...split]
+                    .filter(([, models]) => models.length > 0)
+                    .map(([protocol, models]) => ({ protocol, models }));
+                for (const sibling of siblingEntries) {
+                    // Only an entry that exists can be emptied: never create a sibling
+                    // just to say it holds nothing.
+                    if (sibling.profile === undefined)
+                        continue;
+                    if (!writes.some(entry => entry.protocol === sibling.protocol)) {
+                        writes.push({ protocol: sibling.protocol, models: [] });
+                    }
+                }
+                const entryId = (protocol) => protocol === baseProtocol ? state.providerId : siblingProviderId(state.providerId, protocol);
+                // The route the wizard hands over must be the entry that actually lists
+                // the chosen model — with a split they are no longer the same id.
+                const ownerId = entryId(writes.find(entry => entry.models.includes(model))?.protocol ?? baseProtocol);
                 if (settings === undefined) {
                     this.pushRow({ kind: 'error', text: t('onboard.settingsMissing') });
                     saved = false;
                 }
                 else {
-                    await settings.mutate(settingsNamespace('llm-pi-ai'), [
-                        { op: 'set', path: ['providers', state.providerId], value: profile },
-                    ]);
+                    await settings.mutate(settingsNamespace('llm-pi-ai'), writes.map(entry => ({
+                        op: 'set',
+                        path: ['providers', entryId(entry.protocol)],
+                        value: profileFor(entry.protocol, entry.models),
+                    })));
                     this.pushRow({ kind: 'system', text: t('onboard.providerSaved', { id: state.providerId, path: displayDshPath('settings.yaml') }) });
+                    if (template.protocols !== undefined) {
+                        const summary = writes.map(entry => `${GATEWAY_PROTOCOL_SUFFIX[entry.protocol]} ${entry.models.length}`).join(' · ');
+                        this.pushRow({ kind: 'system', text: t('onboard.providerSplit', { id: state.providerId, summary }) });
+                    }
                 }
                 // Only store the key when its provider profile actually made it to
                 // settings; otherwise the saved key points at an unusable route.
@@ -7835,7 +9337,7 @@ export class SshTui {
                     await this.saveCredential(credentials, envRef, state.key);
                 if (saved) {
                     const selection = {
-                        provider: state.providerId,
+                        provider: ownerId,
                         model,
                         ...(defaultEffort === undefined ? {} : { reasoningEffort: defaultEffort }),
                     };
@@ -7845,10 +9347,10 @@ export class SshTui {
                     }
                     this.onSelectionChanged?.(selection);
                     await this.rememberRoute(selection);
-                    await this.syncSubagentToProvider(state.providerId, state.models);
+                    await this.syncSubagentToProvider(ownerId, state.models, previousParentProvider !== ownerId);
                     this.pushRow({
                         kind: 'system',
-                        text: t('onboard.customDone', { id: state.providerId, model }),
+                        text: t('onboard.customDone', { id: ownerId, model }),
                     });
                 }
             }
@@ -7998,8 +9500,12 @@ export class SshTui {
             }
             if (this.dialog.kind === 'confirm')
                 this.closeConfirm('cancel');
-            else if (this.dialog.kind === 'onboarding')
-                this.cancelOnboarding();
+            else if (this.dialog.kind === 'onboarding') {
+                // Inside the models picker Esc steps back through the wizard's own
+                // steps; anywhere else it still abandons the wizard.
+                if (!this.stepBackOnboarding())
+                    this.cancelOnboarding();
+            }
             else
                 this.dialog.reject(new UserQuestionError('ask_user_question was cancelled', 'ASK_ABORTED'));
             return;
@@ -8285,6 +9791,10 @@ export class SshTui {
         const text = this.input.trim();
         if (text === '')
             return;
+        // Framed mode paints the composer; line mode has to put the typed line
+        // into the log itself, or a `tee` never sees what the user sent.
+        if (this.lineMode)
+            this.pushRow({ kind: 'user', text: t('line.prompt', { text }) });
         if (text.startsWith('/')) {
             this.historyIndex = this.history.length;
             this.historyDraft = '';
@@ -8499,7 +10009,7 @@ export class SshTui {
                         ...(quota === undefined ? {} : { quota }),
                         ...(this.contextPressure === undefined ? {} : { context: this.contextPressure }),
                         parentModel: model,
-                        ...(sub.provider === undefined ? {} : { subProvider: sub.provider }),
+                        ...(sub.provider === undefined ? {} : { subProvider: this.displayProviderId(sub.provider) }),
                         subModel: sub.model,
                         cwd: this.workspaceCwd(),
                     });
@@ -8563,16 +10073,20 @@ export class SshTui {
                     this.pushRow({ kind: 'system', text: t('sub.none') });
                 }
                 else {
-                    const lines = [...this.activeSubagents.entries()].map(([runId, sub]) => {
+                    const lines = [...this.activeSubagents.entries()].map(([, sub]) => {
                         const card = this.findSubagentRow(sub.id);
-                        const label = card?.label ?? sub.id;
-                        const activity = card?.lastActivity ? ` · ${card.lastActivity}` : '';
+                        const label = card === undefined ? this.subagentNameFor(sub.id) : subagentDisplayName(card);
+                        const activity = card === undefined ? '' : (() => {
+                            const summary = subagentChipSummary(card);
+                            return summary === '' ? '' : ` · ${summary}`;
+                        })();
                         return t('sub.listLine', {
                             label,
+                            // `/subagents kill` takes this id, and the list is where a user
+                            // looks it up: the chip itself stays name-only.
                             id: sub.id,
                             provider: sub.provider,
                             seconds: Math.floor((Date.now() - sub.startedAt) / 1000),
-                            run: runId.slice(0, 8),
                             activity,
                         });
                     });