@deepseek-harness-tui/dsh-tui 0.9.3 → 0.10.0-beta.2

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

@@ -1,8 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import { assembleContextFor, installModelSelection } from '@deepseek-ai/dsh-agent';
-import { isUserInvocable, renderSkillContent } from '@deepseek-ai/dsh-skill';
-import { createUserMessage, isTokenDelta, MessageId, ReasoningEffortId, } from '@deepseek-ai/dsh-llm';
+import { isModelInvocable, isUserInvocable, renderSkillContent } from '@deepseek-ai/dsh-skill';
+import { createUserMessage, MessageId, ReasoningEffortId, } from '@deepseek-ai/dsh-llm';
 import { runSideQuestion, wrapSideQuestion } from './sideQuestion.js';
+import { isReservedCredentialRef } from './credentialRefGuard.js';
 import { collectRecentActivity, parseRecapResponse, RECAP_RECENT_CHARS, wrapRecapPrompt } from './recap.js';
 import { SESSION_COLOR_NAMES } from '../cc/sessionColors.js';
 import { fetchBalance } from '../deepseekBalance.js';
@@ -11,7 +12,7 @@ import { SessionId } from '@deepseek-ai/dsh-session';
 import { renderContextSections, renderPrompt } from '@deepseek-ai/dsh-system-prompt';
 import { loadBaselineInstructions } from '@deepseek-ai/dsh-agent-instructions';
 import { extname, isAbsolute, join } from 'node:path';
-import { completeCommands, HIDDEN_COMMAND_NAMES, isLocalCommandName, LOCAL_COMMANDS, parseCommandName } from '../commands.js';
+import { completeCommands, HIDDEN_COMMAND_NAMES, isCommandCompletionToken, isLocalCommandName, LOCAL_COMMANDS, parseCommandName } from '../commands.js';
 import { clearResumeTarget, forgetSession, readResumeTarget, touchSession, writeResumeTarget } from '../sessionHistory.js';
 import { appendSessionTitle, defaultMaxScanned, deleteSessionLog, ensureLegacySessionEventTypes, readSessionEventsFromFile, readSessionEventsFromLog, sessionsRoots } from './compat/index.js';
 import { buildSessionTree, forkTarget, liveTailWindow, rewindTarget, turnUserText, } from './sessionTree.js';
@@ -22,16 +23,17 @@ import { isPathLikeQuery, rankFileCandidates } from '../utils/fileSuggestions.js
 import { readEffortPref, writeEffortPref } from '../effortPrefs.js';
 import { readModelPref, writeModelPref } from '../modelPrefs.js';
 import { explicitModelRoute, recordedModelRoute, resolveModelRoute, validateModelRoute } from '../modelRoute.js';
-import { readPresetPref, writePresetPref } from '../presetPrefs.js';
-import { composePreset, resolvePersistedPreset, resolvePersistedRoute, rosterOf, runningPresetOf, serviceForAgent } from './presets.js';
+import { migratePresetPref, readPresetPref, writePresetPref } from '../presetPrefs.js';
+import { composePreset, resolvePersistedPreset, resolvePersistedRoute, runningPresetOf, serviceForAgent } from './presets.js';
+import { resolveCompatiblePreset, rosterOf } from './preset-resolution.js';
 import { isPresetName, PRESET_NAMES } from '../components/activityFrames.js';
 import { existsSync, statSync, writeFileSync } from 'node:fs';
 import { logForDebugging } from '../utils/debug.js';
 import { homeDir, LEGACY_DATA_DIR } from '../utils/paths.js';
 import { extractMentions } from '../utils/mentions.js';
 import { getLang, LANGS, t } from '../i18n.js';
-import { AUTO_THEME_NAME, THEME_NAMES } from '../theme.js';
-import { listCustomThemes } from '../customTheme.js';
+import { AUTO_THEME_NAME } from '../theme.js';
+import { listThemeCatalog } from '../themeCatalog.js';
 import { modeDisplayName, resolveSessionModes } from '../sessionModes.js';
 import { normalizeScrollGutter, normalizeStatusBar, normalizeToolBackground } from '../tuiDisplayPrefs.js';
 import { SubagentActivityStore } from './subagents.js';
@@ -45,6 +47,7 @@ import { getHostCommandTrees } from './command-trees.js';
 import { getHostSettingsSections, getLocalSettingsSectionsHost } from './settings-sections.js';
 import { getHostSceneRuntime } from './scenes.js';
 import { getHostRenderers } from './renderers.js';
+import { getHostThemes } from './themes.js';
 import { getHostMessageObserver } from './message-observer.js';
 import { dispatchTuiDecision, dispatchTuiNotification, normalizeCancelDecision } from './extension-events.js';
 import { installDecisionGuard } from './decision-guard.js';
@@ -131,6 +134,119 @@ function normalizeRewindPromptDecision(result, warn) {
 /** Toast-bound plugin text (veto reasons, handled notices, rewind summaries)
  *  is render-path data too: same sanitization, toast-width cap. */
 const NOTICE_CELLS = 200;
+const PERMISSION_PRESET_CUSTOM = 'custom';
+const PERMISSION_PRESET_NAME_CELLS = 120;
+const PERMISSION_PRESET_DESCRIPTION_CELLS = 400;
+function isRecord(value) {
+    return value !== null && typeof value === 'object';
+}
+function legacyPermissionPresetOptions() {
+    return [
+        {
+            value: 'read-only',
+            name: t('permission-preset-readonly'),
+            description: t('permission-preset-readonly-desc'),
+        },
+        {
+            value: 'workspace-write',
+            name: t('permission-preset-workspace-write'),
+            description: t('permission-preset-workspace-write-desc'),
+        },
+        {
+            value: 'danger-full-access',
+            name: t('permission-preset-full-access'),
+            description: t('permission-preset-full-access-desc'),
+        },
+    ];
+}
+function legacyPermissionPresetSnapshot(sandbox) {
+    const options = legacyPermissionPresetOptions();
+    const currentOption = sandbox === undefined ? undefined : options.find(option => option.value === sandbox);
+    return {
+        availability: 'legacy',
+        options,
+        ...(currentOption === undefined
+            ? {}
+            : { current: { ...currentOption, kind: 'preset' } }),
+    };
+}
+function unavailablePermissionPresetSnapshot() {
+    return { availability: 'unavailable', options: [] };
+}
+function normalizePermissionPresetOption(value) {
+    if (!isRecord(value) || typeof value.value !== 'string' || typeof value.name !== 'string')
+        return undefined;
+    const name = cleanRenderText(value.name, PERMISSION_PRESET_NAME_CELLS);
+    if (name === '')
+        return undefined;
+    if (value.description !== undefined && typeof value.description !== 'string')
+        return undefined;
+    const description = value.description === undefined
+        ? undefined
+        : cleanRenderText(value.description, PERMISSION_PRESET_DESCRIPTION_CELLS);
+    if (value.description !== undefined && description === '')
+        return undefined;
+    return {
+        value: value.value,
+        name,
+        ...(description === undefined || description === '' ? {} : { description }),
+    };
+}
+function permissionPresetSnapshotFromService(service, events) {
+    if (!isRecord(service))
+        return unavailablePermissionPresetSnapshot();
+    const runtime = service;
+    try {
+        const capturedNames = runtime.names;
+        const current = runtime.current;
+        const optionOf = runtime.optionOf;
+        if (!Array.isArray(capturedNames) || capturedNames.length === 0)
+            return unavailablePermissionPresetSnapshot();
+        if (typeof current !== 'function' || typeof optionOf !== 'function')
+            return unavailablePermissionPresetSnapshot();
+        const names = [...capturedNames];
+        const seen = new Set();
+        for (const name of names) {
+            if (typeof name !== 'string' || name.trim() === '' || name === PERMISSION_PRESET_CUSTOM || seen.has(name)) {
+                return unavailablePermissionPresetSnapshot();
+            }
+            seen.add(name);
+        }
+        const options = [];
+        for (const name of names) {
+            const option = normalizePermissionPresetOption(optionOf(name));
+            if (option === undefined || option.value !== name)
+                return unavailablePermissionPresetSnapshot();
+            options.push({ ...option });
+        }
+        const currentValue = current(events);
+        if (typeof currentValue !== 'string' || (currentValue !== PERMISSION_PRESET_CUSTOM && !seen.has(currentValue))) {
+            return unavailablePermissionPresetSnapshot();
+        }
+        const currentOption = normalizePermissionPresetOption(optionOf(currentValue));
+        if (currentOption === undefined || currentOption.value !== currentValue)
+            return unavailablePermissionPresetSnapshot();
+        if (currentValue !== PERMISSION_PRESET_CUSTOM) {
+            const rosterOption = options.find(option => option.value === currentValue);
+            if (rosterOption === undefined
+                || rosterOption.name !== currentOption.name
+                || rosterOption.description !== currentOption.description) {
+                return unavailablePermissionPresetSnapshot();
+            }
+        }
+        return {
+            availability: 'runtime',
+            options,
+            current: {
+                ...currentOption,
+                kind: currentValue === PERMISSION_PRESET_CUSTOM ? 'custom' : 'preset',
+            },
+        };
+    }
+    catch {
+        return unavailablePermissionPresetSnapshot();
+    }
+}
 /** `tui/rewind-done` return normalization: the first non-empty STRING is the
  *  summary; anything else is not a decision. */
 function normalizeRewindDoneSummary(result, warn) {
@@ -173,6 +289,22 @@ const SUBAGENT_TOOL_NAMES = new Set([
 function isSubagentToolName(name) {
     return SUBAGENT_TOOL_NAMES.has(name.toLowerCase());
 }
+/** Narrow an optional plugin event without importing its module augmentation. */
+function todoPanelItems(data) {
+    if (typeof data !== 'object' || data === null)
+        return undefined;
+    const todos = data.todos;
+    if (!Array.isArray(todos))
+        return undefined;
+    const valid = todos.every(item => {
+        if (typeof item !== 'object' || item === null)
+            return false;
+        const candidate = item;
+        return typeof candidate.content === 'string' &&
+            (candidate.status === 'pending' || candidate.status === 'in_progress' || candidate.status === 'completed');
+    });
+    return valid ? todos : undefined;
+}
 const ARGS_PREVIEW_LIMIT = 160;
 const RESULT_PREVIEW_LIMIT = 240;
 /** Local `!`-command output cap (mirrors the result preview limit). */
@@ -508,6 +640,7 @@ async function waitForTurnEnd(session, fromSeq, timeoutMs) {
 export function createChannel(ctx, initialAgent, options) {
     let agent = initialAgent;
     let currentHandle = options.handle;
+    const themeHost = getHostThemes(ctx.get('tuiThemes'));
     const subagentControl = {
         interrupt(agentId) {
             const child = subagentStore.get(agentId);
@@ -662,6 +795,25 @@ export function createChannel(ctx, initialAgent, options) {
         state.subagents = subagentStore.snapshot();
         syncSubagentRows(state.subagents);
     };
+    /** Drop the subagent row map (transcript wipe): the next event for a still
+     *  live subagent re-creates its card as a fresh row instead of feeding a
+     *  row object no transcript holds (update-only orphan). */
+    const dropSubagentRows = () => {
+        subagentStreamDirty = false;
+        subagentRowsByAgentId.clear();
+    };
+    /** Full subagent reset for a session swap: the row map, the queued task
+     *  descriptions and the store itself are all scoped to the OLD agent's
+     *  session. Leaked into the adopted one, they would keep dead subagents in
+     *  the dashboard snapshot until new events overwrite it, grow the row map
+     *  without bound across swaps, and hand a stale queued description to the
+     *  new session's first card. */
+    const resetSubagentProjection = () => {
+        dropSubagentRows();
+        pendingTaskDescriptions.length = 0;
+        subagentStore.reset();
+        state.subagents = [];
+    };
     // foldRows incremental cursor (see foldRows): rows only append past the
     // fold line, so each pass touches only newly-eligible rows.
     const foldCursor = { rows: null, index: 0 };
@@ -906,6 +1058,7 @@ export function createChannel(ctx, initialAgent, options) {
         toolCards.clear();
         nextRowId = 0;
         state.rows.length = 0;
+        resetSubagentProjection();
         // Goal/todo/title are session-scoped; the replay re-derives them for
         // the session being entered (or leaves them empty).
         state.todos = [];
@@ -958,6 +1111,11 @@ export function createChannel(ctx, initialAgent, options) {
         touchSession(childId);
         state.emit();
         void oldHandle?.dispose().catch(() => { });
+        // The staged-image map is session-scoped (the same contract the
+        // resumeTo/newSession tails enforce): tokens typed against the rewound
+        // conversation must not ride into the fork's next send, and the epoch
+        // bump fences saves still in flight for the old session.
+        clearStagedImages();
         return sourceSessionId;
     };
     /** Monotonic token: only the latest `interruptAndDeliver` re-queues, so a
@@ -1176,7 +1334,7 @@ export function createChannel(ctx, initialAgent, options) {
             }
             // `undefined` = not registered; a handler error surfaces as its
             // message so the user sees why the command failed.
-            return execution?.result.text ?? '';
+            return execution === undefined ? undefined : execution.result.text ?? '';
         }
         catch (error) {
             return error instanceof Error ? error.message : String(error);
@@ -1389,6 +1547,39 @@ export function createChannel(ctx, initialAgent, options) {
             state.emit();
         }).catch(() => { });
     };
+    // --- Manual-compaction lifecycle ---------------------------------------
+    // The in-flight /compact transaction: its abort hook plus the settled
+    // promise. Every path that replaces `agent` (rewind / rewind-node /
+    // resume / new / model switch) must cancel and await it BEFORE snapshot-
+    // ting the session. Without this, a slow summarizer keeps running against
+    // the OLD session across the switch and can commit its replacement
+    // checkpoint AFTER the fork snapshot — silently swapping the history the
+    // user believed intact ("compaction failed → /model → context lost").
+    let manualCompaction;
+    /** Compactions cancelled by settleManualCompaction: their rejection is expected. */
+    const cancelledCompactions = new WeakSet();
+    /**
+     * Cancel an in-flight manual compaction and wait for it to settle.
+     * Aborting tears the summarizer stream down; dsh-compaction then closes
+     * the transaction with an error end marker and rejects compactNow with
+     * the `cancelled` class — no checkpoint is committed, the surface stays
+     * whole. The settle race is capped so a stuck stream can never wedge the
+     * session switch itself.
+     */
+    const settleManualCompaction = async () => {
+        const active = manualCompaction;
+        if (active === undefined)
+            return;
+        manualCompaction = undefined;
+        cancelledCompactions.add(active.controller);
+        active.controller.abort(new Error('session switch'));
+        state.notify(t('compact-cancelled-switch'), { color: 'warning', timeoutMs: 4000 });
+        await Promise.race([
+            active.settled,
+            new Promise(resolve => { setTimeout(resolve, 3000); }),
+        ]);
+    };
+    let agentBindingGeneration = 0;
     const state = {
         effortLevels: undefined,
         version: 0,
@@ -1407,6 +1598,7 @@ export function createChannel(ctx, initialAgent, options) {
             return ns?.value?.recapOnOpen !== false;
         },
         agentId: agent.id,
+        agentBindingGeneration: 0,
         model: options.model,
         provider: options.provider,
         tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, peak: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, idle: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } },
@@ -1442,6 +1634,8 @@ export function createChannel(ctx, initialAgent, options) {
         scrollGutter: normalizeScrollGutter(options.scrollGutter),
         foldTerminalCommand: options.foldTerminalCommand === true,
         promptSessionLabel: options.promptSessionLabel === true,
+        expandEditor: options.expandEditor !== false,
+        smoothStreaming: options.smoothStreaming !== false,
         statusBar: normalizeStatusBar(options.statusBar),
         whale: options.whale !== false,
         minimal: options.minimal === true,
@@ -1484,21 +1678,34 @@ export function createChannel(ctx, initialAgent, options) {
                     ];
                 }
                 if (path.length === 1 && path[0] === 'theme') {
+                    const themeEntries = listThemeCatalog(themeHost);
                     return [
                         { name: 'status', description: 'Show the current theme', descriptionKey: 'sugg-status-desc' },
                         { name: AUTO_THEME_NAME, description: 'Follow the terminal background', descriptionKey: 'sugg-theme-auto-desc' },
-                        ...THEME_NAMES.map((name) => ({
-                            name,
-                            description: `Built-in theme ${name}`,
-                            descriptionKey: 'sugg-theme-builtin-desc',
-                        })),
-                        ...listCustomThemes()
-                            .filter((spec) => spec.name !== AUTO_THEME_NAME)
-                            .map((spec) => ({
-                            name: spec.name,
-                            description: `User theme (${spec.base} base)`,
-                            descriptionKey: 'sugg-theme-user-desc',
-                        })),
+                        ...themeEntries
+                            .filter((entry) => entry.name !== AUTO_THEME_NAME)
+                            .map((entry) => {
+                            const base = entry.base ?? 'dark';
+                            if (entry.source === 'builtin') {
+                                return {
+                                    name: entry.name,
+                                    description: `Built-in theme ${entry.name}`,
+                                    descriptionKey: 'sugg-theme-builtin-desc',
+                                };
+                            }
+                            if (entry.source === 'runtime') {
+                                return {
+                                    name: entry.name,
+                                    description: `Plugin theme (${base} base)`,
+                                    descriptionKey: 'sugg-theme-plugin-desc',
+                                };
+                            }
+                            return {
+                                name: entry.name,
+                                description: `User theme (${base} base)`,
+                                descriptionKey: 'sugg-theme-user-desc',
+                            };
+                        }),
                     ];
                 }
                 if (path.length === 1 && path[0] === 'color') {
@@ -1573,13 +1780,23 @@ export function createChannel(ctx, initialAgent, options) {
                     ];
                 }
                 if (path.length === 1 && path[0] === 'permission') {
-                    // Sandbox-preset vocabulary of the `/permission` picker — Tab
-                    // completes it for keyboard users, Enter still dispatches.
-                    return [
-                        { name: 'read-only', description: 'Read-only session: no file writes, no commands', descriptionKey: 'permission-preset-readonly-desc' },
-                        { name: 'workspace-write', description: 'Read/write inside the workspace; writes need a prior read', descriptionKey: 'permission-preset-workspace-write-desc' },
-                        { name: 'danger-full-access', description: 'Unrestricted access, no approvals', descriptionKey: 'permission-preset-full-access-desc' },
-                    ];
+                    const snapshot = state.permissionPresets();
+                    return snapshot.options
+                        .filter(option => isCommandCompletionToken(option.value))
+                        .map(option => ({
+                        name: option.value,
+                        description: option.description ?? option.name,
+                        ...(option.value === 'read-only'
+                            ? { descriptionKey: 'permission-preset-readonly-desc' }
+                            : option.value === 'workspace-write'
+                                ? { descriptionKey: 'permission-preset-workspace-write-desc' }
+                                : option.value === 'danger-full-access'
+                                    ? { descriptionKey: 'permission-preset-full-access-desc' }
+                                    : {}),
+                        ...(snapshot.current?.kind === 'preset' && snapshot.current.value === option.value
+                            ? { tag: 'current' }
+                            : {}),
+                    }));
                 }
                 if (path.length === 1 && path[0] === 'plan') {
                     return [
@@ -1833,6 +2050,10 @@ export function createChannel(ctx, initialAgent, options) {
                     return null;
                 }
             }
+            // An in-flight manual compaction must not straddle the fork: cancel it
+            // and wait, or its checkpoint could commit right after the seed snapshot
+            // below and quietly replace history the rewind was meant to preserve.
+            await settleManualCompaction();
             const childId = SessionId(randomUUID());
             // DSH event order is `turn/start → user/message → … → turn/end`, so a
             // message's own seq always sits inside its turn — forking there would
@@ -2363,6 +2584,10 @@ export function createChannel(ctx, initialAgent, options) {
                 state.notify(t('rewind-unavailable'), { color: 'error' });
                 return null;
             }
+            // An in-flight manual compaction must not straddle the snapshot below
+            // (live branch) nor keep summarizing the current session while the
+            // rewind targets another — cancel and await it first.
+            await settleManualCompaction();
             // Pin the entry-time session: the awaits below (log load, preset
             // compose, agent create) are windows in which a queued switch
             // (/new, /resume, /model) can swap `agent` — the mutation queue only
@@ -2543,6 +2768,10 @@ export function createChannel(ctx, initialAgent, options) {
                 state.notify(t('fork-while-working'), { color: 'warning' });
                 return false;
             }
+            // An in-flight manual compaction must not straddle the fork snapshot:
+            // cancel and await it, or its checkpoint could commit right after the
+            // seed copy below and quietly replace history the fork preserved.
+            await settleManualCompaction();
             const source = agent.session;
             const childId = SessionId(randomUUID());
             // No boundary: the whole (turn-closed) log. Slice via sessions.fork for
@@ -2641,6 +2870,15 @@ export function createChannel(ctx, initialAgent, options) {
             // untouched.
             if (await sessionSwitchVetoed('resume', sessionId))
                 return { ok: false, reason: 'cancelled' };
+            // The live session's in-flight manual compaction must not keep running
+            // (and commit its checkpoint) once we leave it for the target — cancel
+            // and await it before any target read.
+            await settleManualCompaction();
+            // Identity pin for the rival-swap guard below: everything between here
+            // and the adoption can await (veto, preset, route, agents.resume), and
+            // an interrupt-queued /new or a second /resume may commit a different
+            // swap in that window.
+            const entrySession = agent.session;
             let handle;
             // Compat boundary: register vouched-for legacy event types (e.g.
             // activity/status from pre-#143 logs) in every reachable dsh-session
@@ -2692,6 +2930,17 @@ export function createChannel(ctx, initialAgent, options) {
             catch (error) {
                 state.notify(t('resume-attach-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'warning', timeoutMs: 8000 });
             }
+            // Rival-swap guard (rewindToNode's entrySession check, applied to the
+            // resume path): the awaits above can straddle another session swap
+            // committing first, and adopting now would stomp the newer session's
+            // live transcript with this target's replay. Free the just-created
+            // handle and bail — the live session stays exactly as the rival left
+            // it, and the persisted target simply stays in /resume.
+            if (agent.session !== entrySession) {
+                void handle.dispose().catch(() => { });
+                state.notify(t('resume-session-changed'), { color: 'error' });
+                return { ok: false, reason: 'failed', error: 'live session changed during resume' };
+            }
             // Replay the persisted history into a fresh transcript (same reset as
             // rewindTo, plus the context window which the replay re-derives).
             streaming = undefined;
@@ -2703,6 +2952,7 @@ export function createChannel(ctx, initialAgent, options) {
             toolCards.clear();
             nextRowId = 0;
             state.rows.length = 0;
+            resetSubagentProjection();
             // Goal/todo/title are session-scoped; the replay re-derives them for
             // the session being entered (or leaves them empty).
             state.todos = [];
@@ -2805,12 +3055,20 @@ export function createChannel(ctx, initialAgent, options) {
             // happened yet — the session id below is not even allocated.
             if (await sessionSwitchVetoed('new'))
                 return false;
+            // Leaving the live session: its in-flight manual compaction must not
+            // keep summarizing (and later commit a checkpoint the user believes
+            // cancelled) — cancel and await it first.
+            await settleManualCompaction();
             const sessionId = SessionId(randomUUID());
             let handle;
             // A fresh session composes the caller's DEFAULT preset: the cordis.yml
             // `preset` key wins over the persisted `/preset` choice, which wins
             // over the roster default (same precedence as activityFrames).
-            const newComposed = await composePreset(ctx, options.configuredPreset ?? readPresetPref());
+            const presetPref = options.configuredPreset === undefined ? readPresetPref() : undefined;
+            const newComposed = await composePreset(ctx, options.configuredPreset ?? presetPref);
+            if (!migratePresetPref(presetPref, newComposed.agentPreset)) {
+                state.notify(t('preset-switched-pref-failed', { id: newComposed.agentPreset ?? presetPref ?? 'unknown' }), { color: 'warning' });
+            }
             // Same precedence for the route (issues #14/#30/#67): the pair resolves
             // atomically — a complete cordis.yml route wins whole, else the
             // persisted `/model` choice (a switch earlier in this run just wrote
@@ -2872,6 +3130,7 @@ export function createChannel(ctx, initialAgent, options) {
             lastTextDelta.clear();
             nextRowId = 0;
             state.rows.length = 0;
+            resetSubagentProjection();
             // Goal/todo/title are session-scoped; the replay re-derives them for
             // the session being entered (or leaves them empty).
             state.todos = [];
@@ -3008,6 +3267,11 @@ export function createChannel(ctx, initialAgent, options) {
             }
             let seed;
             try {
+                // An in-flight manual compaction must not straddle the fork: cancel
+                // it first, or its checkpoint can commit right after this snapshot —
+                // the model-switched child would start from the summary alone while
+                // the user believes the full history carried over ("context lost").
+                await settleManualCompaction();
                 // No boundary = fork the whole log (continue the conversation).
                 seed = sessions.fork(agent.session).events;
             }
@@ -3057,6 +3321,7 @@ export function createChannel(ctx, initialAgent, options) {
             toolCards.clear();
             nextRowId = 0;
             state.rows.length = 0;
+            resetSubagentProjection();
             // Goal/todo/title are session-scoped; the replay re-derives them for
             // the session being entered (or leaves them empty).
             state.todos = [];
@@ -3111,7 +3376,7 @@ export function createChannel(ctx, initialAgent, options) {
             currentHandle = handle;
             bindAgent();
             // Model-switch quip rides the fresh tracker (pi parity).
-            activityTracker.onModelSwitch(model);
+            updateWorkingActivity('model switch', () => activityTracker.onModelSwitch(model));
             refreshCommandList();
             void refreshLoadedContext();
             void refreshSkillCommands();
@@ -3119,6 +3384,9 @@ export function createChannel(ctx, initialAgent, options) {
             touchSession(childId);
             state.emit();
             void oldHandle?.dispose().catch(() => { });
+            // Staged image tokens were typed against the pre-switch conversation;
+            // resumeTo/newSession already drop theirs on the swap — same contract.
+            clearStagedImages();
             // Persist the choice so the next boot and `/new` start on it (same
             // contract as /preset and /effort; issues #14/#30). A failed
             // write keeps the live switch but warns it will not survive a restart.
@@ -3138,6 +3406,11 @@ export function createChannel(ctx, initialAgent, options) {
             streaming = undefined;
             reasoning = undefined;
             toolCards.clear();
+            // In-flight subagents keep streaming after the wipe; clearing the row
+            // map lets their next event re-create the card as a fresh row instead
+            // of feeding a row object no transcript holds (the store keeps live
+            // tracking for the dashboard — same session, still running).
+            dropSubagentRows();
             state.activeToolCount = 0;
             state.responseChars = 0;
             state.rows.push({
@@ -3214,6 +3487,18 @@ export function createChannel(ctx, initialAgent, options) {
             state.promptSessionLabel = enabled;
             state.emit();
         },
+        setExpandEditor(enabled) {
+            if (enabled === state.expandEditor)
+                return;
+            state.expandEditor = enabled;
+            state.emit();
+        },
+        setSmoothStreaming(enabled) {
+            if (enabled === state.smoothStreaming)
+                return;
+            state.smoothStreaming = enabled;
+            state.emit();
+        },
         setStatusBar(config) {
             const next = normalizeStatusBar({ ...state.statusBar, ...config });
             const changed = Object.keys(next).some(key => next[key] !== state.statusBar[key]);
@@ -3255,6 +3540,18 @@ export function createChannel(ctx, initialAgent, options) {
             state.notify(t('activity-indicator-switched', { name }));
             return true;
         },
+        permissionPresets() {
+            let service;
+            try {
+                service = ctx.get('permissionPresets');
+            }
+            catch {
+                return unavailablePermissionPresetSnapshot();
+            }
+            if (service === undefined)
+                return legacyPermissionPresetSnapshot(state.mode.sandbox);
+            return permissionPresetSnapshotFromService(service, agent.session.events);
+        },
         async listPresets() {
             const presets = rosterOf(ctx);
             if (presets === undefined)
@@ -3285,17 +3582,21 @@ export function createChannel(ctx, initialAgent, options) {
             }
             let target;
             try {
-                target = await presets.resolve(presetId);
+                target = await resolveCompatiblePreset(presets, presetId);
             }
             catch (error) {
                 state.notify(t('preset-not-found', { id: presetId, err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
                 return false;
             }
             if (target.broken !== undefined) {
-                state.notify(t('preset-load-failed', { id: presetId, broken: target.broken }), { color: 'error', timeoutMs: 8000 });
+                state.notify(t('preset-load-failed', { id: target.id, broken: target.broken }), { color: 'error', timeoutMs: 8000 });
                 return false;
             }
             if (target.id === state.agentPreset) {
+                if (!migratePresetPref(presetId, target.id)) {
+                    state.notify(t('preset-switched-pref-failed', { id: target.id }), { color: 'warning' });
+                    return true;
+                }
                 state.notify(t('preset-already-current', { id: target.id }), { color: 'success' });
                 return true;
             }
@@ -3436,6 +3737,14 @@ export function createChannel(ctx, initialAgent, options) {
                 async writeCredential(ref, value) {
                     if (!credentials)
                         throw new Error('credentials service unavailable');
+                    // Second layer of the secret-ref reservation guard: the
+                    // registration layer already rejects plugin sections with
+                    // host-owned refs, but this seam must not trust it — a stale
+                    // section (registered before the guard) or a direct call must not
+                    // reach the shared credentials. The host's own main-credential
+                    // writes go through providerSetup().writeCredential instead.
+                    if (isReservedCredentialRef(ref))
+                        throw new Error(t('settings-secret-ref-reserved', { ref }));
                     await credentials.set(ref, value);
                 },
             };
@@ -3751,18 +4060,43 @@ export function createChannel(ctx, initialAgent, options) {
                     state.notify(t('compact-while-working'), { color: 'warning' });
                     return;
                 }
-                const signal = new AbortController().signal;
+                const controller = new AbortController();
                 state.notify(t('compact-working'));
-                void compactService
-                    .compactNow(agent, signal)
-                    .then((result) => {
-                    state.notify(result ? t('compact-done') : t('compact-nothing'));
-                    // Compaction quip rides the next thinking rotation (pi parity).
-                    if (result)
-                        activityTracker.onCompact('done');
-                })
-                    .catch((error) => {
-                    state.notify(t('compact-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+                // Register the in-flight transaction so any agent-replacing path
+                // (rewind/resume/new/model switch) can cancel it before snapshotting
+                // the session — see settleManualCompaction. `settled` never rejects:
+                // every branch lands in a notification.
+                const settled = (async () => {
+                    try {
+                        const result = await compactService.compactNow(agent, controller.signal);
+                        state.notify(result ? t('compact-done') : t('compact-nothing'));
+                        // Compaction quip rides the next thinking rotation (pi parity).
+                        if (result)
+                            updateWorkingActivity('compaction', () => activityTracker.onCompact('done'));
+                    }
+                    catch (error) {
+                        // ManualCompactionError('persistence'): the replacement checkpoint
+                        // is ALREADY committed — only the durability flush failed. The
+                        // surface is now the summary, so a plain "failed" toast here sent
+                        // users to /model expecting full history and finding only the
+                        // summary ("context lost"). Distinguish it, structurally — the
+                        // TUI must not import the error class across the adapter seam.
+                        if (error.code === 'persistence') {
+                            state.notify(t('compact-flush-failed'), { color: 'warning', timeoutMs: 12000 });
+                            return;
+                        }
+                        // A switch-initiated abort rejects compactNow with the abort reason;
+                        // the cancellation was already toasted above — a second generic
+                        // "failed" toast for the same, expected rejection would mislead.
+                        if (cancelledCompactions.has(controller))
+                            return;
+                        state.notify(t('compact-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+                    }
+                })();
+                manualCompaction = { controller, settled };
+                void settled.finally(() => {
+                    if (manualCompaction?.controller === controller)
+                        manualCompaction = undefined;
                 });
             })().catch((error) => {
                 // Sync throws from compactNow (e.g. runMaintenance rejecting a
@@ -4039,19 +4373,21 @@ export function createChannel(ctx, initialAgent, options) {
                 ...(renderedInstructions?.truncated ?? []).map(file => file.displayPath),
             ]);
             files.push(...[...instructionPaths].map(displayPath => ({ displayPath })));
-            // The skills registry is host-plane but scope-layered: preset rows
-            // (skill-filesystem) register into the preset's layer, so the catalog
-            // must be read through the agent's scope chain (serviceForAgent falls
-            // back to the host context when no roster is mounted).
-            const skillsService = serviceForAgent(ctx, target, 'skills');
-            if (skillsService !== undefined) {
-                const catalog = await skillsService.list({});
+            // A registry entry reaches the model only through dsh-tool-skill's
+            // catalog, which is gated on that exact tool being visible to the agent.
+            const skillsRegistry = tools.some(tool => tool.name === 'skill')
+                ? skillRegistryFor(target)
+                : undefined;
+            if (skillsRegistry !== undefined) {
+                const observation = await skillsRegistry.snapshot(skillViewOptions(target));
                 if (target !== agent)
                     return;
-                skills.push(...catalog.map(skill => ({
-                    name: skill.name,
-                    description: skill.description,
-                })));
+                if (observation.complete) {
+                    skills.push(...observation.skills.filter(isModelInvocable).map(skill => ({
+                        name: skill.name,
+                        description: skill.description,
+                    })));
+                }
             }
         }
         catch (error) {
@@ -4065,7 +4401,7 @@ export function createChannel(ctx, initialAgent, options) {
      * Rebuild the merged slash-command list: built-in locals, then registry
      * commands (plan/goal/…), then user-invocable skills from the DSH skill
      * registry (issue #86 — filesystem-discovered skills must appear in the
-     * `/` menu and Tab completion, like /audit and /review). Skill entries
+     * `/` menu and Tab completion, like /my-skill). Skill entries
      * are completion-only: dispatch falls through to the model as plain text,
      * where dsh-tool-skill's pre-step hook injects the skill body — the same
      * path a hand-typed `/skill-name` takes. Registry and skill reads are
@@ -4538,7 +4874,7 @@ ${output}
             streaming = existing;
             return existing;
         }
-        streaming = { id: nextRowId, kind: 'assistant', text: '', streaming: true, ...seq !== undefined ? { seq } : {} };
+        streaming = { id: nextRowId, kind: 'assistant', text: '', streaming: true, fresh: true, ...seq !== undefined ? { seq } : {} };
         nextRowId += 1;
         state.rows.push(streaming);
         return streaming;
@@ -4877,6 +5213,11 @@ ${output}
                     if (text)
                         row.text = text;
                     row.streaming = false;
+                    // Live settles keep the smooth-reveal cursor alive (a one-shot
+                    // non-streaming delivery still paints as a flow); replayed
+                    // settles must not — the transcript would typewrite on open.
+                    if (!replaying && text)
+                        row.fresh = true;
                 }
                 streaming = undefined;
                 if (reasoning !== undefined) {
@@ -5000,6 +5341,9 @@ ${output}
                     kind: 'tool',
                     text: '',
                     seq: event.seq,
+                    // Smooth-reveal participation flag: live cards animate their body
+                    // in; replayed cards (resume/rewind) paint complete.
+                    fresh: !replaying,
                     tool: {
                         callId: event.data.callId,
                         name: event.data.name,
@@ -5153,21 +5497,31 @@ ${output}
             case 'session/title':
                 state.sessionTitle = event.data.title;
                 break;
-            case 'todo/write':
-                // Whole-list snapshot — latest write wins; log-only UI state.
-                state.todos = event.data.todos;
-                break;
             default:
+                // dsh-tool-todo owns this optional module augmentation in alpha.2.
+                // Match by name so the TUI remains loadable without that plugin.
+                if (event.type === 'todo/write') {
+                    const todos = todoPanelItems(event.data);
+                    if (todos !== undefined)
+                        state.todos = todos;
+                    break;
+                }
                 // Logged preset switch (blank sessions only, issue #8): a transcript
                 // marker so a replayed log shows which composition produced the
                 // turns after it. Not in dsh-session's typed union — matched here by
                 // name, like the other plugin-defined events above.
                 if (event.type === 'agent-preset/selected') {
                     const data = event.data;
+                    const recordedPreset = typeof data.agentPreset === 'string' ? data.agentPreset : undefined;
+                    const renamedOfficialPreset = (recordedPreset === 'code' && state.agentPreset === 'ptc') ||
+                        (recordedPreset === 'ptc' && state.agentPreset === 'code');
+                    const preset = renamedOfficialPreset && state.agentPreset !== undefined
+                        ? state.agentPreset
+                        : recordedPreset ?? 'unknown';
                     state.rows.push({
                         id: nextRowId,
                         kind: 'notice',
-                        text: t('agent-preset-switched', { preset: data.agentPreset ?? 'unknown' }),
+                        text: t('agent-preset-switched', { preset }),
                     });
                     nextRowId += 1;
                     break;
@@ -5264,17 +5618,60 @@ ${output}
         state.workingActivity = rendered;
         return rendered;
     };
+    // Working Activity is an optional presentation sidecar. A malformed durable
+    // event must never let it abort the authoritative channel projection (Cordis
+    // contains the listener throw, but the rest of THIS callback would otherwise
+    // be skipped — including turn/end and inbox retirement).
+    let activityFailureReported = false;
+    const updateWorkingActivity = (source, update) => {
+        try {
+            update?.();
+            return renderWorkingActivity();
+        }
+        catch (error) {
+            if (!activityFailureReported) {
+                activityFailureReported = true;
+                const detail = error instanceof Error ? error.message : String(error);
+                ctx.logger.warn(`dsh-tui: working-activity ignored ${source} after a projection error: ${detail}`);
+            }
+            return undefined;
+        }
+    };
+    /**
+     * Release volatile UI gates when the bound driver is definitively quiescent
+     * but its terminal session event did not reach this projection. This does not
+     * invent a turn/end or any transcript fact; it only reconciles live controls
+     * to the authoritative Agent status so Enter/Esc cannot remain latched.
+     */
+    const reconcileRetiredProjection = (status) => {
+        if (!state.working)
+            return;
+        ctx.logger.warn(`dsh-tui: agent became ${status} while the channel still projected an open turn; releasing volatile UI gates`);
+        cancelInFlight = false;
+        state.cancelPending = false;
+        state.working = false;
+        state.activeToolCount = 0;
+        settleStreaming();
+        updateSpinnerMode();
+    };
     const bindAgent = () => {
+        agentBindingGeneration += 1;
+        state.agentBindingGeneration = agentBindingGeneration;
         for (const dispose of agentSubscriptions)
             dispose();
         stopActivityTick();
+        // Cancel state and deferred interrupt delivery belong to one bound agent.
+        // A replacement must neither inherit the old latch nor receive its queued
+        // microtask after the session identity changes.
+        cancelInFlight = false;
+        interruptSeq += 1;
         const prefs = activityPrefsSnapshot();
         activityTracker = new ActivityTracker(prefs.config, Date.now, prefs.customActions);
-        activityTracker.onAgentStatus(agent.status);
-        renderWorkingActivity();
+        activityFailureReported = false;
+        updateWorkingActivity('agent bind', () => activityTracker.onAgentStatus(agent.status));
         activityTickTimer = setInterval(() => {
             const previous = state.workingActivity;
-            const rendered = renderWorkingActivity();
+            const rendered = updateWorkingActivity('activity tick');
             if (rendered === undefined)
                 return;
             // Live phases deliberately wake at 500 ms even when the formatted line
@@ -5318,8 +5715,9 @@ ${output}
                 if (subject !== agent)
                     return;
                 state.status = status;
-                activityTracker.onAgentStatus(status);
-                renderWorkingActivity();
+                updateWorkingActivity(`agent/status:${status}`, () => activityTracker.onAgentStatus(status));
+                if (status === 'idle')
+                    reconcileRetiredProjection('idle');
                 state.emit();
             }),
             ctx.on('agent/disposed', ({ agent: subject }) => {
@@ -5327,6 +5725,7 @@ ${output}
                     return;
                 state.status = 'disposed';
                 stopActivityTick();
+                reconcileRetiredProjection('disposed');
                 state.emit();
             }),
             // Pending delivery is driven by the agent inbox: a claimed message
@@ -5358,9 +5757,16 @@ ${output}
                 };
             })(),
             ctx.on('session/event', (session, event) => {
-                // First check if this is a subagent session
-                const subagentId = subagentStore.getSubagentIdBySession(session);
-                if (subagentId) {
+                // The currently bound main session always wins. SubagentActivityStore
+                // intentionally retains Session-object mappings for completed cards;
+                // if one of those sessions is later adopted/resumed as the main agent,
+                // checking the stale child mapping first would swallow every main event
+                // (including turn/end) and leave working/cancelPending latched forever.
+                const isMainSession = session === agent.session;
+                const subagentId = isMainSession
+                    ? undefined
+                    : subagentStore.getSubagentIdBySession(session);
+                if (subagentId !== undefined) {
                     subagentStore.onSessionEvent(subagentId, event);
                     if (event.type === 'assistant/chunk') {
                         // Token-rate path (100-300 events/s): the store append stays
@@ -5376,23 +5782,24 @@ ${output}
                     }
                     return;
                 }
-                // Otherwise handle main agent session
-                if (session !== agent.session)
+                // Otherwise handle the bound main-agent session.
+                if (!isMainSession)
                     return;
                 // Observation broker (C-042): maps user/message + assistant/message
                 // into grant-gated envelopes; every other event type is a no-op, and
                 // publish never throws into this arm.
                 messageObserver?.publish(session, event);
-                activityTracker.onSessionEvent(event);
-                // Interrupt quip: an aborted/interrupted turn ends the round; the
-                // comeback copy shows on the next thinking rotation (pi parity).
-                if (event.type === 'turn/end') {
-                    const reason = event.data.reason;
-                    if (reason?.kind === 'aborted' || reason?.kind === 'interrupted') {
-                        activityTracker.onInterrupted();
+                updateWorkingActivity(`session/event:${event.type}`, () => {
+                    activityTracker.onSessionEvent(event);
+                    // Interrupt quip: an aborted/interrupted turn ends the round; the
+                    // comeback copy shows on the next thinking rotation (pi parity).
+                    if (event.type === 'turn/end') {
+                        const reason = event.data.reason;
+                        if (reason?.kind === 'aborted' || reason?.kind === 'interrupted') {
+                            activityTracker.onInterrupted();
+                        }
                     }
-                }
-                renderWorkingActivity();
+                });
                 // Mode-affecting atoms fold into the Shift+Tab mode indicator the
                 // moment they land (whether appended by cycleMode or by hand).
                 const eventType = event.type;
@@ -5519,7 +5926,7 @@ ${output}
                 // is exactly what the column claims.
                 noteBranch(agent.session.id, branch);
                 // Feed the working line so git tools can show ` · git <branch>`.
-                activityTracker.onGitBranch(branch);
+                updateWorkingActivity('git branch', () => activityTracker.onGitBranch(branch));
                 state.emit();
             }
         })
@@ -5591,6 +5998,18 @@ export function sessionCwdMatches(stateCwd, headerCwd, caseInsensitive = process
 function estimateTokens(text) {
     return Math.ceil(text.length / 4);
 }
+/** Whether one stream chunk advances the first-token/decode boundary. */
+function isTokenDelta(chunk) {
+    switch (chunk.type) {
+        case 'text-delta':
+        case 'reasoning-delta':
+            return chunk.text !== '';
+        case 'tool-call-delta':
+            return chunk.argumentsDelta !== '' || chunk.name !== undefined;
+        default:
+            return false;
+    }
+}
 /** Character payload of one token-bearing stream delta for the live fallback. */
 function tokenDeltaChars(chunk) {
     switch (chunk.type) {