@deepseek-harness-tui/dsh-tui 0.14.1 → 0.16.0

package/lib/types/dsh-adapter/plugin.js

@@ -4,12 +4,19 @@ import { SessionId } from '@deepseek-ai/dsh-session';
 import UserQuestionService from '@deepseek-ai/dsh-user-questions';
 import * as toolAskUser from '@deepseek-ai/dsh-tool-ask-user';
 import Schema from '@deepseek-ai/schemastery';
-import { Config, normalizeBackendChoice } from './index.js';
+import { Config } from './index.js';
 import { configValues, createSettingsScope, resolveSettingsNamespace } from './compat/settings.js';
 import { createChannel } from './channel.js';
 import { createDshSession } from './backend/session.js';
-import { BACKEND_LOADERS, closeBackendResources, openBackendStartup, probeKernels, sdkInstall } from './backends.js';
+import { createTuiSettingsService } from './tui-settings.js';
+import { EDITABLE_CONFIG_KEYS } from '../settings/definitions.js';
+import { kernelEntriesOf } from '../components/kernelCatalog.js';
+import { openBackendStartup, prepareBackendStartup, probeKernels, installSurfaceFor } from './backends.js';
+import { backendLabel, isBackendIdSyntax, isRegisteredBackend, listBackends, listOfferedBackends, loadBackend, parseBackendChoice, unloadBackends } from './backend-registry.js';
+import { createPluginInstallEntry } from './plugin-install.js';
+import { createPluginManageEntry } from './plugin-manage.js';
 import { formatSessionRef } from '../agent/refs.js';
+import { createStartingSession } from '../agent/starting-session.js';
 import { createChannelSceneOutlet } from './channel-scene-outlet.js';
 import { mountChannelUi } from './channel-ui.js';
 import { bindChannelCommands } from './channel/commands.js';
@@ -18,6 +25,7 @@ import { createChildStderrReporter, installChildStderrGuard } from './childStder
 import { removeClipboardImageDir } from '../utils/clipboard.js';
 import { appendCrashLog, serializeCrashDetail, unserializableCrashDetail } from '../utils/crashDetail.js';
 import { logForDebugging } from '../utils/debug.js';
+import { createTerminalNotifier } from '../ink/terminal-notification.js';
 import { isEnvTruthy } from '../utils/envUtils.js';
 import { QuestionStore, bindQuestionStore } from './questions.js';
 import { prepareQuestionAnswerer } from './questions-answerer.js';
@@ -29,23 +37,24 @@ import { readActivityFrames } from '../activityPrefs.js';
 import { commitFullscreenFactoryMigration, planFullscreenFactoryMigration, readAppliedMigrations } from '../migrationPrefs.js';
 import { readModelPref } from '../modelPrefs.js';
 import { explicitModelRoute, recordedModelRoute, resolveModelRoute, validateModelRoute } from '../modelRoute.js';
-import { migratePresetPref, readPresetPref } from '../presetPrefs.js';
+import { migratePresetPref, presetOverrideFromEnv, readPresetPref } from '../presetPrefs.js';
 import { readEffortPref } from '../effortPrefs.js';
 import { composePreset, filterMinimalPresetTools, resolvePersistedPreset, resolvePersistedRoute, runningPresetOf } from './presets.js';
+import { createFreshAgent, isUnstoredFreshSession } from './fresh-agent.js';
 import { ensurePackagedPresets } from './packaged-presets.js';
 import { registerBundledPresets } from './bundled-presets.js';
 import { ensureLegacySessionEventTypes, snapshotLiveSessionEvents } from './compat/index.js';
-import { clearResumeTarget, resumeTargetFromArgv, writeResumeTarget } from '../sessionHistory.js';
-import { initialPromptFromCmdlineArgs } from './startup-args.js';
+import { clearResumeTarget, resumeTargetFromArgv, stripResumeArgs, writeResumeTarget } from '../sessionHistory.js';
+import { cmdlineArgsOf, initialPromptFromCmdlineArgs } from './startup-args.js';
 import { readHomePrefs } from '../homePrefs.js';
 import { handoffEventTag, formatHandoffNotice } from '../handoffEvents.js';
 import { armFirstFrameAck, beginHandoffAck, handoffAttemptId, ownsAltScreenExit } from '../handoffAck.js';
-import { KERNEL_IDS, KERNEL_SWITCH_HANDOFF_ENV, kernelDisplayName, readKernelPrefs, resolveRememberedBackend, writeKernelPrefs } from '../kernelPrefs.js';
+import { DSH_BACKEND_ID, HOST_NOTICE_ENV, KERNEL_SWITCH_HANDOFF_ENV, RESUME_BACKEND_ENV, RESUME_RETRY_ENV, parseBackendId, readKernelPrefs, resolveRememberedBackend, resolveResumeTarget, writeKernelPrefs } from '../kernelPrefs.js';
 import { shouldOfferOnboarding } from '../onboardingPrefs.js';
 import { resolveSessionCwd } from '../utils/workspaceRoot.js';
-import { beginRestartAttempt, checkForTuiUpdate, installedTuiVersion, isBootDeadlockTarget, isStandaloneRuntime, isVersionNewer, logRestartEvent, resolveDshProfileName, resolveTuiUpdateTarget, restartTui, updateTuiAndRestart, writeHandoffNotice, writeLastRunRecord } from '../update.js';
+import { LAUNCH_PROMPT_SENT_ENV, beginRestartAttempt, checkForTuiUpdate, installedTuiVersion, isBootDeadlockTarget, isStandaloneRuntime, isVersionNewer, logRestartEvent, resolveDshProfileName, resolveTuiUpdateTarget, restartTui, updateTuiAndRestart, writeHandoffNotice, writeLastRunRecord } from '../update.js';
 import { getLang, isLang, resolveStartupLang, setLang, t, writeLangPref } from '../i18n.js';
-import { applyBtwContextBudget, applyBtwContextTurns, applyCodeFrameStyle, applyCompanionSkin, applyImageBacking, applyMathImageBacking, applyMathImageScale, applyMathRendering, applyMermaidDiagrams, applyPageMargin, applySidePanelOpen, applySidePanelPanels, applySidePanelRatio, applySidePanelSplitEnabled, BTW_CONTEXT_BUDGET_MAX, BTW_CONTEXT_BUDGET_MIN, BTW_CONTEXT_TURNS_MAX, BTW_CONTEXT_TURNS_MIN, DEFAULT_PAGE_MARGIN, DEFAULT_SIDE_PANEL_IDS, DEFAULT_STATUS_BAR, isPageMarginMode, normalizeJobGroupFold, normalizePageMargin, normalizeScrollGutter, normalizeSidePanelPanels, normalizeStatusBar, normalizeToolBackground, parsePageMarginSpec, resolveMathRendering, SIDE_PANEL_ID_PATTERN } from '../tuiDisplayPrefs.js';
+import { applyBtwContextBudget, applyBtwContextTurns, applyCodeFrameStyle, applyCompanionSkin, applyImageBacking, applyMathImageBacking, applyMathImageScale, applyMathRendering, applyMermaidDiagrams, applyPageMargin, applySidePanelOpen, applySidePanelRatio, applySidePanelSplitEnabled, BTW_CONTEXT_BUDGET_MAX, BTW_CONTEXT_BUDGET_MIN, BTW_CONTEXT_TURNS_MAX, BTW_CONTEXT_TURNS_MIN, DEFAULT_PAGE_MARGIN, DEFAULT_SIDE_PANEL_IDS, DEFAULT_STATUS_BAR, isPageMarginMode, normalizeJobGroupFold, normalizePageMargin, normalizeScrollGutter, normalizeSidePanelPanels, normalizeStatusBar, normalizeToolBackground, parsePageMarginSpec, resolveMathRendering, SIDE_PANEL_ID_PATTERN } from '../tuiDisplayPrefs.js';
 import { draftComboConflicts, effectiveComboString, parseComboDraft, setKeymapOverrides, SHORTCUT_ACTIONS, } from '../utils/keymap.js';
 import { attachHerdrIntegration } from '../herdr.js';
 import { logMouseDebug } from '../utils/debug.js';
@@ -55,8 +64,11 @@ import { startSessionMountHeartbeat } from './session-mount-heartbeat.js';
 import { reserveMount } from '../sessionMounts.js';
 import { getHostDialogStore } from './dialogs.js';
 import { getHostStatusStore } from './status.js';
+import { attachSessionListMetadata } from './session-list-metadata.js';
 import { createActivityStore } from './activity-store.js';
 import { createContextOccupancyStore } from './context-occupancy.js';
+import { createTeamRosterStore } from './team-roster.js';
+import { createTeamCommandEntry, filterTeamReplacedTools } from './team-mode.js';
 import { getHostToastStore } from './toast.js';
 import { getHostShortcuts } from './shortcuts.js';
 import { getHostThemes } from './themes.js';
@@ -64,6 +76,10 @@ import { attachSessionToWorkspace } from './workspace.js';
 import { createLocalWorkspaceRuntime, getHostWorkspaceRuntime } from './workspaces.js';
 import { getHostSettingsSections, getLocalSettingsSectionsHost } from './settings-sections.js';
 import { compositionRoot, withHostRootCapability } from './host-access.js';
+import { armAdmissionLoader } from './admission-loader.js';
+import { assembleBackendsFromProfile } from './backend-assembly.js';
+import { applyConfiguredSidePanelPanels, applySidePanelPanelsFromSettings } from './panels.js';
+import { disposeRootSettled } from './root-dispose.js';
 import { render, ThemeProvider, AlternateScreen } from '../ui.js';
 import { PageMargin } from '../components/PageMargin.js';
 import { normalizeSplashFont } from '../components/splashFonts.js';
@@ -73,7 +89,11 @@ import instances from '../ink/instances.js';
 import { cursorMove, DISABLE_KITTY_KEYBOARD, DISABLE_MODIFY_OTHER_KEYS, DISABLE_WIN32_INPUT_MODE } from '../ink/termio/csi.js';
 import { DBP, DFE, DISABLE_MOUSE_TRACKING, EXIT_ALT_SCREEN, SHOW_CURSOR } from '../ink/termio/dec.js';
 import { CLEAR_ITERM2_PROGRESS, CLEAR_TAB_STATUS, supportsTabStatus, wrapForMultiplexer } from '../ink/termio/osc.js';
-import { fatalReasonForExit, registerProcessGuardFatalSink } from '../ink/update-overflow-guard.js';
+import { addProcessErrorAbsorber, fatalReasonForExit, registerProcessGuardFatalSink } from '../ink/update-overflow-guard.js';
+import { CHANNEL_UI_LIFETIME_ENDED } from '../adapter/channel/ui.js';
+import { markBoot } from '../utils/bootTrace.js';
+import { TERMINATION_SIGNALS, dieBySignal } from './process-exit.js';
+import { StartupOpenError } from './channel/state.js';
 /**
  * Interactive TUI front door for DeepSeek Harness agents.
  *
@@ -98,6 +118,11 @@ import { fatalReasonForExit, registerProcessGuardFatalSink } from '../ink/update
 let lastBootedFullscreen;
 // Image preferences also stay fixed across host recomposes until /restart.
 let lastBootedTerminalImages;
+// A replacement's first process already sent the launch prompt. Read once per
+// process (a recompose must not resend it) and dropped from the environment,
+// so a `dsh-tui "prompt"` run from inside the session keeps its own prompt.
+const launchPromptSent = process.env[LAUNCH_PROMPT_SENT_ENV] === '1';
+delete process.env[LAUNCH_PROMPT_SENT_ENV];
 // Kept importable from here: the startup parser moved to its own dependency-free
 // module so argv probes can load it without the whole plugin graph.
 export { initialPromptFromCmdlineArgs };
@@ -128,8 +153,10 @@ export function resolveTuiHostMode(stdoutIsTTY = process.stdout.isTTY === true,
     const explicitTuiLaunch = env.DSH_TUI_LAUNCHER_VERSION !== undefined || isStandaloneRuntime();
     return explicitTuiLaunch ? 'invalid-explicit-launch' : 'headless-host';
 }
-export async function apply(ctx, runtimeConfig, configOwner = ctx) {
+export async function apply(ctx, runtimeConfig, configOwner = ctx, runtimeOptions = {}) {
     const config = configValues(runtimeConfig);
+    const taskNotifier = createTerminalNotifier(process.stdout);
+    taskNotifier.configure(config.taskNotifications, config.notificationMethod);
     // /restart handoff diagnosis: the replacement process is marked by env and
     // logs its boot progress to ~/.dsh-tui/restart.log (ordinary launches stay
     // silent). First line lands before anything in this function can throw.
@@ -203,21 +230,40 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     }
     // Validate settings before creating an agent or taking over the terminal.
     const tuiSettingsNs = resolveSettingsNamespace(configOwner, Config);
+    // Register before agent creation so its first checkpoint includes web list metadata.
+    attachSessionListMetadata(ctx);
+    // The TUI's own settings layer (~/.dsh-tui/settings.json): the same
+    // document on every kernel and entry. Other namespaces still go
+    // to the host's settings service (absent in the standalone entry).
+    const tuiSettings = createTuiSettingsService({
+        ns: tuiSettingsNs,
+        profile: resolveDshProfileName() ?? runtimeOptions.profile ?? 'dsh-tui',
+        keys: EDITABLE_CONFIG_KEYS,
+        delegate: () => ctx.get('settings'),
+    });
+    // The in-process DSH kernel's screen mounts before DSH has composed: what
+    // needs DSH's services runs later, in `attachDsh`.
+    const entrySlot = runtimeOptions.entrySlot;
+    const dshInEntry = entrySlot?.dsh === true;
     // Modern hosts own a declarative registry; old hosts discover directories.
     // A modern bundle failure must not silently fall back to obsolete files.
-    if (!await registerBundledPresets(ctx))
-        try {
-            for (const result of ensurePackagedPresets()) {
-                if (result.status === 'conflict') {
-                    ctx.logger.warn(`dsh-tui: packaged preset "${result.id}" was not installed because an unmanaged preset already uses that id`);
+    const installPresets = async (presetCtx) => {
+        if (!await registerBundledPresets(presetCtx))
+            try {
+                for (const result of ensurePackagedPresets()) {
+                    if (result.status === 'conflict') {
+                        presetCtx.logger.warn(`dsh-tui: packaged preset "${result.id}" was not installed because an unmanaged preset already uses that id`);
+                    }
                 }
             }
-        }
-        catch (error) {
-            // A read-only home must not make the whole terminal unusable; the other
-            // official and user presets remain available.
-            ctx.logger.warn(`dsh-tui: unable to install packaged presets (${error instanceof Error ? error.message : String(error)})`);
-        }
+            catch (error) {
+                // A read-only home must not make the whole terminal unusable; the other
+                // official and user presets remain available.
+                presetCtx.logger.warn(`dsh-tui: unable to install packaged presets (${error instanceof Error ? error.message : String(error)})`);
+            }
+    };
+    if (!dshInEntry)
+        await installPresets(ctx);
     // UI language resolution: DSH_TUI_LANG env var wins, then the
     // settings.yaml `dsh-tui.lang` user layer (applied once the settings
     // namespace registers below), then cordis.yml `lang`, then the
@@ -263,6 +309,14 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
             }
         }
     }
+    // The questionnaire store every backend's questions park in (a non-DSH
+    // session's `question.request` events too); Chat renders it.
+    const questionStore = new QuestionStore(adapterRuntimeFor(ctx));
+    bindQuestionStore(ctx, questionStore);
+    // One store, one teardown effect on both API lines. The compatibility
+    // adapter binds either registration to this Cordis fiber; this separate
+    // effect rejects asks still parked in the UI during teardown.
+    ctx.effect(() => () => questionStore.rejectAll());
     // DSH user-interaction seam: the model's ask_user_question tool parks on
     // the userQuestions service until a UI answerer responds. Mount the
     // service when the composition doesn't (the official dsh-base
@@ -272,46 +326,49 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // seat is registered below; the 0.1.2 line's agent-aware waterfall needs the
     // channel owner and is therefore registered immediately after the channel
     // is created. Optional-service access goes through `ctx.get`, not the
-    // inject proxy.
-    const userQuestions = ctx.get('userQuestions') ?? new UserQuestionService(ctx);
-    ctx.plugin(toolAskUser);
-    // The host-level tool mount above is intentional for the TUI and for user
-    // presets, but the official Minimal preset is a single-tool trajectory (one
-    // persistent shell: bash on POSIX, pwsh on Windows). Filter only that preset
-    // at the final assembly boundary. Reading the session on every assembly also
-    // makes blank-session /preset switches and resumed sessions behave correctly.
-    ctx.on('system-prompt/assemble', async (_assembly, context, next) => {
-        const assembled = await next();
-        const presetId = context.agent === undefined ? undefined : runningPresetOf(context.agent.session);
-        return filterMinimalPresetTools(assembled, presetId);
-    });
-    const questionStore = new QuestionStore(adapterRuntimeFor(ctx));
-    bindQuestionStore(ctx, questionStore);
-    // One store, one teardown effect on both API lines. The compatibility
-    // adapter binds either registration to this Cordis fiber; this separate
-    // effect rejects asks still parked in the UI during teardown.
-    ctx.effect(() => () => questionStore.rejectAll());
-    // `/debug-prompt` snapshots the final provider-neutral request at the
-    // llm/stream boundary, after every prompt and tool contributor has run.
-    registerPromptDebug(ctx);
-    // API selection and registration live behind one adapter boundary. The UI
-    // bootstrap only translates a legacy seat conflict into its visible notice.
-    const questionAnswererRegistration = prepareQuestionAnswerer(ctx, userQuestions, questionStore);
-    const questionSeatDecision = questionAnswererRegistration.kind === 'legacy'
-        ? questionAnswererRegistration.yieldDecision
-        : undefined;
-    let questionSeatNotice;
-    if (questionSeatDecision?.action === 'alert-unverified') {
-        ctx.logger.error(`dsh-tui: user-questions provider seat is held by a component self-reporting as ${questionSeatDecision.incumbentId} ` +
-            '(identity not host-verified); this TUI will not register its questionnaire and model questions may be answered by it');
-        questionSeatNotice = t('question-provider-occupied-unverified', { id: questionSeatDecision.incumbentId ?? '' });
-    }
-    else if (questionSeatDecision?.action === 'alert') {
-        const displayId = questionSeatDecision.incumbentId ?? t('question-provider-occupied-unknown');
-        ctx.logger.error(`dsh-tui: user-questions provider seat is held by a non-host component (${displayId}); ` +
-            'this TUI will not register its questionnaire and model questions may be answered by it');
-        questionSeatNotice = t('question-provider-occupied', { id: displayId });
-    }
+    // inject proxy. The in-process DSH kernel mounts these from its dsh-tui row
+    // once DSH has composed: mounting them on the entry's root first would
+    // take the `userQuestions` seat the profile's own row registers.
+    const mountDshQuestionSeams = (dshCtx) => {
+        const userQuestions = dshCtx.get('userQuestions') ?? new UserQuestionService(dshCtx);
+        dshCtx.plugin(toolAskUser);
+        // The host-level tool mount above is intentional for the TUI and for user
+        // presets, but the official Minimal preset is a single-tool trajectory (one
+        // persistent shell: bash on POSIX, pwsh on Windows). Filter only that preset
+        // at the final assembly boundary. Reading the session on every assembly also
+        // makes blank-session /preset switches and resumed sessions behave correctly.
+        // Agent Teams is decided at the same boundary: presets keep their legacy
+        // delegation rows, and a request that carries `spawn_teammate` drops
+        // `subagent` / `subagent_fork` (team-mode.ts), so a team bundle switched
+        // at run time reaches the sessions already running.
+        dshCtx.on('system-prompt/assemble', async (_assembly, context, next) => {
+            const assembled = filterTeamReplacedTools(await next());
+            const presetId = context.agent === undefined ? undefined : runningPresetOf(context.agent.session);
+            return filterMinimalPresetTools(assembled, presetId);
+        });
+        // `/debug-prompt` snapshots the final provider-neutral request at the
+        // llm/stream boundary, after every prompt and tool contributor has run.
+        registerPromptDebug(dshCtx);
+        // API selection and registration live behind one adapter boundary. The UI
+        // bootstrap only translates a legacy seat conflict into its visible notice.
+        const registration = prepareQuestionAnswerer(dshCtx, userQuestions, questionStore);
+        const seatDecision = registration.kind === 'legacy' ? registration.yieldDecision : undefined;
+        let notice;
+        if (seatDecision?.action === 'alert-unverified') {
+            dshCtx.logger.error(`dsh-tui: user-questions provider seat is held by a component self-reporting as ${seatDecision.incumbentId} ` +
+                '(identity not host-verified); this TUI will not register its questionnaire and model questions may be answered by it');
+            notice = t('question-provider-occupied-unverified', { id: seatDecision.incumbentId ?? '' });
+        }
+        else if (seatDecision?.action === 'alert') {
+            const displayId = seatDecision.incumbentId ?? t('question-provider-occupied-unknown');
+            dshCtx.logger.error(`dsh-tui: user-questions provider seat is held by a non-host component (${displayId}); ` +
+                'this TUI will not register its questionnaire and model questions may be answered by it');
+            notice = t('question-provider-occupied', { id: displayId });
+        }
+        return { registration, notice };
+    };
+    const questionSeams = dshInEntry ? undefined : mountDshQuestionSeams(ctx);
+    let questionSeatNotice = questionSeams?.notice;
     // Child-process stderr guard (issue #17): MCP servers spawned with an
     // inherited stderr (the MCP SDK's stdio default) write straight to the
     // terminal device from the child process, bypassing the renderer's own
@@ -344,20 +401,14 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
         provider: config.provider,
         model: config.model,
     };
-    // Atomic route resolution (issue #67): a complete cordis.yml route wins
-    // whole, else the persisted `/model` choice wins whole, else Harness's
-    // provider-neutral agent-default-model selection. The local DeepSeek pair
-    // remains the final fallback for bare embedders without that service. This
-    // lets optional provider bundles supply the same default to Web and TUI
-    // without patching this front door by name.
-    const configuredDefault = ctx.get('agentDefaultModel')?.currentSelection?.();
-    const harnessDefault = typeof configuredDefault?.provider === 'string'
-        && configuredDefault.provider.length > 0
-        && typeof configuredDefault.model === 'string'
-        && configuredDefault.model.length > 0
-        ? { provider: configuredDefault.provider, model: configuredDefault.model }
-        : undefined;
-    const startupRoute = resolveModelRoute(configuredRoute, readModelPref(), harnessDefault);
+    // Atomic route resolution (issue #67): the persisted `/model` choice — the
+    // route the last session ran — wins whole; else a complete cordis.yml route
+    // wins whole as the deployment DEFAULT (it decides the first run, never a
+    // later one); else Harness's provider-neutral agent-default-model
+    // selection. The local DeepSeek pair remains the final fallback for bare
+    // embedders without that service. This lets optional provider bundles supply
+    // the same default to Web and TUI without patching this front door by name.
+    const { startupRoute, deploymentRoute } = startupRoutes(ctx, configuredRoute);
     // Session cwd (issue #96): explicit cordis.yml `cwd` wins; otherwise the
     // git worktree root containing the launch directory (the launch directory
     // itself outside any worktree), so `@` completion and mention expansion
@@ -413,11 +464,23 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
         ctx.logger.warn('dsh-tui: tuiPluginHost service is not mounted; plugin grant store, runtime generation and Host Descriptor are unavailable. ' +
             'The bundle patch is older than the installed dsh-tui package — update the globally installed dsh-tui launcher to match the profile (issue #183).');
     }
+    // Admit third-party activations from their package-root `dsh-plugin.json`.
+    armAdmissionLoader(ctx);
+    // Stage D-1: the backends installed bundles declare join the registry *here*,
+    // before anything below parses a backend choice (`parseBackendChoice` reads the
+    // registry for membership, so an id registered later reads as unknown: dsh plus a
+    // warning). Synchronous on purpose — a bundle's own rows are composed after this
+    // one, so waiting for them would be waiting past the parse. This is the caller
+    // notes 0009's "Wired (W-2)" section was still missing.
+    assembleBackendsFromProfile(ctx);
+    // The in-process DSH kernel mounts before the profile's workspace providers
+    // exist: a provider URI resolves in `attachDsh`, and an unresolvable one
+    // fails the startup session there instead of the mount.
     const initialWorkspace = requestedWorkspace === undefined
         ? undefined
         : await workspaceService.resolve(requestedWorkspace);
-    if (requestedWorkspace !== undefined && initialWorkspace === undefined) {
-        throw new Error(`dsh-tui: unsupported or unavailable workspace target: ${requestedWorkspace}`);
+    if (requestedWorkspace !== undefined && initialWorkspace === undefined && !dshInEntry) {
+        throw new Error(unsupportedWorkspaceTarget(requestedWorkspace));
     }
     const sessionCwd = initialWorkspace?.cwd ?? resolveSessionCwd(config.cwd);
     const meta = { cwd: sessionCwd };
@@ -425,8 +488,12 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // `dsh --profile tui` forwards `--resume` verbatim instead, so fall back to
     // the same app-argv snapshot as the initial prompt. Raw process.argv also
     // contains the DSH launcher's own -- and is only a legacy embedder fallback.
-    const cmdline = ctx.cmdlineArgs;
-    const cmdlineArgs = cmdline?.get?.() ?? cmdline?.args;
+    const cmdlineArgs = cmdlineArgsOf(ctx);
+    // The raw request, deliberately self-contained: `scripts/verify-startup-argv.mjs`
+    // replays this very statement (picked out of the compiled `apply` by name) to check
+    // the launcher's argv interception end to end, so it has to stay computable from
+    // `config` and `cmdlineArgs` alone. Whether the target may actually be used is
+    // decided further down, once the backend this boot lands on is known.
     const launchSessionId = config.sessionId ?? resumeTargetFromArgv(cmdlineArgs ?? process.argv.slice(2));
     // The session's backend (Config `backend`, `dsh-tui --backend`). A non-DSH
     // backend opens its own session here and skips everything DSH-specific
@@ -447,28 +514,118 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     const handoffBackendRaw = process.env[KERNEL_SWITCH_HANDOFF_ENV];
     if (handoffBackendRaw !== undefined)
         delete process.env[KERNEL_SWITCH_HANDOFF_ENV];
-    const handoffBackend = normalizeBackendChoice(handoffBackendRaw);
+    const handoffBackend = parseBackendChoice(handoffBackendRaw);
     // Fullscreen kernel switch: the old process spawned this one with an ACK
     // pipe on fd 3 and the alternate screen still open (see handoffAck.ts).
     const handoffAck = beginHandoffAck();
     if (handoffAck !== undefined) {
         logRestartEvent('handoff/boot: ack armed', { attemptId: handoffAttemptId() ?? '' });
     }
-    const backendChoice = resolveRememberedBackend({
+    // Every source is parsed in two stages (P0 D1): syntax first, then the
+    // registry. An id that is syntactically valid but not installed must behave
+    // exactly like an unknown value did before the set was open — dsh plus a
+    // warning, never a crashed boot. `envKnown` carries that into the resolver for
+    // the one source that arrives raw; the other three are parsed above/beside.
+    const configuredBackend = parseBackendChoice(config.backend);
+    const rememberedBackend = readKernelPrefs().backend;
+    const entryKernel = runtimeOptions.entryKernel;
+    const backendChoice = entryKernel ?? (dshInEntry ? DSH_BACKEND_ID : resolveRememberedBackend({
         ...(handoffBackend === undefined ? {} : { handoff: handoffBackend }),
-        configured: config.backend,
+        configured: configuredBackend,
         envRaw: rawBackend,
-        memory: readKernelPrefs().backend,
+        envKnown: isRegisteredBackend,
+        memory: isRegisteredBackend(rememberedBackend) ? rememberedBackend : undefined,
+    }));
+    const rawBackendGiven = rawBackend === undefined ? '' : rawBackend.trim();
+    // The launcher marks a *derived* resume target with the backend it read it from
+    // (RESUME_BACKEND_ENV); a target the user placed carries no mark. Read and
+    // deleted right away, like the kernel handoff above, so no child inherits it.
+    // The mark is parsed with the syntax gate alone: the source is typically a
+    // backend that is NOT registered here, which is the whole reason to check.
+    // A marked target belongs to that one backend, and this boot may have landed
+    // elsewhere — an uninstalled plugin id falls back to dsh (P0 D1), an unset
+    // DSH_TUI_BACKEND follows the remembered kernel instead. Handing it over either
+    // fails or resumes an unrelated session that happens to share the id, so it is
+    // revoked rather than carried across (PR #1380 review R2) — and a revocation is
+    // a refusal, not a cold start (roadmap §6 item 11, B-2a).
+    const resumeBackendRaw = process.env[RESUME_BACKEND_ENV];
+    if (resumeBackendRaw !== undefined)
+        delete process.env[RESUME_BACKEND_ENV];
+    // A safe-mode retry carries a licence to survive a revoked target (the launcher
+    // sets RESUME_RETRY_ENV; see resolveResumeTarget). Read and deleted right away,
+    // like the mark above: no child may inherit it.
+    const resumeRetry = process.env[RESUME_RETRY_ENV] !== undefined;
+    delete process.env[RESUME_RETRY_ENV];
+    const resumeTarget = resolveResumeTarget({
+        sessionId: launchSessionId,
+        sourceBackend: parseBackendId(resumeBackendRaw),
+        backendChoice,
+        retry: resumeRetry,
     });
-    if (rawBackend !== undefined && rawBackend.trim() !== '' && normalizeBackendChoice(rawBackend) === undefined) {
-        ctx.logger.warn(`dsh-tui: DSH_TUI_BACKEND="${rawBackend}" names no known backend (${KERNEL_IDS.join(', ')}); starting on dsh`);
+    const effectiveSessionId = resumeTarget.kind === 'usable' ? resumeTarget.sessionId : undefined;
+    // The non-DSH path below opens `backendChoice`'s own session — a revoked target
+    // must not reach it either.
+    const configuredSessionId = resumeTarget.kind === 'revoked' ? undefined : config.sessionId;
+    // Safe-mode retries replay the original argv. Revocation must also remove its
+    // resume flags, or either startup path can reopen the replacement backend's
+    // own last session after promising a cold start. Prompt parsing keeps raw argv.
+    const startupArgv = resumeTarget.kind === 'revoked'
+        ? stripResumeArgs(cmdlineArgs ?? process.argv.slice(2))
+        : cmdlineArgs ?? process.argv.slice(2);
+    if (resumeTarget.kind === 'revoked') {
+        // Fail closed (roadmap §6 item 11): the target belongs to another backend, so
+        // this boot neither carries it over nor quietly starts a session nobody asked
+        // for. A fatal refusal is thrown into the startup funnel, which reports it on
+        // stderr and exits non-zero after restoring the terminal; the only tolerated
+        // case is the safe-mode retry, whose target comes from last-run.json and whose
+        // failure would close the user's last way back (RESUME_RETRY_ENV).
+        // The advice must be executable (PR #1449 review R2): when the source backend
+        // is not registered here, `--backend <from> --resume` would hit this same
+        // refusal, so that branch says the backend is unavailable instead. The other
+        // branch names the id (`kernelId`), never the display label — `--backend`
+        // takes an id.
+        const refusalKey = !resumeTarget.fatal
+            ? 'resume-target-revoked-retry'
+            : isRegisteredBackend(resumeTarget.from) ? 'resume-target-revoked' : 'resume-target-revoked-uninstalled';
+        const refusal = t(refusalKey, {
+            from: resumeTarget.from,
+            kernel: backendLabel(backendChoice),
+            kernelId: backendChoice,
+        });
+        if (resumeTarget.fatal)
+            throw new Error(refusal);
+        ctx.logger.warn(refusal);
+    }
+    // Config and handoff outrank env: an ignored env value cannot invalidate the
+    // selected backend's resume target or claim that this boot fell back to DSH.
+    if (handoffBackend === undefined && configuredBackend === undefined
+        && rawBackendGiven !== '' && !isRegisteredBackend(rawBackendGiven.toLowerCase())) {
+        // Two cases, two sentences: a typo is not an uninstalled plugin (P0 D1).
+        const installed = listBackends().map(entry => entry.manifest.id).join(', ');
+        // The plain fallback (no resume request) keeps P0 D1's shape: dsh plus a
+        // warning, exit code 0. With a resume target in hand it must not: dsh would
+        // be asked to open an id that belongs to the backend the user named, which
+        // either fails or resumes a session of another backend (roadmap §6 item 11).
+        // Nothing is resumed, nothing is created — the boot stops here instead.
+        if (effectiveSessionId !== undefined) {
+            throw new Error(t('resume-backend-unavailable', {
+                backend: rawBackendGiven,
+                session: effectiveSessionId,
+                installed,
+            }));
+        }
+        ctx.logger.warn(isBackendIdSyntax(rawBackendGiven)
+            ? `dsh-tui: DSH_TUI_BACKEND="${rawBackend}" names no installed backend (registered: ${installed}); starting on dsh`
+            : `dsh-tui: DSH_TUI_BACKEND="${rawBackend}" is not a valid backend id (lowercase letters, digits and dashes); starting on dsh`);
     }
     /**
      * Whether a Config row or DSH_TUI_BACKEND overrides the selector's
      * remembered kernel. The selector then says so: a switch still restarts
      * onto the chosen kernel, but the next plain launch follows the override.
+     * Only a registered Config choice pins: the schema keeps syntactically
+     * valid but uninstalled ids too, which must not prevent a memory fallback.
      */
-    const backendPinned = config.backend !== undefined
+    const backendPinned = configuredBackend !== undefined
         || (rawBackend !== undefined && rawBackend.trim() !== '');
     // A remembered kernel whose backend cannot open (its SDK uninstalled, its
     // session store unreadable, …) must not kill the boot: without an explicit
@@ -477,27 +634,74 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // Explicit choices (flag/Config/handoff) and explicit resume targets keep
     // the hard failure: silently swapping what the user named would be worse.
     let backendStart;
+    /** The startup session still opening (`deferBackendOpen`); the channel adopts it. */
+    let backendStartup;
+    /** Once set, the channel's binding owns the session. */
+    let backendStartupAdopted = false;
     let backendFallbackNotice;
+    const deferBackendOpen = runtimeOptions.deferBackendOpen === true;
+    if (deferBackendOpen && backendChoice === 'dsh' && !dshInEntry) {
+        throw new Error('dsh-tui: the standalone entry cannot host the DSH kernel; start it through the profile launcher');
+    }
+    /** The in-process DSH kernel's startup session: settled by `attachDsh`
+     *  (the profile's dsh-tui row) or by a failed composition. */
+    let settleDshStartup;
+    let dshStartupSettled = false;
+    const dshStartup = dshInEntry
+        ? new Promise((resolve, reject) => {
+            settleDshStartup = {
+                resolve: startup => { dshStartupSettled = true; resolve(startup); },
+                reject: error => { dshStartupSettled = true; reject(error); },
+            };
+        })
+        : undefined;
+    // A boot that fails before the channel holds the startup must not leak an
+    // unhandled rejection.
+    dshStartup?.catch(() => undefined);
     if (backendChoice !== 'dsh') {
         try {
-            backendStart = await openBackendStartup(ctx, await BACKEND_LOADERS[backendChoice](), {
+            const startupInput = {
                 cwd: sessionCwd,
-                stderr: line => {
+                stderr: (line) => {
                     logForDebugging(`[${backendChoice}-stderr] ${line}`);
                     stderrReporter.push(line);
                 },
-                ...(config.sessionId === undefined ? {} : { configuredSessionId: config.sessionId }),
-                argv: cmdlineArgs ?? process.argv.slice(2),
-            });
+                ...(configuredSessionId === undefined ? {} : { configuredSessionId }),
+                argv: startupArgv,
+            };
+            // One load per launch, shared by the deferred path (the entry mounts
+            // between `prepare` and `start`) and the eager one.
+            const backendModule = await loadBackend(backendChoice);
+            if (deferBackendOpen) {
+                const prepared = await prepareBackendStartup(ctx, backendModule, startupInput);
+                const startup = prepared.start().then(opened => ({ session: opened.session, history: opened.initialHistory }));
+                backendStartup = startup;
+                // As for dshStartup above; the effect closes an unadopted session.
+                startup.catch(() => undefined);
+                ctx.effect(() => () => {
+                    if (backendStartupAdopted)
+                        return;
+                    void startup.then(opened => opened.session.dispose(), () => undefined).catch(() => undefined);
+                }, 'dsh-tui deferred backend startup');
+                backendStart = { ...prepared, session: createStartingSession(prepared.backendId, sessionCwd), initialHistory: [] };
+            }
+            else {
+                backendStart = await openBackendStartup(ctx, backendModule, startupInput);
+            }
         }
         catch (error) {
-            if (backendPinned || handoffBackend !== undefined || launchSessionId !== undefined)
+            if (deferBackendOpen || backendPinned || handoffBackend !== undefined || effectiveSessionId !== undefined)
                 throw error;
             const reason = error instanceof Error ? error.message : String(error);
             logForDebugging(`dsh-tui: remembered backend "${backendChoice}" failed to open (${reason}); falling back to dsh`);
-            backendFallbackNotice = t('kernel-memory-fallback', { name: kernelDisplayName(backendChoice), reason });
+            backendFallbackNotice = t('kernel-memory-fallback', { name: backendLabel(backendChoice), reason });
         }
     }
+    // Resolve a surviving bare request on the backend that actually opened.
+    // This also covers a remembered backend whose startup fell back to DSH.
+    const bootSessionId = backendStart === undefined
+        ? effectiveSessionId ?? resumeTargetFromArgv(startupArgv)
+        : backendStart.resumedSessionId;
     // The backend session (and its child process) belongs to this fiber until the
     // channel adopts it: a boot that throws before then disposes the fiber's
     // effects, and this one stops the child instead of leaking it. Dispose is
@@ -515,11 +719,15 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     const backendPermissions = backendStart === undefined ? undefined : new PermissionStore();
     if (backendPermissions !== undefined)
         ctx.effect(() => () => backendPermissions.settleAll());
-    const { agent, handle, agentPreset, route: createdRoute } = backendStart !== undefined
+    const resolved = backendStart !== undefined || dshInEntry
         ? { agent: undefined, handle: undefined, agentPreset: undefined, route: undefined }
-        : await resolveAgent(ctx, launchSessionId, configuredRoute, startupRoute, meta, config.preset);
+        : await resolveAgent(ctx, bootSessionId, configuredRoute, startupRoute, deploymentRoute, meta, config.preset);
+    let agent = resolved.agent;
+    const { handle, agentPreset, route: createdRoute } = resolved;
     // Workspace ownership is a DSH session-store fact (skipped off DSH).
-    if (agent !== undefined)
+    // `ctx` here is the context that owns the session: this plugin's, or the
+    // dsh-tui row's for the in-process DSH kernel (`attachDsh`).
+    const attachWorkspaceOwnership = async (ctx, agent) => {
         try {
             // Opening a persisted TUI session is an explicit ownership action too.
             // Older TUI versions only wrote the Session log, so attaching on every
@@ -556,6 +764,9 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
             // loud instead of silently leaving the conversation Ungrouped.
             ctx.logger.warn(`dsh-tui: session "${agent.session.id}" workspace attachment failed: ${error instanceof Error ? error.message : String(error)}`);
         }
+    };
+    if (agent !== undefined)
+        await attachWorkspaceOwnership(ctx, agent);
     // Status-line route: the exact route the agent runs with — on create the
     // validated startup resolution, on resume the route the target session's
     // own records carry (a complete cordis.yml pin wins over them).
@@ -579,6 +790,9 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // empty and the channel falls back to the last-request sample — as does a
     // non-DSH session, whose id the DSH meter never projects.
     const contextOccupancyStore = createContextOccupancyStore(ctx);
+    // Read side of the Agent Teams `agentTeam` projection, for the same TDZ
+    // reason; empty unless the profile mounts the team service.
+    const teamRosterStore = createTeamRosterStore(ctx);
     // The channel holds a backend session; this DSH one owns the resolved
     // handle (disposed by the binding when a later adoption replaces it).
     let startupSession;
@@ -586,16 +800,36 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
         startupSession = backendStart.session;
     else if (agent !== undefined)
         startupSession = createDshSession(ctx, { agent, handle });
+    else if (dshInEntry)
+        startupSession = createStartingSession('dsh', sessionCwd);
     else
         throw new Error('dsh-tui: no startup session was opened');
+    // The in-process DSH kernel's route and Config pins from its dsh-tui row,
+    // set in `attachDsh` before adoption; the getters below serve them.
+    const rowFacts = {};
+    /**
+     * The in-process DSH kernel's `/new` while no DSH session was adopted (its
+     * startup open failed). Installed by `attachDsh`.
+     */
+    let openDshSession;
+    let compositionFailed = false;
+    /** How the in-process DSH kernel's composition ended: a failing startup open
+     *  waits for it, so a failed composition (the root cause) is reported. */
+    let settleComposition = () => undefined;
+    const compositionSettled = new Promise(resolve => { settleComposition = resolve; });
     const rawChannel = createChannel(ctx, startupSession, {
         // The namespace this boot actually registered the settings section under
         // (the Config owner's Loader id; custom ids are supported). Chat and the
         // channel's own settings reads look the section up by it.
         settingsNs: tuiSettingsNs,
+        onTaskComplete: preview => {
+            if (!shadow)
+                taskNotifier.notify(t('task-complete-notification'), preview);
+        },
+        settingsService: tuiSettings,
         // The backend reports its model with its first turn (`system/init`);
         // until then the status line names the backend.
-        model: backendStart !== undefined ? backendStart.label : displayRoute.model,
+        get model() { return rowFacts.route?.model ?? (backendStart !== undefined ? backendStart.label : displayRoute.model); },
         ...(backendStart === undefined || backendPermissions === undefined ? {} : {
             backendLabel: backendStart.label,
             openSession: backendStart.open,
@@ -605,6 +839,17 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
             sessionPrefs: backendStart.sessionPrefs,
             initialHistory: backendStart.initialHistory,
             resumeCommand: backendStart.resumeCommand,
+            ...(backendStartup === undefined ? {} : { startup: backendStartup }),
+        }),
+        // The in-process DSH kernel: a DSH placeholder until the row's session.
+        ...(dshStartup === undefined ? {} : {
+            backendLabel: backendLabel('dsh'),
+            startup: dshStartup,
+            openSession: async (target) => {
+                if (target.kind !== 'create' || openDshSession === undefined)
+                    throw new Error(t('new-session-unavailable'));
+                return await openDshSession(target.cwd);
+            },
         }),
         // The activity projection only pushes on change; read the current value as
         // soon as this session binds so a resumed or reattached session renders its
@@ -619,6 +864,8 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
         // change, so a resumed session reads one baseline at bind time.
         contextPressure: contextOccupancyStore,
         seedContextOccupancy: session => contextOccupancyStore.seed(session),
+        team: teamRosterStore,
+        seedTeam: session => teamRosterStore.seed(session),
         // A RESUMED session keeps its persisted header cwd (issue #96 review):
         // pre-upgrade sessions recorded the launch directory, and re-resolving
         // from the current launch directory would split @ expansion / file
@@ -626,17 +873,19 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
         // sessions record sessionCwd at creation, so both agree there.
         // A resumed backend session runs where it was recorded.
         cwd: backendStart?.session.cwd ?? agent?.session.header.cwd ?? sessionCwd,
-        provider: backendStart !== undefined ? backendStart.backendId : displayRoute.provider,
+        get provider() { return rowFacts.route?.provider ?? (backendStart !== undefined ? backendStart.backendId : displayRoute.provider); },
         // Raw cordis.yml route (undefined when unset): the channel's
         // new-session path re-resolves prefs against these, and resume passes
         // only explicit values so the target session's own record wins.
-        configuredModel: config.model,
-        configuredProvider: config.provider,
+        get configuredModel() { return rowFacts.config === undefined ? config.model : rowFacts.config.model; },
+        get configuredProvider() { return rowFacts.config === undefined ? config.provider : rowFacts.config.provider; },
         // Raw cordis.yml `lang` / `activityFrames`: /reload must not override a
         // static deployment choice with the persisted preference.
         configuredLang: config.lang,
         configuredActivityFrames: config.activityFrames,
-        effort: config.effort,
+        // Read when the DSH extensions attach (the adoption), after the row's
+        // facts are in; the display fields below are fixed at the first frame.
+        get effort() { return rowFacts.config === undefined ? config.effort : rowFacts.config.effort; },
         activity: config.activity,
         // Explicit cordis.yml value (static deployment choice) wins over the
         // runtime `/activity` preference, which wins over the default.
@@ -645,14 +894,17 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
         contextBar: config.contextBar,
         // Same precedence for the agent preset: cordis.yml `preset` over the
         // persisted `/preset` choice; undefined adopts the roster default.
-        configuredPreset: config.preset,
+        get configuredPreset() { return rowFacts.config === undefined ? config.preset : rowFacts.config.preset; },
         agentPreset,
         // Shift+Tab session-mode cycle (undefined → the built-in default/
         // plan/full cycle in sessionModes.ts).
-        modes: config.modes,
+        get modes() { return rowFacts.config === undefined ? config.modes : rowFacts.config.modes; },
         // Edit/Write diff presentation (schema default 'auto'); the /settings
         // screen edits this key live through the dsh-tui namespace.
         diffLayout: config.diffLayout,
+        // Upstream auto-retry seeding (cordis.yml upstreamRetry, default on):
+        // only an explicit opt-out disables it.
+        get upstreamRetry() { return rowFacts.config === undefined ? config.upstreamRetry : rowFacts.config.upstreamRetry; },
         thinkingFold: config.thinkingFold,
         jobGroupFold: config.jobGroupFold,
         toolBackground: config.toolBackground,
@@ -674,6 +926,7 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
         // 的改动由 applyBrand 实时接上（branding.ts 负责解析）。
         brand: config.brand,
     });
+    backendStartupAdopted = backendStartup !== undefined;
     // Register the live Channel for the adapter Kernel. The Channel driver
     // resolves it lazily from the composition root, so this can be called after
     // the plugin-host Kernel started without requiring a re-mount.
@@ -682,9 +935,9 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // child activation context.
     const unregisterTuiChannel = registerTuiChannel(compositionRoot(ctx), rawChannel);
     ctx.effect(() => () => { unregisterTuiChannel(); });
-    const pluginHost = ctx.get('tuiPluginHost');
     const adapterRuntime = adapterRuntimeFor(ctx);
-    const uiMount = mountChannelUi(ctx, rawChannel, pluginHost, adapterRuntime.mode);
+    // Looked up per probe: the plugin-host row can compose after the mount.
+    const uiMount = mountChannelUi(ctx, rawChannel, ctx.get('tuiPluginHost'), adapterRuntime.mode, () => ctx.get('tuiPluginHost'));
     const channel = uiMount.channel;
     bindChannelCommands(rawChannel, channel);
     // last-run.json for the launcher's crash retry (see writeLastRunRecord):
@@ -692,6 +945,8 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // at that point. The kernel-switch branch skips the refresh because the
     // replacement writes its own record when it boots.
     const bootAttemptId = `${process.pid.toString(36)}-${Date.now().toString(36)}`;
+    /** None before DSH has composed (the in-process DSH kernel) or off DSH. */
+    const liveDshAgent = () => dshAgentOn(ctx, channel.agentId);
     const refreshLastRunRecord = () => {
         // An observational composition (replay/embedding) is not "the instance the
         // user ran last" — it must not overwrite the interactive record.
@@ -701,7 +956,7 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
             ? backendStart.persisted(channel.agentId, channel.rows)
             : isExitResumable({
                 pendingCount: channel.pending.length,
-                liveAgent: ctx.agents.get(SessionId(channel.agentId)),
+                liveAgent: liveDshAgent(),
                 startupAgent: agent,
             });
         writeLastRunRecord({
@@ -725,6 +980,13 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // lands once the channel can actually show it.
     if (backendFallbackNotice !== undefined)
         notifyChannel(backendFallbackNotice, { color: 'warning' });
+    // The entry could not use the installed dsh and fell back (this process,
+    // or the `dsh --profile` it handed the launch to): say why, once.
+    const hostNotice = process.env[HOST_NOTICE_ENV];
+    delete process.env[HOST_NOTICE_ENV];
+    if (hostNotice !== undefined && hostNotice !== '') {
+        notifyChannel(t('host-dsh-unavailable', { reason: hostNotice }), { color: 'warning', timeoutMs: 10000 });
+    }
     const submitChannel = text => {
         if (!shadow)
             channel.submit(text);
@@ -744,7 +1006,9 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     applySidePanelSplitEnabled(config.sidePanel?.splitEnabled);
     applySidePanelOpen(config.sidePanel?.open);
     applySidePanelRatio(config.sidePanel?.ratio);
-    applySidePanelPanels(config.sidePanel?.panels);
+    // Registered ids survive: on the profile path a third-party row may have
+    // registered its panel before this row applied (./panels.ts).
+    applyConfiguredSidePanelPanels(config.sidePanel?.panels);
     applyCompanionSkin(config.companion?.skin);
     applyBtwContextTurns(config.btw?.contextTurns);
     applyBtwContextBudget(config.btw?.contextBudget);
@@ -759,14 +1023,16 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // Without the extensions row (tuiToast absent) plugin toasts are dropped
     // by the runtime itself — same soft-degrade contract as the other seams.
     // Delivery uses the same owner-bound UI capability as all renderer actions.
-    const toastStore = getHostToastStore(ctx.get('tuiToast'));
-    toastStore?.setSink(delivery => {
-        notifyChannel(delivery.text, { color: delivery.color, timeoutMs: delivery.timeoutMs });
-    });
-    if (questionAnswererRegistration.kind === 'waterfall') {
+    const bindToastSink = () => {
+        getHostToastStore(ctx.get('tuiToast'))?.setSink(delivery => {
+            notifyChannel(delivery.text, { color: delivery.color, timeoutMs: delivery.timeoutMs });
+        });
+    };
+    bindToastSink();
+    if (questionSeams?.registration.kind === 'waterfall') {
         // Ownership follows the mutable channel; registration cleanup belongs to
         // this Cordis fiber.
-        questionAnswererRegistration.register(channel);
+        questionSeams.registration.register(channel);
     }
     // Fullscreen layout decision: the settings user layer (edited through the
     // /settings screen) overrides cordis.yml when set. The settings injection
@@ -777,6 +1043,11 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // (swapping layouts requires re-mounting the whole tree).
     let bootedFullscreen = config.fullscreen === true;
     let bootedTerminalImages = lastBootedTerminalImages ?? config.terminalImages ?? true;
+    // The launchpad boot decision (settings `launchpad`): same
+    // restart-to-apply pattern as fullscreen — resolved before the tree mounts
+    // from the settings user layer over cordis.yml; a mid-session edit is for
+    // the next boot, the running session keeps what it booted with.
+    let bootedLaunchpad = config.launchpad !== false;
     let rendererSettingsFrozen = false;
     const terminalImagesDisabledByEnv = isEnvTruthy(process.env.DSH_TUI_DISABLE_TERMINAL_IMAGES);
     // The settings service may come up AFTER this plugin's apply: the cordis
@@ -791,10 +1062,7 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
         resolveSettingsReady = () => resolve();
         setTimeout(resolve, 300);
     });
-    // Old hosts register a settings.yaml scope. 0.1.7 projects the plugin's
-    // volatile Config fields instead; both paths apply edits without remounting.
-    ctx.inject(['settings'], (settingsCtx) => {
-        // Loader targets the Config owner's fiber, not the injected child fiber.
+    ((settingsCtx) => {
         const scope = createSettingsScope(configOwner, settingsCtx.settings, tuiSettingsNs, Schema.object({
             diffLayout: Schema.union(['auto', 'split', 'unified']).default('auto'),
             thinkingFold: Schema.union(['preview', 'full']).default('preview'),
@@ -822,6 +1090,8 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
             expandEditor: Schema.boolean(),
             // Same no-default rule: applyDisplay resolves `?? config.smoothStreaming ?? true`.
             smoothStreaming: Schema.boolean(),
+            taskNotifications: Schema.union(['off', 'unfocused', 'always']),
+            notificationMethod: Schema.union(['auto', 'osc9', 'bel']),
             // Same no-default rule: applyDisplay resolves `?? config.mermaidDiagrams ?? true`.
             mermaidDiagrams: Schema.boolean(),
             // Code-frame shape; unset keeps the light rail frame.
@@ -913,6 +1183,10 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
             // Same no-default rule: unset keeps cordis.yml's `fullscreen`
             // decisive; set overrides it from the next boot on.
             fullscreen: Schema.boolean(),
+            // Same no-default rule as fullscreen: the launchpad boot gate reads
+            // `value.launchpad ?? config.launchpad ?? true`, so cordis.yml stays
+            // decisive while the user layer is unset.
+            launchpad: Schema.boolean(),
             // Unset inherits cordis.yml; a saved choice takes effect after restart.
             terminalImages: Schema.boolean(),
             // Built-in action-shortcut overrides, one optional combo string per
@@ -969,8 +1243,14 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
             if (typeof value.fullscreen === 'boolean') {
                 bootedFullscreen = value.fullscreen;
             }
+            if (typeof value.launchpad === 'boolean') {
+                bootedLaunchpad = value.launchpad;
+            }
             bootedTerminalImages = lastBootedTerminalImages ?? value.terminalImages ?? config.terminalImages ?? true;
         };
+        /** False only during the boot application below: a registered panel absent
+         *  from its CSV is not a user removal (./panels.ts). */
+        let settingsEditsLive = true;
         // The /settings language field writes `lang` through the settings
         // service (user layer): apply it live and mirror it to lang.json so
         // the /lang command and next-boot resolution agree. DSH_TUI_LANG
@@ -1002,6 +1282,7 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
             channel.setPromptSessionLabel(value.promptSessionLabel ?? config.promptSessionLabel ?? false);
             channel.setExpandEditor(value.expandEditor ?? config.expandEditor ?? true);
             channel.setSmoothStreaming(value.smoothStreaming ?? config.smoothStreaming ?? true);
+            taskNotifier.configure(value.taskNotifications ?? config.taskNotifications, value.notificationMethod ?? config.notificationMethod);
             applyMermaidDiagrams(value.mermaidDiagrams ?? config.mermaidDiagrams);
             applyCodeFrameStyle(value.codeFrameStyle ?? config.codeFrameStyle);
             applyMathRendering(resolveMathRendering(value, config));
@@ -1016,7 +1297,12 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
             applySidePanelSplitEnabled(value.sidePanel?.splitEnabled ?? config.sidePanel?.splitEnabled);
             applySidePanelOpen(value.sidePanel?.open ?? config.sidePanel?.open);
             applySidePanelRatio(value.sidePanel?.ratio ?? config.sidePanel?.ratio);
-            applySidePanelPanels(value.sidePanel?.panels ?? config.sidePanel?.panels);
+            // A registered panel missing from a live edit was unticked in /settings.
+            const panelsCsv = value.sidePanel?.panels ?? config.sidePanel?.panels;
+            if (settingsEditsLive)
+                applySidePanelPanelsFromSettings(panelsCsv);
+            else
+                applyConfiguredSidePanelPanels(panelsCsv);
             applyCompanionSkin(value.companion?.skin ?? config.companion?.skin);
             applyBtwContextTurns(value.btw?.contextTurns ?? config.btw?.contextTurns);
             applyBtwContextBudget(value.btw?.contextBudget ?? config.btw?.contextBudget);
@@ -1090,8 +1376,11 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
             notifyChannel(t('settings-fullscreen-migrated'), { color: 'warning' });
         }
         const { fullscreen: staleFullscreen, ...migratedSettings } = bootSettings;
+        settingsEditsLive = false;
         apply(fullscreenMigration === 'unset' ? migratedSettings : bootSettings);
+        settingsEditsLive = true;
         let lastTerminalImages = bootSettings.terminalImages ?? config.terminalImages ?? true;
+        let lastLaunchpad = bootSettings.launchpad ?? config.launchpad ?? true;
         settingsCtx.effect(() => scope.watch(next => {
             apply(next);
             if (typeof next.fullscreen === 'boolean' && next.fullscreen !== bootedFullscreen) {
@@ -1102,9 +1391,14 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
                 channel.notify(t('settings-terminal-images-restart'), { color: 'warning' });
             }
             lastTerminalImages = terminalImages;
+            const launchpad = next.launchpad ?? config.launchpad ?? true;
+            if (launchpad !== lastLaunchpad && launchpad !== bootedLaunchpad) {
+                notifyChannel(t('settings-launchpad-restart'), { color: 'warning' });
+            }
+            lastLaunchpad = launchpad;
         }));
         resolveSettingsReady?.();
-    });
+    })({ settings: tuiSettings, effect: ctx.effect.bind(ctx) });
     // The /settings screen's own section: the dsh-tui namespace comes from
     // the settings registration above, and the declared selects write `lang`
     // and `diffLayout` back through the settings service's revision-fenced
@@ -1147,9 +1441,12 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // left this registration silently skipped and /settings read-only.
     // channel.ts reads through the same fallback, so both sides meet in the
     // same registry either way.
+    // The in-process DSH kernel registers into the local host first and moves
+    // the section to the composition's service once it exists.
+    let rehomeSettingsSection = () => undefined;
     {
-        const settingsSections = getHostSettingsSections(ctx.get('tuiSettingsSections')) ?? getLocalSettingsSectionsHost(ctx);
-        const unregister = settingsSections.register({
+        let settingsSections = getHostSettingsSections(ctx.get('tuiSettingsSections')) ?? getLocalSettingsSectionsHost(ctx);
+        const tuiSection = {
             ns: tuiSettingsNs,
             title: 'dsh-tui',
             groups: [...SETTING_GROUPS],
@@ -1258,6 +1555,14 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
                         return String(typeof value === 'boolean' ? value : config.mermaidDiagrams !== false);
                     },
                 },
+                {
+                    ...settingField('taskNotifications'),
+                    format: value => String(value ?? config.taskNotifications ?? 'unfocused'),
+                },
+                {
+                    ...settingField('notificationMethod'),
+                    format: value => String(value ?? config.notificationMethod ?? 'auto'),
+                },
                 {
                     ...settingField('codeFrameStyle'),
                 },
@@ -1284,10 +1589,10 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
                     ...settingField('effortDefault'),
                     format(value) {
                         // Unset in settings.yaml: show what a boot would actually start
-                        // on (the cordis effort pin → the persisted /effort choice)
+                        // on (the persisted /effort choice → the cordis effort default)
                         // instead of a misleading blank.
                         if (value === undefined || value === null || value === 'auto') {
-                            return config.effort ?? readEffortPref() ?? 'auto';
+                            return readEffortPref() ?? config.effort ?? 'auto';
                         }
                         return String(value);
                     },
@@ -1440,6 +1745,14 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
                         return { kind: 'set', value: budget };
                     },
                 },
+                {
+                    ...settingField('launchpad'),
+                    format(value) {
+                        // Unset in settings.yaml: the effective default is on — same
+                        // rule as expandEditor's field.
+                        return String(typeof value === 'boolean' ? value : config.launchpad !== false);
+                    },
+                },
                 {
                     ...settingField('companion.skin'),
                 },
@@ -1471,8 +1784,17 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
                     ...settingField('minimal'),
                 },
             ],
-        });
-        ctx.effect(() => unregister);
+        };
+        let unregister = settingsSections.register(tuiSection);
+        ctx.effect(() => () => { unregister(); });
+        rehomeSettingsSection = () => {
+            const service = getHostSettingsSections(ctx.get('tuiSettingsSections'));
+            if (service === undefined || service === settingsSections)
+                return;
+            unregister();
+            settingsSections = service;
+            unregister = service.register(tuiSection);
+        };
     }
     // DSH approval seam: the permission layer asks ApprovalService.request(),
     // which dispatches an `approval/request` waterfall. With no answerer the
@@ -1486,19 +1808,24 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     bindApprovalStore(ctx, approvalStore);
     // A non-DSH backend answers its own permission prompts: the DSH answerer
     // is not registered for it.
-    if (ctx.get('approval') !== undefined && backendStart === undefined) {
-        ctx.on('approval/request', (req, next) => approvalStore.park(req).catch(() => next()));
-        // Badge-flip push (P-4): React does not know the session log appended —
-        // a source-badge verdict that only flips inside getSnapshot() surfaces
-        // solely when something else re-renders. Feed the session firehose to
-        // the store: it reacts only to tool/result (the sole verdict-flipping
-        // event type), and its internal log-length memo skips appends from any
-        // session other than the active ask's, so no agent filtering is needed
-        // here. The firehose fires post-commit, after the event entered
-        // session.events, so the recheck sees the settled result.
-        ctx.on('session/event', (session, event) => approvalStore.noteSessionEvent(session.id, event));
-        ctx.effect(() => () => approvalStore.settleAll('cancelled'));
-    }
+    // The in-process DSH kernel installs it in `attachDsh`.
+    const mountDshApprovals = (dshCtx) => {
+        if (dshCtx.get('approval') !== undefined && backendStart === undefined) {
+            dshCtx.on('approval/request', (req, next) => approvalStore.park(req).catch(() => next()));
+            // Badge-flip push (P-4): React does not know the session log appended —
+            // a source-badge verdict that only flips inside getSnapshot() surfaces
+            // solely when something else re-renders. Feed the session firehose to
+            // the store: it reacts only to tool/result (the sole verdict-flipping
+            // event type), and its internal log-length memo skips appends from any
+            // session other than the active ask's, so no agent filtering is needed
+            // here. The firehose fires post-commit, after the event entered
+            // session.events, so the recheck sees the settled result.
+            dshCtx.on('session/event', (session, event) => approvalStore.noteSessionEvent(session.id, event));
+            dshCtx.effect(() => () => approvalStore.settleAll('cancelled'));
+        }
+    };
+    if (!dshInEntry)
+        mountDshApprovals(ctx);
     // The agent view reads parked ask ids for its "needs input" state.
     rawChannel.bindApprovalStore(approvalStore);
     // The panel source Chat renders: the backend's own prompts off DSH.
@@ -1518,9 +1845,25 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // Submit once the channel exists; delivery goes through the normal pending/inbox
     // chain, so no special timing is needed. The parser separates startup flags
     // from literal prompt text.
-    const initialPrompt = initialPromptFromCmdlineArgs(cmdlineArgs);
-    if (initialPrompt)
-        submitChannel(initialPrompt);
+    // The standalone entry has no `ctx.cmdlineArgs` (its argv is the app's); a
+    // replacement keeps the arguments but the first process sent their prompt.
+    const initialPrompt = launchPromptSent ? '' : initialPromptFromCmdlineArgs(cmdlineArgs ?? process.argv.slice(2));
+    if (initialPrompt) {
+        // A placeholder session refuses sends and nothing replays them after
+        // adoption: hold the prompt until the channel is ready.
+        if (channel.ready) {
+            submitChannel(initialPrompt);
+        }
+        else {
+            const unsubscribe = channel.subscribe(() => {
+                if (!channel.ready)
+                    return;
+                unsubscribe();
+                submitChannel(initialPrompt);
+            });
+            ctx.effect(() => unsubscribe, 'dsh-tui initial prompt after startup');
+        }
+    }
     // Attach the stderr reporter to the live channel and flush anything a
     // startup-spawned server produced while the channel didn't exist yet.
     notifyStderr = (text, options) => notifyChannel(text, options);
@@ -1554,10 +1897,13 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // accepted; the exit funnel then respawns onto that kernel (a NEW session —
     // no resume markers at all).
     let backendSwitchRequested;
+    // A signal or `ctx.appExit` via the entry's exit seam: the clean-exit branch
+    // runs as for `/quit`, then ends the process by the signal / with the code.
+    let processExitRequest;
     // The profile this process was booted with (`dsh --profile <name>`); dsh
     // exposes it nowhere else, and /update must update the installation the
     // user is actually running, not a hard-coded one.
-    const profile = resolveDshProfileName();
+    const profile = resolveDshProfileName() ?? runtimeOptions.profile;
     // Single exit funnel: `/exit` and double Ctrl+C land here, and so does
     // the unmount triggered by a cordis context teardown — but the two must
     // not share a fate (issue #12). Teardown only unmounts the UI; user exit
@@ -1565,7 +1911,11 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // update handoff or resume hint).
     /** The session id for a restart or update handoff, or empty when the backend
      * has not persisted it and the replacement must start fresh. */
-    const handoffSessionId = () => backendStart === undefined || backendStart.persisted(channel.agentId, channel.rows) ? channel.agentId : '';
+    const handoffSessionId = () => {
+        if (backendStart !== undefined)
+            return backendStart.persisted(channel.agentId, channel.rows) ? channel.agentId : '';
+        return isUnstoredFreshSession(liveDshAgent()?.session) ? '' : channel.agentId;
+    };
     const handoffHint = backendStart === undefined ? undefined : (sessionId) => backendStart.resumeCommand(sessionId);
     const funnel = createExitFunnel({
         onUserExit: error => {
@@ -1589,18 +1939,14 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
                     // never CLEARS a marker, so a session the user still has cannot be
                     // dropped by a failure that happened before the first message landed.
                     writeResumeMarkers: () => {
-                        if (isExitResumable({
-                            pendingCount: channel.pending.length,
-                            liveAgent: ctx.agents.get(SessionId(channel.agentId)),
+                        writeCrashResumeMarkers({
+                            ctx,
+                            backendStart,
+                            channel,
                             startupAgent: agent,
-                        })) {
-                            writeResumeTarget(channel.agentId);
-                        }
-                        // Non-DSH sessions use their backend preference as the launcher marker.
-                        if (backendStart !== undefined && backendStart.persisted(channel.agentId, channel.rows))
-                            backendStart.sessionPrefs.setLastSession(channel.agentId);
-                        // So the launcher's retry reopens this session, not the boot-time one.
-                        refreshLastRunRecord();
+                            writeResumeTarget,
+                            refreshLastRunRecord,
+                        });
                     },
                     finish: crashLine => {
                         void finishExit(ctx, instance, bootedFullscreen, undefined, crashLine, () => disposeRootAndExit(ctx, 1));
@@ -1611,8 +1957,13 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
             if (updateRequested) {
                 try {
                     // Non-DSH sessions keep their marker in backend prefs, not DSH's `resume.txt`.
-                    if (backendStart === undefined)
-                        writeResumeTarget(channel.agentId);
+                    if (backendStart === undefined) {
+                        const sessionId = handoffSessionId();
+                        if (sessionId === '')
+                            clearResumeTarget();
+                        else
+                            writeResumeTarget(sessionId);
+                    }
                     else if (backendStart.persisted(channel.agentId, channel.rows))
                         backendStart.sessionPrefs.setLastSession(channel.agentId);
                 }
@@ -1623,7 +1974,7 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
                 const hintText = isStandaloneRuntime()
                     ? t('update-standalone-starting')
                     : t('update-starting');
-                void finishExit(ctx, instance, bootedFullscreen, hintText, undefined, () => runUpdate(ctx, profile, handoffSessionId(), updateTargetVersion, backendChoice, handoffHint));
+                void finishExit(ctx, instance, bootedFullscreen, hintText, undefined, () => runUpdate(ctx, profile, handoffSessionId(), updateTargetVersion, backendChoice, handoffHint, exitSeam));
                 return;
             }
             // The kernel selector's switch: the same respawn machinery, no resume.
@@ -1633,30 +1984,41 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
             // inherited DSH_TUI_RESUME_SESSION marker from the replacement env.
             // kernel.json was already written when the choice was accepted.
             if (backendSwitchRequested !== undefined) {
-                logRestartEvent('funnel: backend-switch branch entered', { backend: backendSwitchRequested });
+                // Captured: the closure below runs after this block, where the outer
+                // `let` is no longer narrowed.
+                const switchingTo = backendSwitchRequested;
+                logRestartEvent('funnel: backend-switch branch entered', { backend: switchingTo });
                 // Fullscreen keeps the alternate screen and writes the "switching"
                 // notice into it until the replacement takes over (see handoffAck.ts);
                 // inline restores the main screen and writes the notice there.
-                logRestartEvent(handoffEventTag('starting'), { backend: backendSwitchRequested });
+                logRestartEvent(handoffEventTag('starting'), { backend: switchingTo });
                 const keepAlt = bootedFullscreen;
-                void finishExit(ctx, instance, bootedFullscreen, formatHandoffNotice('starting', { name: kernelDisplayName(backendSwitchRequested), color: process.stdout.isTTY === true }), undefined, () => runRestart(ctx, profile, '', undefined, {
-                    backend: backendSwitchRequested,
+                void finishExit(ctx, instance, bootedFullscreen, formatHandoffNotice('starting', { name: backendLabel(switchingTo), color: process.stdout.isTTY === true }), undefined, () => runRestart(ctx, profile, '', undefined, {
+                    backend: switchingTo,
+                    // The replacement's parent prints the same name this process just
+                    // put on screen (update.ts has no registry to look it up in).
+                    backendName: backendLabel(switchingTo),
                     ...(keepAlt ? { handoffScreen: 'alt' } : {}),
-                }), { keepAltScreen: keepAlt });
+                }, exitSeam), { keepAltScreen: keepAlt });
                 return;
             }
             // `/restart`: same handoff as the update path, no installation step.
-            // The resume target is written unconditionally — the user asked to
-            // restart THIS session, blank or not (mirrors the update contract).
+            // A fresh initialization-only session has no log to reopen. Restart
+            // it fresh; saved sessions keep their identity across the handoff.
             if (restartRequested) {
                 beginRestartAttempt(channel.agentId);
                 logRestartEvent('funnel: /restart branch entered');
                 try {
-                    if (backendStart === undefined)
-                        writeResumeTarget(channel.agentId);
+                    if (backendStart === undefined) {
+                        const sessionId = handoffSessionId();
+                        if (sessionId === '')
+                            clearResumeTarget();
+                        else
+                            writeResumeTarget(sessionId);
+                    }
                     else if (backendStart.persisted(channel.agentId, channel.rows))
                         backendStart.sessionPrefs.setLastSession(channel.agentId);
-                    logRestartEvent('funnel: resume target written');
+                    logRestartEvent('funnel: resume target updated');
                 }
                 catch (error) {
                     // Resume persistence is best effort and must never block a restart.
@@ -1665,7 +2027,7 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
                     });
                 }
                 refreshLastRunRecord();
-                void finishExit(ctx, instance, bootedFullscreen, t('restart-starting'), undefined, () => runRestart(ctx, profile, handoffSessionId(), handoffHint, { kernel: backendChoice }));
+                void finishExit(ctx, instance, bootedFullscreen, t('restart-starting'), undefined, () => runRestart(ctx, profile, handoffSessionId(), handoffHint, { kernel: backendChoice }, exitSeam));
                 return;
             }
             // Judge against the live session behind the channel (channel.agentId),
@@ -1689,7 +2051,7 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
             else {
                 const resumable = isExitResumable({
                     pendingCount: channel.pending.length,
-                    liveAgent: ctx.agents.get(SessionId(channel.agentId)),
+                    liveAgent: liveDshAgent(),
                     startupAgent: agent,
                 });
                 try {
@@ -1707,10 +2069,39 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
             }
             // Same resumability as the markers above.
             refreshLastRunRecord();
-            void finishExit(ctx, instance, bootedFullscreen, hint, undefined, () => disposeRootAndExit(ctx, 0));
+            const request = processExitRequest;
+            void finishExit(ctx, instance, bootedFullscreen, hint, undefined, () => {
+                if (request === undefined)
+                    disposeRootAndExit(ctx, 0);
+                else if (request.kind === 'code')
+                    disposeRootAndExit(ctx, request.code);
+                // A signal: the process dies by it once the root is down (bounded
+                // as any dispose; the stalled case dies by it too).
+                else
+                    disposeRootAndThen(ctx, () => { dieBySignal(request.signal); }, () => { dieBySignal(request.signal); });
+            });
         },
     });
     const handleExit = funnel.handleExit;
+    const exitSeam = runtimeOptions.exitSeam;
+    const requestProcessExit = (request) => {
+        // A handoff is under way: no backstop, which could kill the supervisor of
+        // a replacement already up; superviseReplacement takes the seam over.
+        if (updateRequested || restartRequested || backendSwitchRequested !== undefined)
+            return 'supervising';
+        // A `/quit` or a crash is already ending this process.
+        if (exited)
+            return 'pending';
+        processExitRequest = request;
+        logRestartEvent('funnel: process exit requested', request.kind === 'signal' ? { signal: request.signal } : { code: request.code });
+        if (handleExit())
+            return 'exiting';
+        // The tree is being torn down: the funnel cannot own the process.
+        processExitRequest = undefined;
+        return 'refused';
+    };
+    if (exitSeam !== undefined)
+        exitSeam.request = requestProcessExit;
     /** The launchpad kernel selector's accept path (the Chat side passes the
      *  chosen kernel through onSwitchBackend — the prop wiring lands together
      *  with the selector's Chat rendering). Persists the choice BEFORE the
@@ -1724,7 +2115,7 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
         backendSwitchRequested = backend;
         writeKernelPrefs({ backend });
         logRestartEvent('command: backend switch accepted', { backend });
-        notifyChannel(t('kernel-switch-restarting', { name: kernelDisplayName(backend) }));
+        notifyChannel(t('kernel-switch-restarting', { name: backendLabel(backend) }));
         handleExit();
     };
     /** /channel changed the active channel's connection. The running CLI child
@@ -1818,18 +2209,21 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
      * and opens straight into its conversation.
      */
     const dshBoot = backendStart === undefined;
-    const noResume = isLandingLaunch({ launchSessionId, initialPrompt });
+    const noResume = isLandingLaunch({ launchSessionId: bootSessionId, initialPrompt });
     const openHomeOnBoot = dshBoot && !homeSeen && noResume && requestedWorkspace === undefined;
     /**
      * The launchpad is NOT one-shot the way the workspace home is: every
      * ordinary launch starts on it, because it is where the first sentence gets
      * typed rather than a tutorial that retires itself — on every backend: a
      * remembered claude kernel lands here exactly like a dsh one (the `dshBoot`
-     * gate below is deliberately absent). `DSH_TUI_NO_LAUNCHPAD=1` is the
-     * escape hatch (an automation that wants the old blank conversation and no
-     * dialog in front of it).
+     * gate below is deliberately absent). The /settings `launchpad` toggle
+     * (settings user layer over cordis.yml, resolved into `bootedLaunchpad`
+     * above) is the persistent off switch — off boots straight into the chat
+     * page. `DSH_TUI_NO_LAUNCHPAD=1` remains the env escape hatch (an
+     * automation that wants the old blank conversation and no dialog in front
+     * of it).
      */
-    const launchpadOnBoot = noResume && process.env.DSH_TUI_NO_LAUNCHPAD !== '1';
+    const launchpadOnBoot = noResume && bootedLaunchpad && process.env.DSH_TUI_NO_LAUNCHPAD !== '1';
     /**
      * The first-run guide. Gated on its own preference (not on `homeSeen`): the
      * two answer different questions, and an install that already knows its
@@ -1839,7 +2233,8 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // 品牌镜像初值（branding.ts）：首帧渲染前铺好，避免 Claude 后端先画一屏
     // 蓝再变橙。Chat 里的 effect 会在品牌解析变化时跟进更新这个镜像。
     setActiveBrand(resolveBrand(config.brand, backendChoice));
-    const chat = React.createElement(Chat, {
+    const liveThemeHost = () => getHostThemes(ctx.get('tuiThemes'));
+    const buildChat = () => React.createElement(Chat, {
         channel,
         renderScene: createChannelSceneOutlet(() => rawChannel.pluginScene),
         questionStore,
@@ -1859,7 +2254,7 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
         // no longer runs a second activity tracker of its own.
         activityStore,
         extensionShortcuts: getHostShortcuts(ctx.get('tuiShortcuts')),
-        themeHost,
+        themeHost: liveThemeHost(),
         // Full-screen surfaces inside Chat — the trajectory scene and the session
         // browser — enter the alt screen themselves in inline mode; in fullscreen
         // the tree is already wrapped below, so they must not nest.
@@ -1880,12 +2275,39 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
         onSwitchBackend: switchBackend,
         // /channel: restart with a new session after the connection changed.
         onRestartFreshSession: restartFreshSession,
+        // The backend registry as the picker sees it: the UI takes data, not the
+        // registry (P0). dsh first, then the manifest order — picker order. Entries
+        // that registered without an admission are not offered (B-2).
+        kernelEntries: kernelEntriesOf(listOfferedBackends()),
         onProbeKernels: () => probeKernels(ctx, sessionCwd),
-        // The kernel picker's SDK install wizard (the dim Claude row, Enter).
-        onResolveSdkInstallTarget: sdkInstall.resolveTarget,
-        onStartSdkInstall: sdkInstall.start,
-        onCheckPnpm: sdkInstall.checkPnpm,
-        sdkInstallPinned: sdkInstall.pinned,
+        // The kernel picker's SDK install wizard (a dim row's Enter): the surface of
+        // whichever row the user picked, looked up by id — the manifest says what to
+        // install and with which executor, this host holds the actions.
+        onResolveSdkInstall: installSurfaceFor,
+        // `/plugin install <spec>` (C-4): the write path. The wiring lives beside
+        // the flow (`createPluginInstallEntry`) so a regression can drive the real
+        // feed load, declaration read and profile-relative path resolution with a
+        // fixture context. `undefined` ⇒ not an install form, or no service to
+        // install through; the screen then runs the read-only report instead.
+        onPluginInstall: createPluginInstallEntry(ctx, {
+            ownVersion: installedTuiVersion(),
+            profileName: profile ?? resolveDshProfileName(),
+        }),
+        // `/plugin remove|enable|disable` (C-5): the lifecycle write path. Wired the
+        // same way and for the same reason — the entry is where the real profile, the
+        // declaration read and the data directory meet, so a regression can drive
+        // them with a fixture context. `undefined` ⇒ not one of those forms, or no
+        // service to act through; the screen then runs the read-only report.
+        onPluginManage: createPluginManageEntry(ctx, {
+            profileName: profile ?? resolveDshProfileName(),
+        }),
+        // `/team [status] | on | off`: the Agent Teams bundle through the same
+        // lifecycle flow (team-mode.ts).
+        onTeamCommand: createTeamCommandEntry(ctx, {
+            profileName: profile ?? resolveDshProfileName(),
+            // The host reports `unknown` when it has no version: read the installed one.
+            kernelVersion: entrySlot?.kernelVersion === 'unknown' ? undefined : entrySlot?.kernelVersion,
+        }),
         kernelPinned: backendPinned,
         // Only a `dsh --profile <name>` launch has a profile installation for
         // `/update` to act on; source checkouts and `--config` overlays get the
@@ -1957,17 +2379,32 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // the screen border). It must sit INSIDE AlternateScreen: the alt-screen
     // box sizes itself to the real terminal rows, while PageMargin reports
     // content-box dimensions to everything below it.
-    const marginChildren = bootedFullscreen
-        ? React.createElement(AlternateScreen, null, React.createElement(PageMargin, null, chat))
-        : React.createElement(PageMargin, null, chat);
-    const tree = React.createElement(ThemeProvider, {
-        themeHost,
-        children: marginChildren,
-    });
+    const buildTree = () => {
+        const chat = buildChat();
+        const marginChildren = bootedFullscreen
+            ? React.createElement(AlternateScreen, null, React.createElement(PageMargin, null, chat))
+            : React.createElement(PageMargin, null, chat);
+        return React.createElement(ThemeProvider, {
+            themeHost: liveThemeHost(),
+            children: marginChildren,
+        });
+    };
+    const tree = buildTree();
     // Kernel-switch replacement: send the ready ACK once the first frame after
     // adoption is flushed. Does nothing on an ordinary boot.
     armFirstFrameAck(process.stdout);
-    instance = await render(tree, { exitOnCtrlC: false, terminalImages: bootedTerminalImages });
+    markBoot('render-start');
+    // The entry's composition right after the mount freezes the event loop for
+    // a while: it waits for the first frame to reach the terminal.
+    const awaitsFirstFrame = entrySlot !== undefined;
+    let frameFlushed = () => undefined;
+    const firstFrame = awaitsFirstFrame ? new Promise(resolve => { frameFlushed = resolve; }) : undefined;
+    instance = await render(tree, {
+        exitOnCtrlC: false,
+        terminalImages: bootedTerminalImages,
+        ...(awaitsFirstFrame ? { onFrame: () => { frameFlushed(); } } : {}),
+    });
+    markBoot('render-done');
     const isRecompose = lastBootedFullscreen !== undefined;
     lastBootedFullscreen = bootedFullscreen;
     lastBootedTerminalImages = bootedTerminalImages;
@@ -1981,14 +2418,32 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // External injection channel (dsh.nvim etc.): expose a per-session local
     // socket that appends text into the prompt input and submits it. Optional
     // integration — a bind failure degrades to "no channel" and never fails the
-    // session. Closed on teardown so the socket and discovery record do not leak.
-    const injectChannel = openInjectChannel(agent?.session.id ?? channel.agentId, channel.cwd, {
-        append: (text) => injectControllerRef.current?.append(text),
-        submit: () => injectControllerRef.current?.submit(),
-    }, (message) => ctx.logger.warn(`dsh-tui: ${message}`));
-    if (injectChannel) {
-        ctx.effect(() => () => injectChannel.close());
-    }
+    // session. It follows the bound session: a placeholder still opening (empty
+    // id) binds nothing, and adoption or a session switch rebinds under the new
+    // id and cwd, closing the previous socket and discovery record (a connected
+    // client reconnects through servers.json). Closed on teardown so neither leaks.
+    let injectChannel = null;
+    let injectSessionId = '';
+    const bindInjectChannel = () => {
+        if (channel.agentId === injectSessionId)
+            return;
+        injectChannel?.close();
+        injectChannel = null;
+        injectSessionId = channel.agentId;
+        if (injectSessionId === '')
+            return;
+        injectChannel = openInjectChannel(injectSessionId, channel.cwd, {
+            append: (text) => injectControllerRef.current?.append(text),
+            submit: () => injectControllerRef.current?.submit(),
+        }, (message) => ctx.logger.warn(`dsh-tui: ${message}`));
+    };
+    bindInjectChannel();
+    const unsubscribeInject = channel.subscribe(bindInjectChannel);
+    ctx.effect(() => () => {
+        unsubscribeInject();
+        injectChannel?.close();
+        injectChannel = null;
+    }, 'dsh-tui inject channel');
     // Cross-process session mounting: publish the sessions this process has
     // mounted so another TUI (a different terminal process on the same machine)
     // can see them as occupied and refuse to mount the same log. Two processes
@@ -2034,9 +2489,138 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
         // the process, so a later fatal error falls back to Node's default crash
         // instead of reaching a disposed ctx.
         registerProcessGuardFatalSink(undefined);
+        if (exitSeam?.request === requestProcessExit)
+            exitSeam.request = undefined;
         rawChannel.releaseContributions();
         instance?.unmount();
     });
+    /** The first frame's write, then stdout drained (bounded: a renderer that
+     *  never draws must not hold the composition back). */
+    const flushFirstFrame = async () => {
+        await Promise.race([firstFrame ?? Promise.resolve(), new Promise(resolve => { setTimeout(resolve, 1000).unref(); })]);
+        await new Promise(resolve => { process.stdout.write('', () => { resolve(); }); });
+    };
+    /**
+     * Services composed after the mount: re-read what the screen took as values
+     * at mount (Chat's stores, theme host, toast sink, /settings section).
+     */
+    const refreshHostServices = () => {
+        rehomeSettingsSection();
+        bindToastSink();
+        if (!exited)
+            instance?.rerender(buildTree());
+    };
+    if (entrySlot !== undefined)
+        entrySlot.firstFrameFlushed = flushFirstFrame;
+    // The kernels without a dsh-tui row: no row to refresh the mounted screen,
+    // so the slot does it.
+    if (entrySlot !== undefined && !entrySlot.dsh)
+        entrySlot.composeSucceeded = () => { refreshHostServices(); };
+    if (entrySlot?.dsh === true) {
+        entrySlot.composeSucceeded = () => { settleComposition(true); };
+        entrySlot.composeFailed = (error, logPath) => {
+            settleComposition(false);
+            const reason = error instanceof Error ? error.message : String(error);
+            logForDebugging(`dsh-tui: host composition failed (${reason})${logPath === undefined ? '' : ` — startup report: ${logPath}`}`);
+            compositionFailed = true;
+            openDshSession = undefined;
+            // No DSH to open on: the failure row names the report and the ways out.
+            const hint = logPath === undefined ? t('startup-compose-failed-hint') : t('startup-compose-failed-hint-log', { path: logPath });
+            if (!dshStartupSettled) {
+                settleDshStartup?.reject(new StartupOpenError(reason.split('\n')[0] ?? reason, hint, { cause: error }));
+                return;
+            }
+            if (exited)
+                return;
+            // The session may already be adopted (the audit runs after the tree
+            // settled): a row that stays, not a toast.
+            try {
+                channel.pushLocal(t('startup-open-failed', { backend: backendLabel('dsh'), err: reason.split('\n')[0] ?? reason }), [hint]);
+            }
+            catch {
+            }
+        };
+        entrySlot.attachDsh = async (rowCtx, rowRuntimeConfig) => {
+            const dshCtx = rowCtx;
+            // The composition failed (its row is on screen), or the process is
+            // leaving (the root dispose waited for the Loader, which started this row).
+            if (compositionFailed || exited)
+                return;
+            try {
+                const rowConfig = configValues(rowRuntimeConfig);
+                rowFacts.config = rowConfig;
+                await installPresets(dshCtx);
+                const seams = mountDshQuestionSeams(dshCtx);
+                if (seams.notice !== undefined)
+                    notifyChannel(seams.notice, { color: 'error' });
+                if (seams.registration.kind === 'waterfall')
+                    seams.registration.register(channel);
+                mountDshApprovals(dshCtx);
+                refreshHostServices();
+                const rowRoute = { provider: rowConfig.provider, model: rowConfig.model };
+                // The same startup/deployment split the plugin's own boot makes (issue #67).
+                const { startupRoute: rowStartupRoute, deploymentRoute: rowDeploymentRoute } = startupRoutes(dshCtx, rowRoute);
+                const openOnRow = (sessionId, openMeta) => resolveAgent(dshCtx, sessionId, rowRoute, rowStartupRoute, rowDeploymentRoute, openMeta, rowConfig.preset);
+                /** The opened agent is this screen's from now on; returns its route. */
+                const takeOpened = async (opened) => {
+                    agent = opened.agent;
+                    await attachWorkspaceOwnership(dshCtx, opened.agent);
+                    rowFacts.route = opened.route ?? rowStartupRoute;
+                    return rowFacts.route;
+                };
+                // `/new` after a failed startup open: DSH's create path on this row.
+                openDshSession = async (cwd) => {
+                    const created = await openOnRow(undefined, { cwd });
+                    await takeOpened(created);
+                    refreshLastRunRecord();
+                    return createDshSession(dshCtx, { agent: created.agent, handle: created.handle });
+                };
+                // The entry mounted on rebuilt defaults: the row's own `workspace` /
+                // `cwd` decide the session directory, with `apply`'s precedence. A
+                // provider-URI target resolves now that the providers exist.
+                const rowWorkspace = rowConfig.workspace ?? requestedWorkspace;
+                let startupMeta = { cwd: resolveSessionCwd(rowConfig.cwd) };
+                if (rowWorkspace !== undefined) {
+                    if (initialWorkspace !== undefined && rowWorkspace === requestedWorkspace) {
+                        startupMeta = meta;
+                    }
+                    else {
+                        const workspaces = getHostWorkspaceRuntime(dshCtx.get('tuiWorkspaces'));
+                        const target = workspaces === undefined ? undefined : await workspaces.resolve(rowWorkspace);
+                        if (target === undefined)
+                            throw new Error(unsupportedWorkspaceTarget(rowWorkspace));
+                        startupMeta = { cwd: target.cwd };
+                    }
+                }
+                // A revoked target (the safe-mode retry's warning path) cold-starts here too.
+                const rowSessionId = resumeTarget.kind === 'revoked'
+                    ? undefined
+                    : rowConfig.sessionId ?? resumeTargetFromArgv(cmdlineArgsOf(dshCtx) ?? process.argv.slice(2));
+                const opened = await openOnRow(rowSessionId, startupMeta);
+                const session = createDshSession(dshCtx, { agent: opened.agent, handle: opened.handle });
+                // The composition failed while this opened: close the unadoptable session.
+                if (compositionFailed) {
+                    await session.dispose().catch(() => undefined);
+                    return;
+                }
+                const route = await takeOpened(opened);
+                settleDshStartup?.resolve({
+                    session,
+                    history: [],
+                    route,
+                    ...(opened.agentPreset === undefined ? {} : { agentPreset: opened.agentPreset }),
+                });
+                refreshLastRunRecord();
+            }
+            catch (error) {
+                logForDebugging(`dsh-tui: DSH session failed to open (${error instanceof Error ? error.message : String(error)})`);
+                // A composition that fails reports itself (its row names the report).
+                if (!await compositionSettled)
+                    return;
+                settleDshStartup?.reject(error);
+            }
+        };
+    }
     // The TUI is the front door: when the user unmounts it (Ctrl+C), dispose
     // the app tree and exit the process. The rejection handler covers
     // error-driven unmounts — without it a rejected exitPromise became an
@@ -2044,6 +2628,9 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
     // is swallowed by the funnel (issue #12).
     void instance.waitUntilExit().then(handleExit, handleExit);
 }
+function unsupportedWorkspaceTarget(target) {
+    return `dsh-tui: unsupported or unavailable workspace target: ${target}`;
+}
 /**
  * Attach to an existing agent, resume a persisted session (`dsh-tui --resume`
  * feeds the id through `config.sessionId`), or create a fresh one. Resume
@@ -2053,26 +2640,45 @@ export async function apply(ctx, runtimeConfig, configOwner = ctx) {
  * without a session id.
  *
  * Preset composition (issue #8): a create resolves the requested preset
- * (cordis.yml `preset` over the persisted `/preset` choice over the roster
- * default) and mounts it in the factory's setup hook; a resume re-mounts the
- * preset the session's own log records. Without the roster both paths behave
- * as before presets existed.
+ * (`DSH_TUI_PRESET` over the persisted `/preset` choice over the cordis.yml
+ * default over the roster default) and mounts it in the factory's setup hook;
+ * a resume re-mounts the preset the session's own log records. Without the
+ * roster both paths behave as before presets existed.
  *
  * Model route (issues #14/#30/#67): a create adopts the caller's atomically
  * resolved route (validated against the adapter catalog below); a resume
- * passes only a COMPLETE cordis.yml route through — a provider-only pin must
- * not half-override the route the target session's own records carry.
+ * prefers the route the target session's own records carry and falls back to
+ * a COMPLETE cordis.yml route — a provider-only pin must not half-override
+ * the session's route, and the static route is only the deployment default.
+ */
+/**
+ * The startup route and the deployment route a rejected preference falls back
+ * to (issue #67): the persisted `/model` pick wins whole, else a complete
+ * cordis.yml route, else Harness's agent-default-model selection — never the
+ * lock the user's own pick replaced, never a half-pinned config.
  */
-async function resolveAgent(ctx, requestedSessionId, configuredRoute, startupRoute, meta, configuredPreset) {
-    // Resume override (issue #67): cordis.yml overrides the target session's
-    // recorded route only when it pins BOTH halves; undefined halves let the
-    // session's own request/header records win (issue #30). The recorded route
-    // is ALSO fed back into agentOptions (not just the status line): a resume
+function startupRoutes(ctx, configuredRoute) {
+    const selected = ctx.get('agentDefaultModel')?.currentSelection?.();
+    const harnessDefault = typeof selected?.provider === 'string' && selected.provider.length > 0
+        && typeof selected.model === 'string' && selected.model.length > 0
+        ? { provider: selected.provider, model: selected.model }
+        : undefined;
+    return {
+        startupRoute: resolveModelRoute(configuredRoute, readModelPref(), harnessDefault),
+        deploymentRoute: resolveModelRoute(configuredRoute, undefined, harnessDefault),
+    };
+}
+async function resolveAgent(ctx, requestedSessionId, configuredRoute, startupRoute, deploymentRoute, meta, configuredPreset) {
+    // Deployment fallback (issue #67): a resumed session continues on the route
+    // its own request/header records carry (issue #30) — the route it actually
+    // ran is more specific than any static config — and only a session that
+    // records none adopts the complete cordis.yml route. The recorded route is
+    // ALSO fed back into agentOptions (not just the status line): a resume
     // whose cordis.yml pins only `provider` would otherwise leave
     // agentOptions.model undefined, which breaks the `{{model}}` persona
     // variable for the resumed agent's own assembly and for every subagent it
     // spawns (dsh-subagent inherits `parent.options.model`).
-    const resumeRoute = explicitModelRoute(configuredRoute);
+    const resumeRoute = explicitModelRoute(configuredRoute) ?? deploymentRoute;
     if (requestedSessionId !== undefined) {
         const resumeId = SessionId(requestedSessionId);
         const existing = ctx.agents.get(resumeId);
@@ -2125,8 +2731,8 @@ async function resolveAgent(ctx, requestedSessionId, configuredRoute, startupRou
             const composed = await composePreset(ctx, persisted);
             const recorded = await resolvePersistedRoute(ctx, resumeId);
             const resumeOptions = {
-                provider: resumeRoute?.provider ?? recorded?.provider,
-                model: resumeRoute?.model ?? recorded?.model,
+                provider: recorded?.provider ?? resumeRoute?.provider,
+                model: recorded?.model ?? resumeRoute?.model,
             };
             const resumed = await ctx.agents.resume({
                 resumeSessionId: resumeId,
@@ -2134,14 +2740,14 @@ async function resolveAgent(ctx, requestedSessionId, configuredRoute, startupRou
                 ...(composed.setup === undefined ? {} : { setup: composed.setup }),
             });
             // Status-line route on resume: the route the session actually
-            // continues on — a complete cordis.yml pin, else the route its own
-            // request/header records carry (a bare log yields undefined and the
-            // caller falls back to the startup resolution, best effort).
+            // continues on — its own request/header record, else the complete
+            // cordis.yml deployment route (a bare log that pins none falls back to
+            // the startup resolution, best effort).
             return {
                 agent: resumed.agent,
                 handle: resumed,
                 agentPreset: composed.agentPreset,
-                route: resumeRoute ?? recordedModelRoute(snapshotLiveSessionEvents(resumed.agent.session)),
+                route: recordedModelRoute(snapshotLiveSessionEvents(resumed.agent.session)) ?? resumeRoute,
             };
         }
         catch (error) {
@@ -2165,18 +2771,24 @@ async function resolveAgent(ctx, requestedSessionId, configuredRoute, startupRou
         }
     }
     const sessionId = SessionId(randomUUID());
-    const presetPref = configuredPreset === undefined ? readPresetPref() : undefined;
-    const composed = await composePreset(ctx, configuredPreset ?? presetPref);
-    if (!migratePresetPref(presetPref, composed.agentPreset)) {
+    // Fresh-session preset precedence (issue #8): the DSH_TUI_PRESET launch
+    // instruction, then the persisted `/preset` choice (the standing user
+    // default), then the cordis.yml value as the deployment default, then the
+    // roster default. The pref is migrated only when it was the effective
+    // source — an override must not rewrite the remembered id.
+    const presetOverride = presetOverrideFromEnv();
+    const presetPref = readPresetPref();
+    const composed = await composePreset(ctx, presetOverride ?? presetPref ?? configuredPreset);
+    if (presetOverride === undefined && !migratePresetPref(presetPref, composed.agentPreset)) {
         ctx.logger.warn(`dsh-tui: resolved preset preference "${presetPref}" as "${composed.agentPreset}" but could not persist the migrated id`);
     }
     // Fresh-session route precedence (issues #14/#30/#67): resolved atomically
-    // by the caller (complete cordis.yml route > the persisted `/model` choice
+    // by the caller (the persisted `/model` choice > a complete cordis.yml route
     // > the harness default), then validated against the adapter catalog — a
-    // stale persisted choice falls back to the default route wholesale instead
-    // of reaching the server as an unknown model name.
+    // stale persisted choice falls back to the deployment route wholesale
+    // instead of reaching the server as an unknown model name.
     const llm = ctx.get('llm');
-    const { route, rejected } = await validateModelRoute(llm, startupRoute);
+    const { route, rejected } = await validateModelRoute(llm, startupRoute, deploymentRoute);
     if (rejected !== undefined) {
         ctx.logger.warn(`dsh-tui: model route ${rejected.provider}/${rejected.model} is not advertised by provider "${rejected.provider}"; falling back to ${route.provider}/${route.model}`);
     }
@@ -2193,7 +2805,7 @@ async function resolveAgent(ctx, requestedSessionId, configuredRoute, startupRou
     const bootReservation = bootReserved.ok ? bootReserved.reservation : undefined;
     let created;
     try {
-        created = await ctx.agents.create({
+        created = await createFreshAgent(ctx, ctx.agents, {
             sessionId,
             meta: {
                 ...meta,
@@ -2276,6 +2888,31 @@ export function runCrashExit(deps) {
     }
     deps.finish(`dsh-tui crashed: ${detail.message}`);
 }
+/** None where the root has no `ctx.agents` (before DSH composes, or a non-DSH kernel). */
+function dshAgentOn(ctx, agentId) {
+    return ctx.get('agents')?.get(SessionId(agentId));
+}
+/**
+ * The crash tail's resume markers (exported for scripts/verify-shutdown-fallback).
+ * Leaves the marker a clean exit would, never CLEARS one.
+ */
+export function writeCrashResumeMarkers(deps) {
+    const { ctx, backendStart, channel } = deps;
+    if (backendStart === undefined) {
+        if (isExitResumable({
+            pendingCount: channel.pending.length,
+            liveAgent: dshAgentOn(ctx, channel.agentId),
+            startupAgent: deps.startupAgent,
+        })) {
+            deps.writeResumeTarget(channel.agentId);
+        }
+    }
+    else if (backendStart.persisted(channel.agentId, channel.rows)) {
+        // Non-DSH sessions use their backend preference as the launcher marker.
+        backendStart.sessionPrefs.setLastSession(channel.agentId);
+    }
+    deps.refreshLastRunRecord();
+}
 /**
  * Whether a user exit should leave the resume marker (and print the resume
  * hint). Must be judged against the LIVE session behind the channel, not the
@@ -2291,6 +2928,8 @@ export function isExitResumable(deps) {
     const agent = deps.liveAgent ?? deps.startupAgent;
     if (agent === undefined)
         return false;
+    if (isUnstoredFreshSession(agent.session))
+        return false;
     return (deps.pendingCount > 0 ||
         snapshotLiveSessionEvents(agent.session).some(event => event.type === 'user/message' && event.data.source.kind === 'user'));
 }
@@ -2336,7 +2975,7 @@ export async function finishExit(ctx, instance, fullscreen, notice, stderrNotice
         }
         const cursor = fullscreen ? '' : cursorMoveToFrameEnd(runtime);
         try {
-            runtime?.detachForShutdown?.();
+            await runtime?.detachForShutdown?.();
             // The /update continuation spawns children that inherit this stdin;
             // strip the readable pump so the parent cannot swallow their input
             // (issues #284/#307). Harmless on plain exits — the process exits
@@ -2466,11 +3105,47 @@ function writeStream(stream, data) {
 function preservedSessionTail(sessionId, hint) {
     return sessionId === '' ? '\n\n' : ` Your session is preserved — resume with:\n${hint(sessionId)}\n\n`;
 }
-function runRestart(ctx, profile, sessionId, hint = id => resumeCommand(profile, id), options = {}) {
+/**
+ * The entry's signals while following a replacement: SIGTERM is forwarded;
+ * SIGINT/SIGHUP already reach it through the process group. A replacement
+ * that dies by a termination signal ends this process the same way.
+ */
+function superviseReplacement(exitSeam, options) {
+    if (exitSeam === undefined)
+        return options;
+    let replacement;
+    exitSeam.request = request => {
+        if (replacement === undefined)
+            return 'refused';
+        const forwarded = request.kind === 'signal' && request.signal === 'SIGTERM';
+        if (forwarded)
+            replacement.kill('SIGTERM');
+        logRestartEvent('supervisor: exit request while following the replacement', request.kind === 'signal' ? { signal: request.signal, forwarded } : { code: request.code });
+        return 'supervising';
+    };
+    return {
+        ...options,
+        onSpawn: child => { replacement = child; },
+        onTerminationSignal: signal => {
+            if (TERMINATION_SIGNALS.includes(signal))
+                dieBySignal(signal);
+        },
+    };
+}
+function runRestart(ctx, profile, sessionId, hint = id => resumeCommand(profile, id), options = {}, exitSeam) {
     logRestartEvent('runRestart: entered, disposing cordis root');
     disposeRootAndThen(ctx, () => {
         logRestartEvent('runRestart: root disposed, starting restartTui');
-        void restartTui(sessionId, options).then(restartCode => {
+        const supervision = superviseReplacement(exitSeam, options);
+        // The React tree stays mounted while supervising, so a late UI read of the
+        // ended channel is logged instead of crashing the supervisor.
+        addProcessErrorAbsorber(error => {
+            if (!(error instanceof Error) || error.message !== CHANNEL_UI_LIFETIME_ENDED)
+                return false;
+            logRestartEvent('supervisor: late UI read after dispose ignored', { at: error.stack?.split('\n').slice(1, 4).map(line => line.trim()).join(' | ') });
+            return true;
+        });
+        void restartTui(sessionId, supervision).then(restartCode => {
             logRestartEvent('runRestart: restartTui resolved', { restartCode });
             if (restartCode !== 0) {
                 writeHandoffNotice(`\ndsh-tui restart failed to spawn (exit ${restartCode}).${preservedSessionTail(sessionId, hint)}`);
@@ -2484,13 +3159,13 @@ function runRestart(ctx, profile, sessionId, hint = id => resumeCommand(profile,
         });
     });
 }
-function runUpdate(ctx, profile, sessionId, targetVersion, kernel, hint = id => resumeCommand(profile, id)) {
+function runUpdate(ctx, profile, sessionId, targetVersion, kernel, hint = id => resumeCommand(profile, id), exitSeam) {
     disposeRootAndThen(ctx, () => {
         if (profile === undefined) {
             process.stderr.write(`\n${t('update-aborted-no-profile')}\n`);
             process.exit(1);
         }
-        void updateTuiAndRestart(sessionId, profile, targetVersion, kernel).then(({ updateCode, restartCode }) => {
+        void updateTuiAndRestart(sessionId, profile, targetVersion, kernel, superviseReplacement(exitSeam, {})).then(({ updateCode, restartCode }) => {
             if (updateCode !== 0) {
                 process.stderr.write(`\ndsh-tui update failed (exit ${updateCode}).${preservedSessionTail(sessionId, hint)}`);
             }
@@ -2534,16 +3209,25 @@ function resumeCommand(profile, sessionId) {
  * handoff (update/restart) may legitimately take longer than the bound, and
  * reporting failure on a clean exit would mislead wrapper scripts.
  */
-function disposeRootAndThen(ctx, done, fallbackCode = 1) {
+function disposeRootAndThen(ctx, done, fallback = 1) {
+    const startedAt = Date.now();
     const timer = setTimeout(() => {
         // Diagnosis for a stalled disposal: without this line the fallback exit
         // is indistinguishable from a successful handoff in the field.
-        logRestartEvent('dispose: timeout, taking fallback exit', { fallbackCode });
-        process.exit(fallbackCode);
+        logRestartEvent('dispose: timeout, taking fallback exit', typeof fallback === 'number' ? { fallbackCode: fallback } : { fallback: 'signal' });
+        if (typeof fallback === 'number')
+            process.exit(fallback);
+        else
+            fallback();
     }, 5000);
     timer.unref();
-    void withHostRootCapability(() => ctx.root.fiber.dispose()).finally(() => closeBackendResources()).then(() => {
+    // A composition still running into this root settles first.
+    // The pooled, process-wide resources of every backend this process actually
+    // loaded are closed here — after the fiber, never before (P0 D4-P2/P3).
+    void disposeRootSettled(ctx, () => withHostRootCapability(() => ctx.root.fiber.dispose())).finally(() => unloadBackends()).then(() => {
         clearTimeout(timer);
+        // The teardown's length, to restart.log only (never the terminal).
+        logRestartEvent('dispose: root disposed', { ms: Date.now() - startedAt });
         done();
     }, () => {
         clearTimeout(timer);