@deepseek-harness-tui/dsh-tui 0.8.0 → 0.8.2

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

@@ -26,7 +26,108 @@ import { t } from '../i18n.js';
 import { modeDisplayName, resolveSessionModes } from '../sessionModes.js';
 import { ActivityTracker } from 'dsh-working-activity/status';
 import { attachSessionToWorkspace } from './workspace.js';
-import { createLocalWorkspaceRuntime } from './workspaces.js';
+import { createLocalWorkspaceRuntime, getHostWorkspaceRuntime } from './workspaces.js';
+import { getHostCommandTrees } from './command-trees.js';
+import { getHostSettingsSections } from './settings-sections.js';
+import { getHostSceneRuntime } from './scenes.js';
+import { getHostRenderers } from './renderers.js';
+import { getHostMessageObserver } from './message-observer.js';
+import { dispatchTuiDecision, dispatchTuiNotification, normalizeCancelDecision } from './extension-events.js';
+import { installDecisionGuard } from './decision-guard.js';
+import { commandOwner } from './command-attribution.js';
+import { readGrantStore } from './grants.js';
+import { hasCommandErrorCode, mapCommandError } from './command-errors.js';
+import { pluginsInfoLines } from './plugins-info.js';
+import { cleanRenderText, cleanScalarText } from './sanitize.js';
+/** `tui/input` return normalization: transform/handled/cancel or no opinion.
+ *  A blank `{ text }` rewrite is NOT a decision — it is logged and the chain
+ *  continues so a later veto listener still runs. */
+function normalizeInputDecision(result, warn) {
+    if (result === undefined || result === null || result === false)
+        return undefined;
+    if (typeof result !== 'object') {
+        warn(`a non-object (${typeof result})`);
+        return undefined;
+    }
+    const record = result;
+    if (record.cancel === true) {
+        const reason = cleanScalarText(record.reason, NOTICE_CELLS);
+        return { cancel: true, ...(reason === '' ? {} : { reason }) };
+    }
+    if (record.handled === true) {
+        const notice = cleanScalarText(record.notice, NOTICE_CELLS);
+        return { handled: true, ...(notice === '' ? {} : { notice }) };
+    }
+    if (typeof record.text === 'string') {
+        if (record.text.trim() === '') {
+            warn('a blank {text} rewrite');
+            return undefined;
+        }
+        return { text: record.text };
+    }
+    warn('an unrecognized decision shape');
+    return undefined;
+}
+/** `tui/rewind-prompt` return normalization: cancel/modes or no opinion.
+ *  Modes are COPIED with only validated, sanitized scalar fields — the raw
+ *  plugin object must never reach the render path (a `description: {}` would
+ *  crash ListItem's `.replace`, and control chars would corrupt the pane).
+ *  Notices/reasons are toast-bound plugin text: sanitized too (see
+ *  ./sanitize.js — the one implementation of the render-path contract). */
+function normalizeRewindPromptDecision(result, warn) {
+    if (result === undefined || result === null || result === false)
+        return undefined;
+    if (typeof result !== 'object') {
+        warn(`a non-object (${typeof result})`);
+        return undefined;
+    }
+    const record = result;
+    if (record.cancel === true) {
+        const reason = cleanScalarText(record.reason, NOTICE_CELLS);
+        return { cancel: true, ...(reason === '' ? {} : { reason }) };
+    }
+    if (Array.isArray(record.modes)) {
+        const modes = [];
+        for (const raw of record.modes) {
+            if (modes.length >= 8)
+                break;
+            if (raw === null || typeof raw !== 'object')
+                continue;
+            const candidate = raw;
+            if (typeof candidate.id !== 'string' || candidate.id.trim() === '')
+                continue;
+            const label = typeof candidate.label === 'string' ? cleanRenderText(candidate.label, 120) : '';
+            if (label === '')
+                continue;
+            const description = typeof candidate.description === 'string' && candidate.description.trim() !== ''
+                ? cleanRenderText(candidate.description, 400)
+                : undefined;
+            modes.push({ id: candidate.id, label, ...(description === undefined ? {} : { description }) });
+        }
+        if (modes.length === 0) {
+            warn('an empty or invalid {modes} list');
+            return undefined;
+        }
+        return { modes };
+    }
+    warn('an unrecognized decision shape');
+    return undefined;
+}
+/** Toast-bound plugin text (veto reasons, handled notices, rewind summaries)
+ *  is render-path data too: same sanitization, toast-width cap. */
+const NOTICE_CELLS = 200;
+/** `tui/rewind-done` return normalization: the first non-empty STRING is the
+ *  summary; anything else is not a decision. */
+function normalizeRewindDoneSummary(result, warn) {
+    if (result === undefined || result === null || result === false)
+        return undefined;
+    if (typeof result === 'string') {
+        const summary = cleanRenderText(result, NOTICE_CELLS);
+        return summary === '' ? undefined : summary;
+    }
+    warn('a non-string summary');
+    return undefined;
+}
 /**
  * Delay before re-reading a skill catalog that reported an incomplete
  * observation (a provider whose directory watcher is still warming).
@@ -59,12 +160,25 @@ function preview(text, limit) {
  * a loadOlder() restore is not instantly undone. Returns the number of rows
  * folded.
  */
-function foldRows(rows, cap) {
+function foldRows(rows, cap, cursor) {
     const excess = rows.length - cap;
-    if (excess <= 0)
+    if (excess <= 0) {
+        if (cursor !== undefined)
+            cursor.index = 0;
+        return 0;
+    }
+    // Incremental pass: rows only ever append past the fold line and the
+    // folded/restored exemptions are permanent, so everything below a cursor
+    // over the SAME array identity needs no re-inspection. emit/emitStream
+    // fold on every frame during streaming — a full rescan of a long window
+    // there was the O(rows) per-frame term of long-session streaming.
+    const from = cursor === undefined ? 0 : cursor.rows === rows ? cursor.index : 0;
+    if (cursor !== undefined)
+        cursor.rows = rows;
+    if (excess <= from)
         return 0;
     let folded = 0;
-    for (const row of rows.slice(0, excess)) {
+    for (const row of rows.slice(from, excess)) {
         if (row.folded || row.restored)
             continue;
         if (row.kind !== 'user' && row.kind !== 'assistant' && row.kind !== 'reasoning' && row.kind !== 'tool')
@@ -86,6 +200,8 @@ function foldRows(rows, cap) {
             row.text = preview(row.text, 200);
         }
     }
+    if (cursor !== undefined)
+        cursor.index = excess;
     return folded;
 }
 /**
@@ -214,46 +330,44 @@ function restoreToolResult(row, event) {
     row.tool.resultFull = result || undefined;
 }
 /**
- * Coalesce runs of same-type assistant/chunk deltas into single synthetic
- * events for REPLAY only. A streamed turn logs one event per token (~100k
- * events in long sessions); replaying them one at a time costs per-chunk
- * string growth on every row (quadratic in the turn's length). Merging is
- * outcome-identical: ensureStreaming/ensureReasoning only read chunk.type
- * and the concatenated text, and the row's seq comes from the run's FIRST
- * chunk (the fork boundary rewindTo derives from it). Parts join once —
- * no quadratic concat. Live events never go through this.
+ * Prepare durable events for REPLAY (resume / rewind / model-switch fork):
+ * drop settled `assistant/chunk` stream deltas — the sealed
+ * `assistant/message` events carry the full text and reasoning blocks, so
+ * per-token chunks add nothing to the replayed transcript while costing a
+ * per-chunk renderEvent pass (a real 4.5MB session logs ~19k chunks against
+ * ~30 messages). The trailing chunk run AFTER the last message belongs to an
+ * unfinished step (crash-orphaned turn) and is kept, so a resumed session
+ * still shows its partial content. Storage-level packed rows
+ * (`text-chunks`/`reasoning-chunks`/`tool-call-chunks`) are dropped the
+ * same way — defensive: the jsonl reader expands them, but a future
+ * direct-pass path must not resurrect them. Replay-side tps sampling is
+ * lost with the chunks (a live metric; lastUsage comes from the message's
+ * own usage). Live events never go through this.
  */
-function coalesceReplayEvents(events) {
-    const out = [];
-    let run = null;
-    const flush = () => {
-        if (run === null)
-            return;
-        const chunk = run.event.data.chunk;
-        out.push({
-            ...run.event,
-            data: { ...run.event.data, chunk: { ...chunk, text: run.parts.join('') } },
-        });
-        run = null;
-    };
+function prepareReplayEvents(events) {
+    let lastMessageSeq = -1;
     for (const event of events) {
-        if (event.type === 'assistant/chunk' &&
-            (event.data.chunk.type === 'text-delta' || event.data.chunk.type === 'reasoning-delta')) {
-            if (run !== null && run.type === event.data.chunk.type) {
-                // oxlint-disable-next-line typescript/no-unnecessary-condition -- durable replay data may lack text
-                run.parts.push(event.data.chunk.text ?? '');
-                continue;
-            }
-            flush();
-            // oxlint-disable-next-line typescript/no-unnecessary-condition -- durable replay data may lack text
-            run = { event, type: event.data.chunk.type, parts: [event.data.chunk.text ?? ''] };
-            continue;
-        }
-        flush();
-        out.push(event);
+        if (event.type === 'assistant/message')
+            lastMessageSeq = event.seq;
     }
-    flush();
-    return out;
+    return events.filter(event => {
+        if (event.type === 'assistant/message')
+            return true;
+        if (event.type === 'assistant/chunk') {
+            // Keep only the in-flight tail (no message sealed after it).
+            return lastMessageSeq < 0 || event.seq > lastMessageSeq;
+        }
+        // Storage-level packed rows: not in the SessionEvent union (they exist
+        // only in the durable JSON), so compare through a widened view — the
+        // defensive drop is exactly for data the static type doesn't know.
+        const packedType = event.type;
+        if (packedType === 'text-chunks' ||
+            packedType === 'reasoning-chunks' ||
+            packedType === 'tool-call-chunks') {
+            return false;
+        }
+        return true;
+    });
 }
 /** Buffer below the context window at which CC warns (autoCompact.ts). */
 const CONTEXT_WARNING_BUFFER_TOKENS = 20_000;
@@ -288,18 +402,35 @@ async function waitForTurnEnd(session, fromSeq, timeoutMs) {
 export function createChannel(ctx, initialAgent, options) {
     let agent = initialAgent;
     let currentHandle = options.handle;
+    // D-7 backstop: the extensions row installs the decision-subscription
+    // gate, but the channel IS the dispatch path — a stale patch without that
+    // row (or a bare embed mounting neither) would otherwise leave tui/input
+    // & friends subscribable by default, silently voiding the default-deny
+    // posture. Idempotent per cordis root, so the full-patch path installs
+    // exactly once whichever side runs first. One store instance serves both
+    // the gate and the invoke checkpoint below.
+    // Keep a private fallback for bare embedders, but resolve the host-owned
+    // store on every operation so a plugin-host row mounted later (or a custom
+    // live GrantStore) is not shadowed by an early snapshot.
+    const fallbackGrantStore = readGrantStore();
+    const currentGrantStore = () => ctx.get('tuiPluginHost')?.grants ?? fallbackGrantStore;
+    installDecisionGuard(ctx, currentGrantStore());
     // The DSH slash-command registry (optional service): /plan, /goal and
     // friends register here; the TUI merges their descriptors into the slash
     // menu and dispatches through `execute` (which logs the paired
     // command/run + command/done records). Absent the service, only the
     // built-in local commands exist.
     const commandService = ctx.get('commands');
+    // messages.observe broker (optional service, C-042): mounted by the
+    // dsh-tui-plugin-host row; absent the row, publish is a no-op and nothing
+    // else changes (soft degradation, #183).
+    const messageObserver = getHostMessageObserver(ctx.get('tuiMessageObserver'));
     // Workspace registry runtime (optional service, issue #183): mounted by
     // the bundle patch's dsh-tui-workspaces row; absent the row (stale patch
     // or a bare embedder), degrade to the local-only runtime. plugin.ts owns
     // the degraded-boot warning for profile launches.
-    const workspaceService = ctx.get('tuiWorkspaces') ?? createLocalWorkspaceRuntime();
-    const commandTrees = ctx.get('tuiCommandTrees');
+    const workspaceService = getHostWorkspaceRuntime(ctx.get('tuiWorkspaces')) ?? createLocalWorkspaceRuntime();
+    const commandTrees = getHostCommandTrees(ctx.get('tuiCommandTrees'));
     // The `/settings` screen reads its host on EVERY render, so the host must
     // be a stable object: a fresh literal per call would re-fire the screen's
     // host-keyed effects endlessly (render → new host → effect → state →
@@ -310,7 +441,12 @@ export function createChannel(ctx, initialAgent, options) {
     // Plugin scene runtime (optional service, same degradation rule as
     // tuiWorkspaces/tuiCommandTrees): mounted by the bundle patch's
     // dsh-tui-scenes row; absent the row, `pluginScene` simply stays undefined.
-    const sceneRuntime = ctx.get('tuiScenes');
+    const sceneRuntime = getHostSceneRuntime(ctx.get('tuiScenes'));
+    const settingsSectionsRuntime = getHostSettingsSections(ctx.get('tuiSettingsSections'));
+    // Custom-entry text renderers (optional service, dsh-tui-extensions row):
+    // absent the row, unknown plugin event types stay invisible in the
+    // transcript, exactly as before the seam existed.
+    const rendererRuntime = getHostRenderers(ctx.get('tuiRenderers'));
     // Shift+Tab session-mode cycle: cordis.yml `modes` wins; absent/empty/
     // atom-less → the built-in default/plan/full cycle (sessionModes.ts).
     const { modes: sessionModes, dropped: droppedModeIds } = resolveSessionModes(options.modes);
@@ -320,6 +456,9 @@ export function createChannel(ctx, initialAgent, options) {
     const listeners = new Set();
     /** True while a frame-aligned stream notification is pending (emitStream). */
     let streamNotifyScheduled = false;
+    // 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 };
     let nextNotificationId = 1;
     /** One-shot context-low warning per session (CC's TokenWarning). */
     let contextWarned = false;
@@ -405,6 +544,142 @@ export function createChannel(ctx, initialAgent, options) {
             state.notify(t('send-failed', { err: message }), { color: 'error' });
         });
     };
+    /**
+     * RFC 0005 D-8: a flow parked on a plugin decision must be user-observable.
+     * Decisions normally resolve in milliseconds, so the notice only fires
+     * once the wait crosses a threshold — a slow plugin (e.g. one showing a
+     * managed dialog) then explains the pause instead of looking like the TUI
+     * ate the input.
+     */
+    const DECISION_PENDING_MS = 400;
+    const withDecisionPending = (name, pending) => {
+        let dismiss;
+        const timer = setTimeout(() => {
+            // Sticky (timeoutMs 0), D-8: the indicator must cover the WHOLE wait —
+            // an auto-expiring notice would vanish after ~4s while the decision,
+            // the delivery and every queued FIFO task behind them stay parked,
+            // leaving the user with no sign the flow is still waiting. It comes
+            // down only when the decision settles (finally below); a decision
+            // that never settles keeps its indicator up, which is the truthful
+            // state.
+            dismiss = state.notify(t('ext-decision-pending', { event: name }), { timeoutMs: 0 });
+        }, DECISION_PENDING_MS);
+        // Both exits are covered: a fast decision clears the timer before it
+        // fires; a slow one dismisses the indicator it raised.
+        return pending.finally(() => {
+            clearTimeout(timer);
+            dismiss?.();
+        });
+    };
+    /**
+     * The `tui/input` decision event (pi's `input` seam): the FIRST plugin
+     * returning a valid decision wins — transform the text, mark it handled,
+     * or cancel it. No listeners (or only crashing/malformed ones) means
+     * delivery proceeds unchanged, so a broken plugin can never wedge the
+     * input path — and can never skip a later veto listener either
+     * (dispatchTuiDecision isolates crashes and normalizes returns per
+     * listener instead of bailing on the first object).
+     *
+     * Decision AND delivery enter one FIFO chain in submission order: a slow
+     * listener on A parks A's delivery AND any later submissions behind it —
+     * without the chain, B's decision could resolve first and the model would
+     * receive B before A. Each submission binds its origin agent AT ENQUEUE,
+     * so a session switch landing before OR during its decision drops the
+     * stale text with a notice instead of sending the old conversation's
+     * words to the new session.
+     */
+    let inputChain = Promise.resolve();
+    const runUserTextDecision = async (text, placement, originAgent, originAgentId) => {
+        // Stale detection compares the AGENT REFERENCE, not the id: session ids
+        // are reusable (A → /new → /resume A lands back on the same id with a
+        // fresh agent), so an id check has an ABA hole. Both origin values are
+        // ENQUEUE-time captures (see dispatchUserText): a decision parked behind
+        // a slow predecessor must still be judged against the session its text
+        // was typed in, not whichever session is live when it finally runs.
+        const decision = await withDecisionPending('tui/input', dispatchTuiDecision(ctx, 'tui/input', {
+            text,
+            delivery: placement === 'steer' ? 'steer' : 'followup',
+            sessionId: originAgentId,
+            cwd: state.cwd,
+        }, normalizeInputDecision));
+        if (decision !== undefined) {
+            // Both intercepts toast — a bare {cancel}/{handled} must not make the
+            // typed line vanish silently (the host-localized fallback mirrors the
+            // other decision events' ext-action-cancelled handling).
+            if ('cancel' in decision) {
+                state.notify(decision.reason ?? t('ext-action-cancelled'), { color: 'warning', timeoutMs: 4000 });
+                return;
+            }
+            if ('handled' in decision) {
+                state.notify(decision.notice ?? t('ext-action-handled'), { timeoutMs: 4000 });
+                return;
+            }
+            text = decision.text.trim();
+        }
+        if (agent !== originAgent) {
+            state.notify(t('ext-stale-dropped'), { color: 'warning', timeoutMs: 4000 });
+            return;
+        }
+        deliverUserText(text, placement);
+    };
+    const dispatchUserText = (text, placement) => {
+        // D-6: bind the submission to the session it was typed in AT ENQUEUE
+        // TIME. The FIFO chain may park this task behind a slow predecessor
+        // while the user /new's away — capturing the agent at run time would
+        // adopt the NEW session as this text's origin and deliver the old
+        // conversation's words into it.
+        const originAgent = agent;
+        const originAgentId = state.agentId;
+        inputChain = inputChain.then(() => runUserTextDecision(text, placement, originAgent, originAgentId)).catch((error) => {
+            // The chain must survive a failed decision: log, then continue with
+            // the next queued submission.
+            ctx.logger.warn('dsh-tui: tui/input dispatch failed: %o', error);
+        });
+    };
+    /**
+     * The `tui/session-switch` decision event (pi's `session_before_switch`),
+     * fired before `/new` or `/resume` replaces the live session (rewind has
+     * its own prompt event). The first answering plugin may veto the switch;
+     * the reason is toasted here so the fallback string stays host-localized.
+     */
+    const sessionSwitchVetoed = async (kind, targetSessionId) => {
+        // D-6 stale detection captures the AGENT REFERENCE (session ids are
+        // reusable — ABA): a slow decision must not let an older /resume roll
+        // over a newer session the user already switched to mid-await.
+        const originAgent = agent;
+        const decision = await withDecisionPending('tui/session-switch', dispatchTuiDecision(ctx, 'tui/session-switch', {
+            kind,
+            ...(targetSessionId === undefined ? {} : { targetSessionId }),
+            sessionId: state.agentId,
+            cwd: state.cwd,
+        }, normalizeCancelDecision));
+        if (agent !== originAgent) {
+            // The world changed while the decision parked: drop the pending
+            // switch instead of replacing the user's newer session.
+            state.notify(t('ext-stale-dropped'), { color: 'warning', timeoutMs: 4000 });
+            return true;
+        }
+        if (decision !== undefined) {
+            state.notify(decision.reason ?? t('ext-action-cancelled'), { color: 'warning', timeoutMs: 4000 });
+            return true;
+        }
+        return false;
+    };
+    /** Fire-and-forget `tui/session-switched` (parallel): per-session plugin
+     *  state rebinds here. Listener failures are logged, never propagated —
+     *  the switch itself already succeeded. */
+    const notifySessionSwitched = (kind, sessionId, previousSessionId) => {
+        try {
+            void dispatchTuiNotification(ctx, 'tui/session-switched', { kind, sessionId, previousSessionId, cwd: state.cwd }).catch((error) => {
+                ctx.logger.warn('dsh-tui: tui/session-switched listener failed: %o', error);
+            });
+        }
+        catch (error) {
+            // A bare embedder's context may lack the event bus entirely; the
+            // switch itself already succeeded, so this stays a log line.
+            ctx.logger.warn('dsh-tui: tui/session-switched dispatch failed: %o', error);
+        }
+    };
     /** Monotonic token: only the latest `interruptAndDeliver` re-queues, so a
      *  second interrupt while the abort settles cannot double-deliver. */
     let interruptSeq = 0;
@@ -519,6 +794,45 @@ export function createChannel(ctx, initialAgent, options) {
     const executeRegistryCommand = async (name, rawInput) => {
         if (!commandService)
             return undefined;
+        // Resolve the exact definition that execute() will select for this agent.
+        // Same names may exist in distinct agent scopes, so a name-only lookup can
+        // apply another scope's owner policy.
+        const definition = commandService.find(agent, name);
+        const owner = commandOwner(ctx, definition);
+        // The root checkpoint covers host/direct registrations.  A built-in name
+        // is not necessarily a namespaced contribution id, so use a deterministic
+        // host scope for that case; legacy unscoped denies still conservatively
+        // revoke every valid command scope.
+        const rootScope = owner?.commandId
+            ?? (/^[a-z][a-z0-9]*(?:[.-][a-z0-9][a-z0-9-]*)+$/u.test(name)
+                ? name
+                : `dsh-tui.${name.toLowerCase().replace(/[^a-z0-9-]+/gu, '-').replace(/^-+|-+$/gu, '') || 'command'}`);
+        if (!currentGrantStore().allows({ componentId: 'root' }, 'commands.invoke', rootScope)) {
+            ctx.logger.warn('dsh-tui: registry command invocation denied (commands.invoke revoked for "root" in the grants file)');
+            ctx.get('tuiEffectLedger')?.record({
+                operation: 'bind',
+                resource: { kind: 'permission', id: `root:commands.invoke:${rootScope}` },
+                result: 'failed',
+                errorCode: 'PERMISSION_NOT_GRANTED',
+            }, ctx);
+            return t('command-invoke-denied');
+        }
+        // Per-owner gate (C-041): a command REGISTERED BY A PLUGIN through the
+        // plugin-host row's mediated registerCommand (see command-attribution.js)
+        // is additionally gated on the OWNER's grant, so a denies entry for the
+        // plugin closes the host-mediated invocation of ITS commands.
+        // Unattributed host/direct registrations remain inside the documented
+        // trusted-in-process boundary and have no plugin grant to evaluate.
+        if (owner !== undefined && !currentGrantStore().allows({ componentId: owner.componentId, activationId: owner.activationId }, 'commands.invoke', owner.commandId)) {
+            ctx.logger.warn(`dsh-tui: registry command "/${name}" invocation denied — owner Component "${owner.componentId}" lost commands.invoke for "${owner.commandId}"`);
+            ctx.get('tuiEffectLedger')?.record({
+                operation: 'bind',
+                resource: { kind: 'permission', id: `${owner.componentId}:commands.invoke:${owner.commandId}` },
+                result: 'failed',
+                errorCode: 'PERMISSION_NOT_GRANTED',
+            }, ctx);
+            return t('command-invoke-denied-owner', { name, owner: owner.componentId });
+        }
         try {
             const execution = await commandService.execute(agent, `/${name}${rawInput}`, new AbortController().signal);
             // `undefined` = not registered; a handler error surfaces as its
@@ -653,6 +967,7 @@ export function createChannel(ctx, initialAgent, options) {
         workingActivity: undefined,
         activityFrames: options.activityFrames,
         diffLayout: options.diffLayout ?? 'auto',
+        thinkingFold: options.thinkingFold ?? 'preview',
         activityEnabled: options.activity !== false,
         contextBarEnabled: options.contextBar !== false,
         agentPreset: options.agentPreset,
@@ -701,7 +1016,7 @@ export function createChannel(ctx, initialAgent, options) {
             };
         },
         emit() {
-            foldRows(state.rows, MAX_ROWS);
+            foldRows(state.rows, MAX_ROWS, foldCursor);
             state.version += 1;
             for (const listener of listeners)
                 listener();
@@ -719,7 +1034,7 @@ export function createChannel(ctx, initialAgent, options) {
             streamNotifyScheduled = true;
             const timer = setTimeout(() => {
                 streamNotifyScheduled = false;
-                foldRows(state.rows, MAX_ROWS);
+                foldRows(state.rows, MAX_ROWS, foldCursor);
                 for (const listener of listeners)
                     listener();
             }, 16);
@@ -778,7 +1093,7 @@ export function createChannel(ctx, initialAgent, options) {
             // The current session is being used — move it to the MRU front
             // (/resume sorts by last-used).
             touchSession(state.agentId);
-            deliverUserText(trimmed, 'followup');
+            void dispatchUserText(trimmed, 'followup');
         },
         /** Steer a message into the RUNNING turn (Codex/pi semantics): it is
          *  injected at the next step boundary of the current turn and the agent
@@ -788,11 +1103,13 @@ export function createChannel(ctx, initialAgent, options) {
             if (!trimmed)
                 return;
             touchSession(state.agentId);
-            // Official dsh-agent rc.6: steer() is synchronous void — the message
-            // enters the next-step inbox. A rejected step leaves it parked for the
-            // next wake; the inbox events below retire the preview (claimed →
-            // turn boundary, discarded → cancel).
-            deliverUserText(trimmed, 'steer');
+            // Same tui/input decision pass as submit; the delivery re-validates
+            // the live agent after the await. Official dsh-agent rc.6: steer() is
+            // synchronous void — the message enters the next-step inbox; a
+            // rejected step leaves it parked for the next wake, and the inbox
+            // events retire the preview (claimed → turn boundary, discarded →
+            // cancel).
+            void dispatchUserText(trimmed, 'steer');
         },
         /** Pull a pending message back out of the inbox (Alt+Up): it returns to
          *  the input for editing instead of being delivered. */
@@ -838,7 +1155,10 @@ export function createChannel(ctx, initialAgent, options) {
                     return;
                 for (const text of queued) {
                     touchSession(state.agentId);
-                    deliverUserText(text, 'followup');
+                    // Same tui/input decision pass as a typed submit: Ctrl+Enter must
+                    // not bypass a plugin's cancel/transform policy, and re-queued
+                    // texts keep submission order through the one FIFO chain.
+                    dispatchUserText(text, 'followup');
                 }
             };
             if (typeof whenIdle === 'function') {
@@ -851,7 +1171,43 @@ export function createChannel(ctx, initialAgent, options) {
             }
             return queued.length;
         },
-        async rewindTo(row) {
+        /**
+         * The `tui/rewind-prompt` decision event (pi's `session_before_fork`):
+         * fired when the rewind picker confirms a message, before any fork
+         * work. The first answering plugin may cancel the rewind (the picker
+         * stays open; the reason is toasted here so the UI string stays
+         * host-localized when absent) or offer extra modes rendered in the
+         * confirm pane. Returns 'cancel', the modes, or null for "no opinion".
+         */
+        async promptRewind(row) {
+            if (row.seq === undefined)
+                return null;
+            // D-6, same as the other decision points: a slow /new or /resume can
+            // replace the agent while this decision parks. Without the identity
+            // check the picker would go on to show the OLD session's row in the
+            // confirm pane and rewindTo would cut the NEW session at the old
+            // seq — a wrong rewind or a fork failure. Compare agent REFERENCES
+            // (session ids are reusable — ABA) and stale-cancel.
+            const originAgent = agent;
+            const decision = await withDecisionPending('tui/rewind-prompt', dispatchTuiDecision(ctx, 'tui/rewind-prompt', {
+                text: row.text,
+                seq: row.seq,
+                sessionId: state.agentId,
+                cwd: state.cwd,
+            }, normalizeRewindPromptDecision));
+            if (agent !== originAgent) {
+                state.notify(t('ext-stale-dropped'), { color: 'warning', timeoutMs: 4000 });
+                return 'cancel';
+            }
+            if (decision === undefined)
+                return null;
+            if ('cancel' in decision) {
+                state.notify(decision.reason ?? t('ext-action-cancelled'), { color: 'warning', timeoutMs: 4000 });
+                return 'cancel';
+            }
+            return { modes: decision.modes };
+        },
+        async rewindTo(row, mode = null) {
             if (row.seq === undefined)
                 return null;
             const sessions = ctx.get('sessions');
@@ -947,6 +1303,10 @@ export function createChannel(ctx, initialAgent, options) {
             // counters land back at the rewind point, matching the fork).
             streaming = undefined;
             reasoning = undefined;
+            // Stale sealed/thinking bookkeeping belongs to the OLD agent's rows;
+            // keep it out of the next turn's settle logs and revive cache.
+            sealedReasoning.length = 0;
+            lastReasoningRow = undefined;
             toolCards.clear();
             nextRowId = 0;
             state.rows.length = 0;
@@ -980,10 +1340,16 @@ export function createChannel(ctx, initialAgent, options) {
                 thinking: 0,
                 tools: 0,
             };
-            for (const event of coalesceReplayEvents(seed))
-                renderEvent(event);
+            replayEvents(seed);
+            settleStreaming();
+            // A seed ending mid-turn replays a turn/start that set working=true;
+            // the boot path resets this after replay — mirror it here so an idle
+            // rewound agent doesn't sit with a live spinner (a still-running
+            // agent re-asserts on its next event).
+            state.working = handle.agent.status === 'running';
             // Rebind subscriptions to the new agent, then free the old one.
             const oldHandle = currentHandle;
+            const sourceSessionId = String(agent.session.id);
             agent = handle.agent;
             currentHandle = handle;
             bindAgent();
@@ -994,6 +1360,43 @@ export function createChannel(ctx, initialAgent, options) {
             touchSession(childId);
             state.emit();
             void oldHandle?.dispose().catch(() => { });
+            // Decision-event pair around the completed rewind: `tui/rewind-done`
+            // (the first non-empty string is toasted as the post-rewind summary,
+            // e.g. a plugin reporting restored files) and the generic
+            // `tui/session-switched` notification. Listener failures are logged,
+            // never surfaced — the rewind itself already succeeded.
+            //
+            // rewind-done is a post-hoc summary, NOT a gate, so it is dispatched
+            // DECOUPLED from the return value: the picker is already closed and
+            // PromptInput is live — awaiting a slow listener here would delay the
+            // picked text's return to the draft, letting its late arrival
+            // overwrite whatever the user typed meanwhile, and a listener that
+            // never settles would park tui/session-switched forever. The summary
+            // toasts whenever it lands.
+            try {
+                void dispatchTuiDecision(ctx, 'tui/rewind-done', {
+                    text: row.text,
+                    mode,
+                    boundarySeq: boundary,
+                    sourceSessionId,
+                    childSessionId: String(childId),
+                    sessionId: String(childId),
+                    cwd: state.cwd,
+                }, normalizeRewindDoneSummary)
+                    .then(summary => {
+                    if (summary !== undefined)
+                        state.notify(summary, { timeoutMs: 6000 });
+                })
+                    .catch((error) => {
+                    ctx.logger.warn('dsh-tui: tui/rewind-done dispatch failed: %o', error);
+                });
+            }
+            catch (error) {
+                // A bare embedder's context may lack the event bus entirely; the
+                // rewind itself already succeeded, so this stays a log line.
+                ctx.logger.warn('dsh-tui: tui/rewind-done dispatch failed: %o', error);
+            }
+            notifySessionSwitched('rewind', String(childId), sourceSessionId);
             return row.text;
         },
         async resumeTo(sessionId) {
@@ -1002,13 +1405,18 @@ export function createChannel(ctx, initialAgent, options) {
             // resolving through DSH_TUI_RESUME_SESSION at boot).
             if (state.working) {
                 state.notify(t('resume-while-working'), { color: 'warning' });
-                return false;
+                return { ok: false, reason: 'working' };
             }
             const agents = ctx.get('agents');
             if (!agents) {
                 state.notify(t('resume-unavailable'), { color: 'error' });
-                return false;
+                return { ok: false, reason: 'unavailable' };
             }
+            // Plugin veto point (tui/session-switch): before any read of the
+            // target — a veto leaves the live session and its transcript
+            // untouched.
+            if (await sessionSwitchVetoed('resume', sessionId))
+                return { ok: false, reason: 'cancelled' };
             let handle;
             // Compat boundary: register vouched-for legacy event types (e.g.
             // activity/status from pre-#143 logs) in every reachable dsh-session
@@ -1039,7 +1447,7 @@ export function createChannel(ctx, initialAgent, options) {
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
                 state.notify(t('resume-failed', { err: message }), { color: 'error', timeoutMs: 8000 });
-                return false;
+                return { ok: false, reason: 'failed', error: message };
             }
             try {
                 // `/resume` is an explicit adoption of this persisted conversation.
@@ -1054,6 +1462,10 @@ export function createChannel(ctx, initialAgent, options) {
             // rewindTo, plus the context window which the replay re-derives).
             streaming = undefined;
             reasoning = undefined;
+            // Stale sealed/thinking bookkeeping belongs to the OLD agent's rows;
+            // keep it out of the next turn's settle logs and revive cache.
+            sealedReasoning.length = 0;
+            lastReasoningRow = undefined;
             toolCards.clear();
             nextRowId = 0;
             state.rows.length = 0;
@@ -1106,11 +1518,15 @@ export function createChannel(ctx, initialAgent, options) {
                 thinking: 0,
                 tools: 0,
             };
-            for (const event of coalesceReplayEvents(handle.agent.session.events))
-                renderEvent(event);
+            replayEvents(handle.agent.session.events);
             settleStreaming();
+            // A log ending mid-turn replays a turn/start that set working=true;
+            // mirror the boot path's post-replay reset (a still-running agent
+            // re-asserts on its next event).
+            state.working = handle.agent.status === 'running';
             // Rebind subscriptions to the resumed agent, then free the old one.
             const oldHandle = currentHandle;
+            const previousSessionId = String(agent.session.id);
             agent = handle.agent;
             currentHandle = handle;
             bindAgent();
@@ -1124,7 +1540,8 @@ export function createChannel(ctx, initialAgent, options) {
             state.emit();
             void oldHandle?.dispose().catch(() => { });
             clearStagedImages();
-            return true;
+            notifySessionSwitched('resume', sessionId, previousSessionId);
+            return { ok: true };
         },
         async newSession() {
             // `/new` — start a fresh conversation: brand-new agent + session, the
@@ -1143,6 +1560,10 @@ export function createChannel(ctx, initialAgent, options) {
                 });
                 return false;
             }
+            // Plugin veto point (tui/session-switch): no side effects have
+            // happened yet — the session id below is not even allocated.
+            if (await sessionSwitchVetoed('new'))
+                return false;
             const sessionId = SessionId(randomUUID());
             let handle;
             // A fresh session composes the caller's DEFAULT preset: the cordis.yml
@@ -1197,6 +1618,10 @@ export function createChannel(ctx, initialAgent, options) {
             }
             streaming = undefined;
             reasoning = undefined;
+            // Stale sealed/thinking bookkeeping belongs to the OLD agent's rows;
+            // keep it out of the next turn's settle logs and revive cache.
+            sealedReasoning.length = 0;
+            lastReasoningRow = undefined;
             toolCards.clear();
             nextRowId = 0;
             state.rows.length = 0;
@@ -1234,6 +1659,7 @@ export function createChannel(ctx, initialAgent, options) {
                 tools: 0,
             };
             const oldHandle = currentHandle;
+            const previousSessionId = String(agent.session.id);
             agent = handle.agent;
             currentHandle = handle;
             bindAgent();
@@ -1245,6 +1671,7 @@ export function createChannel(ctx, initialAgent, options) {
             touchSession(handle.agent.id);
             void oldHandle?.dispose().catch(() => { });
             clearStagedImages();
+            notifySessionSwitched('new', String(handle.agent.id), previousSessionId);
             return true;
         },
         listWorkspaces() {
@@ -1368,6 +1795,10 @@ export function createChannel(ctx, initialAgent, options) {
             }
             streaming = undefined;
             reasoning = undefined;
+            // Stale sealed/thinking bookkeeping belongs to the OLD agent's rows;
+            // keep it out of the next turn's settle logs and revive cache.
+            sealedReasoning.length = 0;
+            lastReasoningRow = undefined;
             toolCards.clear();
             nextRowId = 0;
             state.rows.length = 0;
@@ -1404,9 +1835,10 @@ export function createChannel(ctx, initialAgent, options) {
                 thinking: 0,
                 tools: 0,
             };
-            for (const event of coalesceReplayEvents(seed))
-                renderEvent(event);
+            replayEvents(seed);
             settleStreaming();
+            // Same mid-turn-seed spinner reset as resume above.
+            state.working = handle.agent.status === 'running';
             const oldHandle = currentHandle;
             agent = handle.agent;
             currentHandle = handle;
@@ -1456,13 +1888,24 @@ export function createChannel(ctx, initialAgent, options) {
             };
             state.notifications.push(item);
             state.emit();
-            setTimeout(() => {
+            const remove = () => {
                 const index = state.notifications.indexOf(item);
                 if (index >= 0) {
                     state.notifications.splice(index, 1);
                     state.emit();
                 }
-            }, item.timeoutMs);
+            };
+            // timeoutMs 0 = sticky: no expiry timer, the dismiss handle is the
+            // only way out (a decision-parked indicator must outlive the wait it
+            // describes — auto-expiring it would hide a still-parked flow, D-8).
+            const expire = item.timeoutMs > 0 ? setTimeout(remove, item.timeoutMs) : undefined;
+            // Early-dismiss handle for flows that know their notice went stale
+            // (e.g. a decision-parked indicator whose decision just landed).
+            return () => {
+                if (expire !== undefined)
+                    clearTimeout(expire);
+                remove();
+            };
         },
         setDiffLayout(layout) {
             if (layout === state.diffLayout)
@@ -1470,6 +1913,12 @@ export function createChannel(ctx, initialAgent, options) {
             state.diffLayout = layout;
             state.emit();
         },
+        setThinkingFold(mode) {
+            if (mode === state.thinkingFold)
+                return;
+            state.thinkingFold = mode;
+            state.emit();
+        },
         setActivityFrames(name) {
             if (!isPresetName(name)) {
                 state.notify(t('unknown-activity-preset', { name }), { color: 'error' });
@@ -1650,12 +2099,10 @@ export function createChannel(ctx, initialAgent, options) {
             return settingsHostCache;
         },
         settingsSections() {
-            const sections = ctx.get('tuiSettingsSections');
-            return sections?.list() ?? [];
+            return settingsSectionsRuntime?.list() ?? [];
         },
         subscribeSettingsSections(listener) {
-            const sections = ctx.get('tuiSettingsSections');
-            return sections?.subscribe(listener) ?? (() => { });
+            return settingsSectionsRuntime?.subscribe(listener) ?? (() => { });
         },
         providerSetup() {
             // The `/provider` wizard's runtime surface, over the dsh-base seams:
@@ -1839,16 +2286,49 @@ export function createChannel(ctx, initialAgent, options) {
                 state.notify(t('compact-while-working'), { color: 'warning' });
                 return;
             }
-            const signal = new AbortController().signal;
-            state.notify(t('compact-working'));
-            void compactService
-                .compactNow(agent, signal)
-                .then((result) => {
-                state.notify(result ? t('compact-done') : t('compact-nothing'));
-            })
-                .catch((error) => {
-                state.notify(t('compact-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
-            });
+            // Plugin veto point (tui/compact): the first answering plugin may
+            // cancel the compaction before anything runs.
+            const originAgentId = state.agentId;
+            // Compare the AGENT REFERENCE after the await, not the id — session
+            // ids are reusable (A → /new → /resume A returns the same id on a new
+            // agent), so an id comparison has an ABA hole that would hand the new
+            // agent to the OLD scope's compaction service.
+            const originAgent = agent;
+            void (async () => {
+                const decision = await withDecisionPending('tui/compact', dispatchTuiDecision(ctx, 'tui/compact', {
+                    sessionId: originAgentId,
+                    cwd: state.cwd,
+                }, normalizeCancelDecision));
+                if (decision !== undefined) {
+                    state.notify(decision.reason ?? t('ext-action-cancelled'), { color: 'warning', timeoutMs: 4000 });
+                    return;
+                }
+                // Stale-drop (same rule as tui/input): the await parked us while the
+                // user switched sessions — `compactService` was resolved through the
+                // OLD agent's scope chain, and the mutable `agent` now points at the
+                // new session. Running now would hand the new agent to the old
+                // service (or call into an unloaded one).
+                if (agent !== originAgent) {
+                    state.notify(t('ext-compact-stale'), { color: 'warning', timeoutMs: 4000 });
+                    return;
+                }
+                if (state.working) {
+                    // The await above gave a queued turn time to start; compacting
+                    // mid-turn now would be the same race the check upfront avoided.
+                    state.notify(t('compact-while-working'), { color: 'warning' });
+                    return;
+                }
+                const signal = new AbortController().signal;
+                state.notify(t('compact-working'));
+                void compactService
+                    .compactNow(agent, signal)
+                    .then((result) => {
+                    state.notify(result ? t('compact-done') : t('compact-nothing'));
+                })
+                    .catch((error) => {
+                    state.notify(t('compact-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+                });
+            })();
         },
         runExternalCommand(name, rawInput) {
             return executeRegistryCommand(name, rawInput);
@@ -2017,8 +2497,23 @@ export function createChannel(ctx, initialAgent, options) {
             if (existsSync(LEGACY_DATA_DIR)) {
                 lines.push(t('doctor-legacy-dir'));
             }
+            // Plugin-spec diagnostics (v0.15): the runtime generation and the
+            // vendored registry self-check, both soft-probed (#183 discipline).
+            const pluginHost = ctx.get('tuiPluginHost');
+            lines.push(t('doctor-plugin-generation', { id: pluginHost?.generationId ?? t('doctor-plugin-host-missing') }));
+            const violations = pluginHost?.selfCheck();
+            lines.push(t('doctor-plugin-registry', {
+                state: violations === undefined ? t('doctor-plugin-host-missing') : violations.length === 0 ? '✓' : `✗ ${violations.length}`,
+            }));
             return lines;
         },
+        pluginsInfo(args) {
+            const host = ctx.get('tuiPluginHost');
+            return pluginsInfoLines(args, {
+                grants: host?.grants ?? currentGrantStore(),
+                host: host?.describe(),
+            });
+        },
         async listSubagents() {
             const subagents = ctx.get('subagents');
             if (!subagents)
@@ -2372,10 +2867,21 @@ export function createChannel(ctx, initialAgent, options) {
                     },
                 });
                 skillCommands.set(name, { dispose, description });
+                ctx.get('tuiEffectLedger')?.record({ operation: 'create', resource: { kind: 'command', id: name }, result: 'applied' }, ctx);
             }
             catch (error) {
+                // C-041: a duplicate registration arrives as a plain-message Error
+                // from dsh-commands; map it onto the contract code before handling
+                // (the refusal path itself is unchanged).
+                const mapped = mapCommandError(error);
                 skillCommandsRefused.add(name);
-                ctx.logger.warn(`skill commands: "${name}" not registrable: %o`, error);
+                ctx.logger.warn(`skill commands: "${name}" not registrable%s: %o`, hasCommandErrorCode(mapped, 'DUPLICATE_CONTRIBUTION_ID') ? ' (DUPLICATE_CONTRIBUTION_ID)' : '', mapped);
+                ctx.get('tuiEffectLedger')?.record({
+                    operation: 'create',
+                    resource: { kind: 'command', id: name },
+                    result: 'failed',
+                    errorCode: hasCommandErrorCode(mapped, 'DUPLICATE_CONTRIBUTION_ID') ? 'DUPLICATE_CONTRIBUTION_ID' : 'COMMAND_FAILED',
+                }, ctx);
             }
         }
     };
@@ -2541,16 +3047,60 @@ ${output}
         }
         return streaming;
     };
-    const ensureReasoning = (seq) => {
+    /** Latest reasoning row keyed by its (turn, step) — lets a resumed
+     *  mid-step stream REVIVE the row the replay sealed (crash-orphan tail:
+     *  replay folds the partial row, live continuation chunks would
+     *  otherwise open a SECOND row for the same step, splitting one
+     *  thinking block in two). */
+    let lastReasoningRow;
+    const ensureReasoning = (seq, turn, step) => {
         if (reasoning === undefined) {
+            // Same-step revive: the sealed row is this step's thinking — continue
+            // it (durationMs carried over via reasoningStart back-dating).
+            if (lastReasoningRow !== undefined &&
+                turn !== undefined &&
+                lastReasoningRow.turn === turn &&
+                lastReasoningRow.step === step) {
+                reasoning = lastReasoningRow.row;
+                reasoning.streaming = true;
+                const sealedIdx = sealedReasoning.indexOf(reasoning);
+                if (sealedIdx !== -1)
+                    sealedReasoning.splice(sealedIdx, 1);
+                reasoningStart = Date.now() - (reasoning.durationMs ?? 0);
+                logForDebugging('thinking: revived sealed reasoning row for same step');
+                return reasoning;
+            }
             reasoningStart = Date.now();
             reasoning = { id: nextRowId, kind: 'reasoning', text: '', streaming: true, ...seq !== undefined ? { seq } : {} };
             nextRowId += 1;
             state.rows.push(reasoning);
             logForDebugging('thinking: reasoning row open (expanded)');
         }
+        if (turn !== undefined && step !== undefined) {
+            lastReasoningRow = { row: reasoning, turn, step };
+        }
         return reasoning;
     };
+    /** Fold the live reasoning preview the moment the model moves PAST
+     *  thinking — the answer's first text token or a tool call — not at
+     *  `assistant/message` (end of step). A long reply pushes the thinking
+     *  block into terminal scrollback long before the message seals, and
+     *  scrollback rows cannot be repainted (the cursor cannot reach them),
+     *  so a late fold leaves a stale unfolded preview frozen above the
+     *  window — the user scrolls up and the thinking looks "not folded".
+     *  Folding while the block still sits in the live window keeps the
+     *  shrink inside the diff engine's reachable region. Preview mode only
+     *  (`full` holds every block open until turn settle by design). */
+    const foldLiveReasoning = (where) => {
+        if (reasoning === undefined || state.thinkingFold !== 'preview')
+            return;
+        const duration = Math.max(0, Date.now() - reasoningStart);
+        reasoning.durationMs = duration;
+        reasoning.streaming = false;
+        sealedReasoning.push(reasoning);
+        reasoning = undefined;
+        logForDebugging(`thinking: folded at ${where} (${duration}ms)`);
+    };
     const settleStreaming = () => {
         if (streaming !== undefined)
             streaming.streaming = false;
@@ -2616,6 +3166,24 @@ ${output}
             };
         }
     };
+    /** True while the durable transcript is being replayed (boot /resume /
+     *  rewind / model-switch fork). The assistant/message reasoning-rebuild
+     *  branch below must run ONLY on this path: in a live stream the chunks
+     *  already created the reasoning row, and foldLiveReasoning clears the
+     *  `reasoning` handle before assistant/message arrives — so
+     *  `reasoning === undefined` alone cannot tell replay from live, and
+     *  using it would rebuild a second thinking block per step. */
+    let replaying = false;
+    const replayEvents = (events) => {
+        replaying = true;
+        try {
+            for (const event of prepareReplayEvents(events))
+                renderEvent(event);
+        }
+        finally {
+            replaying = false;
+        }
+    };
     const renderEvent = (event) => {
         switch (event.type) {
             case 'user/message': {
@@ -2697,13 +3265,18 @@ ${output}
                 const chunk = event.data.chunk;
                 if (chunk.type === 'text-delta') {
                     if (chunk.text) {
+                        // Fold the thinking preview while it is still in the live
+                        // window (see foldLiveReasoning) — before this text grows the
+                        // transcript and pushes the block into scrollback.
+                        foldLiveReasoning('first text token');
                         ensureStreaming(event.seq).text += chunk.text;
                         state.responseChars += chunk.text.length;
                     }
                 }
                 else if (chunk.type === 'reasoning-delta') {
-                    if (chunk.text)
-                        ensureReasoning(event.seq).text += chunk.text;
+                    if (chunk.text) {
+                        ensureReasoning(event.seq, event.data.turn, event.data.step).text += chunk.text;
+                    }
                 }
                 const step = tpsStep;
                 if (step !== undefined &&
@@ -2724,6 +3297,30 @@ ${output}
             }
             case 'assistant/message': {
                 const text = textOf(event.data.message.content);
+                // Replay without chunk deltas (prepareReplayEvents drops settled
+                // ones): rebuild the reasoning row from the sealed message's
+                // reasoning blocks. Replay-only — gated on the `replaying` flag,
+                // not on `reasoning === undefined`: a live stream's chunks already
+                // created the row, and foldLiveReasoning has cleared the `reasoning`
+                // handle by the time this event lands, so the undefined check alone
+                // would rebuild a duplicate thinking block per step. Pushed BEFORE
+                // the assistant row so the transcript order matches the live
+                // stream; settled (folded) immediately, durationMs unknown without
+                // a live clock.
+                if (replaying && reasoning === undefined) {
+                    const reasoningText = event.data.message.content
+                        .map(block => (block.type === 'reasoning' ? block.text : ''))
+                        .join('');
+                    if (reasoningText !== '') {
+                        state.rows.push({
+                            id: nextRowId,
+                            kind: 'reasoning',
+                            text: reasoningText,
+                            seq: event.seq,
+                        });
+                        nextRowId += 1;
+                    }
+                }
                 // Reasoning/tool-only steps emit no text: creating an assistant row
                 // anyway leaves an empty `●` bullet in the transcript. A pre-existing
                 // streaming row always has text (ensureStreaming is only reached on
@@ -2737,10 +3334,16 @@ ${output}
                 }
                 streaming = undefined;
                 if (reasoning !== undefined) {
-                    // Seal, don't fold: the per-step duration settles here, but the
-                    // row keeps streaming=true (expanded) until turn/end — WebUI
-                    // keepOpen parity. The next step's reasoning opens a fresh row.
+                    // Backstop fold: reasoning whose step ended with no text token
+                    // and no tool call (foldLiveReasoning handles those earlier —
+                    // while the block is still in the repaintable live window;
+                    // here a long reply may already have pushed it into scrollback,
+                    // where the shrink cannot be repainted). `full` mode
+                    // (/settings opt-in) keeps the block expanded until turn settle
+                    // — settleStreaming folds the sealed rows then.
                     reasoning.durationMs = Math.max(0, Date.now() - reasoningStart);
+                    if (state.thinkingFold === 'preview')
+                        reasoning.streaming = false;
                     sealedReasoning.push(reasoning);
                     logForDebugging(`thinking: step sealed (${reasoning.durationMs}ms), expanded until turn/end`);
                 }
@@ -2809,6 +3412,10 @@ ${output}
                 // no card is a no-op below.
                 if (event.data.name === 'ask_user_question')
                     break;
+                // Reasoning that led to a tool call is done thinking — fold the
+                // preview now, before the tool card grows the transcript past it
+                // (see foldLiveReasoning).
+                foldLiveReasoning('tool call');
                 const card = {
                     id: nextRowId,
                     kind: 'tool',
@@ -2976,13 +3583,36 @@ ${output}
                         text: t('agent-preset-switched', { preset: data.agentPreset ?? 'unknown' }),
                     });
                     nextRowId += 1;
+                    break;
+                }
+                // Custom plugin events (tuiRenderers seam): a registered renderer
+                // maps the payload to text rows — title as a local row, body as
+                // preview-clipped local-output rows, same shape pushLocal uses.
+                // Runs on the live stream AND on replay (resume/rewind), so the
+                // projection must stay total; the runtime isolates renderer
+                // crashes per type.
+                if (rendererRuntime !== undefined) {
+                    const rendered = rendererRuntime.render(event.type, event.data);
+                    if (rendered !== undefined) {
+                        if (rendered.title !== undefined && rendered.title !== '') {
+                            state.rows.push({ id: nextRowId, kind: 'local', text: rendered.title });
+                            nextRowId += 1;
+                        }
+                        for (const line of rendered.lines) {
+                            state.rows.push({
+                                id: nextRowId,
+                                kind: 'local-output',
+                                text: preview(String(line), LOCAL_OUTPUT_LIMIT),
+                            });
+                            nextRowId += 1;
+                        }
+                    }
                 }
                 break;
         }
     };
     // Replay the durable transcript first, then follow live events.
-    for (const event of coalesceReplayEvents(agent.session.events))
-        renderEvent(event);
+    replayEvents(agent.session.events);
     settleStreaming();
     // Attached to an idle agent: any replayed turn/start belongs to a previous
     // session run, so the spinner must not come up on boot.
@@ -3113,6 +3743,10 @@ ${output}
             ctx.on('session/event', (session, event) => {
                 if (session !== agent.session)
                     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);
                 renderWorkingActivity();
                 // Mode-affecting atoms fold into the Shift+Tab mode indicator the
@@ -3274,47 +3908,60 @@ function usageOutputTokens(usage) {
         : undefined;
 }
 /**
- * Recursive `@` file listing through the leaf's fs service (dsh-fs-local):
- * walks up to MAX_DEPTH levels below `root`, skipping VCS/dependency dirs,
- * returning relative paths (directories with a trailing `/`, matching the
- * FileSuggestions tag logic) capped at MAX_FILES entries. Best-effort —
- * unreadable subtrees are skipped, not fatal.
+ * `@` file listing through the leaf's fs service (dsh-fs-local): skips
+ * VCS/dependency/build dirs and rotates across directory listings so one
+ * large subtree cannot consume the global MAX_FILES budget. That budget also
+ * bounds directory reads without imposing an arbitrary source-tree depth.
+ * Relative directories retain the trailing `/` that FileSuggestions expects.
+ * Unreadable subtrees are skipped, not fatal.
  */
 async function listFilesDeep(fs, root) {
     if (!fs)
         return [];
     const out = [];
-    const SKIP = new Set(['node_modules', '.git', '.hg', '.svn', '.DS_Store', 'dist', 'build']);
-    const MAX_DEPTH = 3;
+    const SKIP = new Set(['node_modules', '.git', '.hg', '.svn', '.DS_Store', 'dist']);
+    const BUILD_DIR = /^(?:build(?:[-_].*)?|cmake-build(?:[-_].*)?)$/i;
     const MAX_FILES = 100;
-    const walk = async (dir, prefix, depth) => {
-        if (depth > MAX_DEPTH || out.length >= MAX_FILES)
-            return;
-        let entries = [];
-        try {
-            const target = await fs.resolve(dir);
-            entries = await fs.listDir(target);
-        }
-        catch {
-            return; // unreadable subtree — skip
+    const directories = [{ dir: root, prefix: '', index: 0 }];
+    while (directories.length > 0 && out.length < MAX_FILES) {
+        const current = directories.shift();
+        if (!current)
+            continue;
+        if (!current.entries) {
+            try {
+                const target = await fs.resolve(current.dir);
+                current.entries = await fs.listDir(target);
+            }
+            catch {
+                continue; // unreadable subtree — skip
+            }
         }
-        for (const entry of entries) {
-            if (out.length >= MAX_FILES)
-                return;
-            if (SKIP.has(entry.name))
+        let entry;
+        while (current.index < current.entries.length) {
+            const candidate = current.entries[current.index++];
+            if (SKIP.has(candidate.name) || BUILD_DIR.test(candidate.name))
                 continue;
-            const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-            if (entry.type === 'directory') {
-                out.push(`${rel}/`);
+            entry = candidate;
+            break;
+        }
+        if (!entry)
+            continue;
+        if (current.index < current.entries.length)
+            directories.push(current);
+        const rel = current.prefix ? `${current.prefix}/${entry.name}` : entry.name;
+        if (entry.type === 'directory') {
+            out.push(`${rel}/`);
+            directories.push({
                 // oxlint-disable-next-line typescript/no-unnecessary-condition -- runtime guard: symlink targets optional
-                await walk(entry.target?.displayPath ?? join(dir, entry.name), rel, depth + 1);
-            }
-            else if (entry.type === 'file') {
-                out.push(rel);
-            }
+                dir: entry.target?.displayPath ?? join(current.dir, entry.name),
+                prefix: rel,
+                index: 0,
+            });
         }
-    };
-    await walk(root, '', 1);
+        else if (entry.type === 'file') {
+            out.push(rel);
+        }
+    }
     return out;
 }
 /** One attached file's contribution is capped so an absent-minded `@` of a