@agi-fans/dsh-tui 0.17.0 → 0.19.0

package/lib/runtime/provider-local.js

@@ -13,10 +13,14 @@
 import { TerminalNotificationController, terminalNotificationSequence, terminalProgressSequence, } from "./terminal-notifications.js";
 import { HerdrAgentReporter } from "./herdr-agent.js";
 import { ComposerImages } from "./composer-images.js";
+import { mergeJobSettlement } from "../session/job-notice.js";
 import { PlainTui } from "./plain-tui.js";
 import { homedir } from 'node:os';
 import { join, sep } from 'node:path';
 import { StringDecoder } from 'node:string_decoder';
+import { defaultFeatureStates, featurePatchPath, featureStatesFromPatch, renderFeatureBlock, replaceFeatureBlock, } from "../session/feature-toggles.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
 import { TUI_SERVICE, } from "../definition.js";
 import { applySlashCompletion, formatHelpText, parseSlashInput, resolveSlashCommand, slashSuggestions, BUILTIN_SLASH_COMMANDS, } from "../views/autocomplete.js";
 import { applyPathCompletion, defaultPathSource, editorLineAt, findPathToken, parsePathPrefix, pathSuggestions, searchPathSuggestions, } from "../views/path-complete.js";
@@ -30,22 +34,24 @@ import { InputEditor, lineEnd, lineStart } from "../input/editor.js";
 import { applySettingsEvent, createSettings, } from "../views/settings-list.js";
 import { appendTrajectoryEvent, applyTrajectoryEvent, createTrajectory, trajectoryDetailMetrics, trajectoryListMetrics, } from "../views/trajectory.js";
 import { applyAgentHubEvent, createAgentHub, updateAgentHub, } from "../views/agent-hub.js";
-import { applyEvent, applyStreamChunk, blockSearchText, initialTranscript, replayEvents, renderView, TRANSCRIPT_FAST_SCROLL, } from "../views/event-views.js";
+import { applyEvent, applyStreamChunk, blockSearchText, initialTranscript, replayEvents, renderView, turnGroups, transcriptSeam, TRANSCRIPT_FAST_SCROLL, withWorkspaceSummary, } from "../views/event-views.js";
 import { applyTranscriptSearchEvent, createTranscriptSearch, searchBlockIndexes, } from "../views/transcript-search.js";
 import { nextRevealStep, revealStreamingAssistant, streamingAssistantKey, streamingAssistantUnits, } from "../views/streaming-reveal.js";
 import { flushPending, parseKeys } from "../input/keys.js";
 import { MainScreenRenderer } from "../chrome/main-screen-renderer.js";
-import { colorDisabledByEnv, detectTrueColor, parseThemeName } from "../chrome/theme.js";
+import { colorDisabledByEnv, detectTrueColor } from "../chrome/theme.js";
 import { renderTool } from "../chrome/tool-renderers.js";
-import { TUI_SETTINGS_NAMESPACE, TuiSettingsSchema } from "../session/tui-settings.js";
+import { TUI_SETTINGS_ENTRY, TUI_SETTINGS_FIELDS } from "../session/tui-settings.js";
+import { DEFAULT_FOLD_DENSITY, foldPolicy, resolveFoldDensity, } from "../session/fold-policy.js";
 import { defaultStatusBarConfig, resolveStatusBarConfig } from "../chrome/status-config.js";
 import { HistoryStore } from "../session/history-store.js";
 import { loadKeybindings } from "../input/keybindings-config.js";
 import { editExternally } from "../input/external-editor.js";
+import z from '@deepseek-ai/schemastery';
 import { movePromptSelection, filteredPromptOptions, selectedPromptAnswer, selectedFilteredPromptAnswer, togglePromptSelection, } from "../views/prompt-selector.js";
 import { refreshProjectContext, resolveProjectContext } from "../session/project-context.js";
 import { pickWelcomeTips } from "../chrome/welcome-tips.js";
-import { formatEssentialHotkeysText, formatHotkeysText, hotkeyCount } from "../views/hotkeys.js";
+import { formatEssentialHotkeysText, formatHotkeysText, hotkeyCount, keysForAction } from "../views/hotkeys.js";
 import { imagePathCandidates, stripComposerImageMarkers, readImageFile, readImageFromClipboard, readMacClipboardFiles, } from "../input/image-paste.js";
 import { APP_NAME, APP_VERSION } from "../session/package-metadata.js";
 const DOUBLE_CTRL_C_MS = 500;
@@ -89,6 +95,18 @@ function windowTitleText(title) {
     return [...cleaned].slice(0, WINDOW_TITLE_MAX).join('');
 }
 export const name = 'omdsh-tui';
+/**
+ * Row schema. The durable preferences ride as volatile fields, so a settings
+ * form edit commits into their references and reaches this fiber through
+ * `loader/volatile-update` without remounting the terminal provider.
+ */
+export const Config = z.object({
+    model: z.string(),
+    historyPath: z.string(),
+    keybindingsPath: z.string(),
+    dshHome: z.string(),
+    ...TUI_SETTINGS_FIELDS,
+});
 /**
  * Local terminal presentation service.
  */
@@ -110,6 +128,25 @@ function resolveColors(preference, isTty) {
         return preference;
     return isTty && !colorDisabledByEnv();
 }
+/**
+ * The first body row whose shape changed between two frames: the earliest
+ * surface that opened, closed, or changed how it is open. Rows above it are
+ * the same in both frames, which is what lets the renderer keep history that
+ * is still true and repair only what moved.
+ */
+function firstReshapedRow(before, after) {
+    const keys = (marks) => new Set(marks.map(mark => mark.key));
+    const was = keys(before);
+    const now = keys(after);
+    let row = Number.POSITIVE_INFINITY;
+    for (const mark of before)
+        if (!now.has(mark.key))
+            row = Math.min(row, mark.row);
+    for (const mark of after)
+        if (!was.has(mark.key))
+            row = Math.min(row, mark.row);
+    return Number.isFinite(row) ? row : 0;
+}
 export class LocalTui {
     #deferInitialRender = false;
     #terminalProfile;
@@ -133,6 +170,10 @@ export class LocalTui {
     #search = null;
     #transcriptSearch = null;
     #settings = null;
+    /** Optional-feature state read from the Profile patch this process booted with. */
+    #features;
+    /** Profile patch the Features section writes; absent hides that section. */
+    #featurePatch;
     #copySelector = null;
     #trajectory = null;
     #agentHub = null;
@@ -179,9 +220,16 @@ export class LocalTui {
     #scrollStart = 0;
     #maxStart = 0;
     #scrollBudget = 0;
+    #blockStarts = [];
+    /** Last frame's {@link TranscriptScroll.foldShape}, to notice a fold change. */
+    #foldShape;
+    /** Last frame's open surfaces, to find where a fold change starts. */
+    #foldMarks;
     #follow = true;
     #focusBlock;
-    #expandTools = false;
+    #focusBlockEdge;
+    #foldDensity = DEFAULT_FOLD_DENSITY;
+    #foldPolicy = foldPolicy(DEFAULT_FOLD_DENSITY);
     #motion = 'full';
     #terminalProgress = false;
     #terminalProgressActive = false;
@@ -199,7 +247,24 @@ export class LocalTui {
     #notificationThreshold = '30s';
     #statusBar = defaultStatusBarConfig();
     #toolsExpanded = false;
-    #expandedToolCalls = new Set();
+    /**
+     * The reader opened something with Ctrl+O or Alt+O and is reading it.
+     *
+     * Openings are shown in a browsing frame, never in the flow that follows the
+     * tail: every opening starts an inspection, and returning to the tail ends it
+     * and closes them all. The flow's rows cross into the terminal's history, which can only be
+     * appended to: opening a run in place pushed rows that closing it could not
+     * take back, so the screen either went blank where they had been or painted
+     * rows history already held, and the transcript read twice. A browsing frame
+     * repaints the screen and nothing above it, so reading an opened run leaves
+     * the flow — and the history — exactly as it was.
+     */
+    #inspecting = false;
+    #mouseTracking = false;
+    #jumpToLatest;
+    #openedGroups = new Set();
+    /** Turn scopes whose tools stay detailed as new calls arrive during inspection. */
+    #detailedTurns = new Set();
     #tools = [];
     #runtimeCommands = [];
     #prompt = null;
@@ -269,6 +334,17 @@ export class LocalTui {
         this.#historyStore = paths.historyPath === undefined ? undefined : new HistoryStore(paths.historyPath);
         this.#history = this.#historyStore?.load() ?? [];
         this.#keybindings = loadKeybindings(paths.keybindingsPath);
+        this.#featurePatch = paths.featurePatch;
+        if (paths.featurePatch !== undefined) {
+            try {
+                this.#features = featureStatesFromPatch(readFileSync(paths.featurePatch, 'utf8'));
+            }
+            catch {
+                // A patch that cannot be read still leaves the shipped defaults; the
+                // write path below reports the failure when the user toggles.
+                this.#features = defaultFeatureStates();
+            }
+        }
         const fallback = defaultPathSource();
         this.#cwd = paths.cwd ?? fallback.cwd;
         this.#readImagePath = paths.readImagePath ?? (path => readImageFile(path, this.#cwd));
@@ -300,7 +376,6 @@ export class LocalTui {
             width: this.#term.width(),
             height: this.#term.height(),
             synchronized: this.#tty,
-            clearScrollback: this.#terminalProfile === 'direct',
             alternateScreenOverlays: paths.alternateScreenOverlays === true,
         });
         if (this.#tty) {
@@ -340,8 +415,15 @@ export class LocalTui {
         if (this.#tty)
             this.#render();
     }
-    event(event, presentation) {
-        this.#state = applyEvent(this.#state, event, presentation);
+    event(event, presentation, workspace) {
+        // Paint any coalesced results and remaining streamed text before the turn's
+        // end changes the live work into its folded summary.
+        if (event.type === 'turn/end' && this.#tty && this.#state.status !== 'idle'
+            && turnGroups(this.#state).some(group => group.live)) {
+            this.#syncStreamingReveal(undefined);
+            this.#render();
+        }
+        this.#state = applyEvent(this.#state, event, presentation, workspace);
         this.#emitNotification(this.#notifications.event({
             type: event.type,
             time: event.time,
@@ -368,6 +450,16 @@ export class LocalTui {
             this.#plain.print();
         }
     }
+    setWorkspaceSummary(turn, summary) {
+        const next = withWorkspaceSummary(this.#state, turn, summary);
+        if (next === this.#state)
+            return;
+        this.#state = next;
+        if (this.#tty)
+            this.#render();
+        else
+            this.#plain.print();
+    }
     /**
      * Fold one live `agent/assistant-stream` chunk into the transcript and
      * schedule the streaming reveal. Durable settlement follows on the session
@@ -532,20 +624,41 @@ export class LocalTui {
             .join(' · ');
     }
     notice(text, options = {}) {
+        const merged = options.job === undefined ? undefined : mergeJobSettlement(this.#state, options.job);
+        if (merged !== undefined && this.#tty) {
+            const origin = merged.blocks.find((block, index) => block !== this.#state.blocks[index]);
+            this.#state = merged;
+            // A previous turn may already be in native history. Keep its new outcome
+            // visible at the tail as well as updating the live transcript's tool.
+            if (origin?.kind === 'tool' && (origin.turn === undefined || origin.turn === this.#state.turn)) {
+                if (options.focus === true)
+                    this.#followTail();
+                this.#render();
+                return;
+            }
+        }
+        const running = options.process === true && this.#state.status !== 'idle' && this.#state.turn > 0;
         const block = {
             kind: 'notice',
             level: options.level ?? 'info',
             text,
             ...(options.framed === true ? { framed: true } : {}),
+            ...(running
+                ? { process: { turn: this.#state.turn, ...(options.processSource === undefined ? {} : { source: options.processSource }) } }
+                : {}),
         };
         this.#state = { ...this.#state, blocks: [...this.#state.blocks, block] };
+        if (options.focus === true)
+            this.#followTail();
         if (this.#tty)
             this.#render();
         else
             this.#plain.print();
     }
-    commandOutput(command, text) {
+    commandOutput(command, text, options = {}) {
         this.#state = { ...this.#state, blocks: [...this.#state.blocks, { kind: 'commandOutput', command, text }] };
+        if (options.focus === true)
+            this.#followTail();
         if (this.#tty)
             this.#render();
         else
@@ -590,14 +703,18 @@ export class LocalTui {
             }
         });
     }
-    replaceSession(events, presentations, status = 'idle') {
+    replaceSession(events, presentations, status = 'idle', reason = 'open') {
         this.#trajectory = null;
         const state = replayEvents(events, presentations);
-        this.#state = { ...state, status, compactCommandId: undefined };
+        // Notices and tool catalogs do not turn a blank session into a document
+        // that /new needs to separate. Refreshes are the same document.
+        const boundary = reason === 'open' || (reason === 'new' && this.#state.blocks.some(block => block.kind !== 'notice' && block.kind !== 'toolCatalog'));
+        const blocks = boundary ? [transcriptSeam('session-opened'), ...state.blocks] : state.blocks;
+        this.#state = { ...state, status, compactCommandId: undefined, blocks };
         this.#plain.resetPrinted();
         this.#followTail();
         this.#deferInitialRender = false;
-        this.#renderer.startEpoch({ replay: status === 'idle' ? 'full' : 'pinned' });
+        this.#renderer.startEpoch({ replay: reason === 'refresh' ? 'viewport' : status === 'idle' ? 'full' : 'pinned' });
         if (this.#tty)
             this.#render();
         else
@@ -645,7 +762,7 @@ export class LocalTui {
     #syncTrueColor() {
         this.#trueColor = this.#colors && detectTrueColor();
     }
-    /** Apply prefs loaded from the settings document (does not persist). */
+    /** Apply prefs loaded from this entry's config (does not persist). */
     applyStoredPrefs(prefs) {
         this.#applyPrefs(prefs, { persist: false, forceToolsSync: true });
         if (this.#settings !== null)
@@ -653,6 +770,29 @@ export class LocalTui {
         if (this.#tty)
             this.#render();
     }
+    /** Currently applied preferences; sibling rows read these instead of the config references. */
+    prefs() {
+        return {
+            theme: this.#themeName,
+            colors: this.#colors,
+            motion: this.#motion,
+            terminalProgress: this.#terminalProgress,
+            foldDensity: this.#foldDensity,
+            checkUpdates: this.#checkUpdates,
+            startupChangelog: this.#startupChangelog,
+            notifications: this.#notificationPolicy,
+            notificationThreshold: this.#notificationThreshold,
+            statusBar: {
+                ...this.#statusBar,
+                groups: [...this.#statusBar.groups],
+                ...(this.#statusBar.order === undefined ? {} : { order: [...this.#statusBar.order] }),
+                ...(this.#statusBar.meta === undefined ? {} : { meta: [...this.#statusBar.meta] }),
+                ...(this.#statusBar.metaOrder === undefined ? {} : { metaOrder: [...this.#statusBar.metaOrder] }),
+                ...(this.#statusBar.colors === undefined ? {} : { colors: { ...this.#statusBar.colors } }),
+                ...(this.#statusBar.sides === undefined ? {} : { sides: { ...this.#statusBar.sides } }),
+            },
+        };
+    }
     /** Called after a live `/settings` change. */
     setPrefsPersist(persist) {
         this.#persistPrefs = persist;
@@ -675,7 +815,7 @@ export class LocalTui {
             this.#agentBehavior = undefined;
             this.#agentBehaviorPending = false;
             if (this.#settings !== null)
-                this.#settings = createSettings(this.#prefs());
+                this.#settings = createSettings(this.prefs(), undefined, this.#agentBehavior, this.#features);
             if (this.#tty && !this.#disposed)
                 this.#render();
         };
@@ -804,6 +944,7 @@ export class LocalTui {
         if (this.#tty) {
             this.#offData?.();
             this.#offResize?.();
+            this.#setMouseTracking(false);
             this.#term.input.setRawMode?.(false);
             // Leave the cursor on a fresh line below the last frame so the shell
             // prompt does not overwrite the transcript. Disable bracketed paste
@@ -989,7 +1130,7 @@ export class LocalTui {
                 trueColor: this.#trueColor,
                 themeName: this.#themeName,
                 scrollStart: this.#follow ? Number.POSITIVE_INFINITY : this.#scrollStart,
-                ...(this.#focusBlock === undefined ? {} : { focusBlock: this.#focusBlock }),
+                ...(this.#focusBlock === undefined ? {} : { focusBlock: this.#focusBlock, focusBlockEdge: this.#focusBlockEdge ?? 'start' }),
                 ...(this.#transcriptSearch === null ? {} : {
                     transcriptSearch: {
                         query: this.#transcriptSearch.query,
@@ -999,7 +1140,10 @@ export class LocalTui {
                     },
                 }),
                 toolsExpanded: this.#toolsExpanded,
-                expandedTools: this.#expandedToolCalls,
+                expandedTools: this.#detailedToolIds(),
+                toolDetailsKey: keysForAction(this.#keybindings, 'toggle-tool-details'),
+                fold: this.#foldPolicy,
+                openedGroups: this.#openedGroups,
                 commands: this.#commands(),
                 recentSessions: this.#recentSessions,
                 welcomeTips: this.#welcomeTips,
@@ -1023,8 +1167,23 @@ export class LocalTui {
             })
             : { lines: [] };
         this.#focusBlock = undefined;
+        this.#focusBlockEdge = undefined;
         this.#promptDocument = frame.promptDocument;
         this.#syncScroll(frame.transcript);
+        this.#jumpToLatest = frame.jumpToLatest;
+        this.#setMouseTracking(frame.transcript !== undefined && frame.transientSurface !== 'overlay'
+            && (this.#inspecting || this.#maxStart > 0));
+        // A run opening or folding reshapes rows above the screen in place; the
+        // renderer's frozen boundary is a row index and has to be told, or a fold
+        // blanks the screen and a large one replays the transcript into history.
+        const scroll = frame.transcript;
+        if (scroll?.foldShape !== undefined && scroll.foldMarks !== undefined) {
+            if (this.#foldMarks !== undefined && scroll.foldShape !== this.#foldShape) {
+                this.#renderer.reflow((scroll.bodyRow ?? 0) + firstReshapedRow(this.#foldMarks, scroll.foldMarks));
+            }
+            this.#foldShape = scroll.foldShape;
+            this.#foldMarks = scroll.foldMarks;
+        }
         this.#renderer.render(frame);
     }
     #scheduleStreamRender() {
@@ -1038,16 +1197,17 @@ export class LocalTui {
     }
     #syncScroll(scroll) {
         if (scroll === undefined) {
-            this.#scrollStart = 0;
-            this.#maxStart = 0;
-            this.#scrollBudget = 0;
-            this.#follow = true;
+            // Full-screen surfaces temporarily cover the transcript. They carry no
+            // scroll projection and must not replace the reader's return position.
             return;
         }
         this.#scrollStart = scroll.start;
         this.#maxStart = scroll.maxStart;
         this.#scrollBudget = scroll.budget;
-        if (this.#follow || this.#scrollStart >= this.#maxStart) {
+        this.#blockStarts = scroll.blockStarts?.map(row => row + (scroll.bodyRow ?? 0)) ?? [];
+        // An inspection stays a browsing frame even when everything fits: resuming
+        // the follow would drop the openings the reader just asked for.
+        if (!this.#inspecting && (this.#follow || this.#scrollStart >= this.#maxStart)) {
             this.#follow = true;
             this.#scrollStart = this.#maxStart;
         }
@@ -1056,8 +1216,22 @@ export class LocalTui {
         return Math.max(1, this.#scrollBudget > 2 ? this.#scrollBudget - 2 : 1);
     }
     #scrollBy(delta) {
+        if (this.#follow && delta > 0)
+            return;
         if (delta === 0 && this.#maxStart === 0)
             return;
+        if (!this.#inspecting && delta > 0 && this.#scrollStart + delta >= this.#maxStart) {
+            this.#followTail();
+            this.#render();
+            return;
+        }
+        // Scrolling past the end of an inspection is how a reader goes back to
+        // the live tail, the same as scrolling to the end of history does.
+        if (this.#inspecting && delta > 0 && this.#scrollStart >= this.#maxStart) {
+            this.#followTail();
+            this.#render();
+            return;
+        }
         this.#follow = false;
         this.#scrollStart += delta;
         if (this.#scrollStart <= 0)
@@ -1067,6 +1241,47 @@ export class LocalTui {
     #followTail() {
         this.#follow = true;
         this.#scrollStart = this.#maxStart;
+        this.#endInspection();
+    }
+    /** Close every opening the reader made; they belong to one inspection. */
+    #endInspection() {
+        if (!this.#inspecting)
+            return;
+        this.#inspecting = false;
+        this.#toolsExpanded = false;
+        this.#openedGroups.clear();
+        this.#detailedTurns.clear();
+    }
+    /** Capture transcript navigation; overlays and disposal restore terminal ownership. */
+    #setMouseTracking(enabled) {
+        if (!this.#tty || enabled === this.#mouseTracking)
+            return;
+        this.#mouseTracking = enabled;
+        this.#term.output.write(enabled ? '\x1b[?1000h\x1b[?1006h' : '\x1b[?1000l\x1b[?1006l');
+    }
+    /**
+     * After a Ctrl+O toggle: read what is open in a browsing frame at `target`,
+     * or go back to the live tail once nothing is open any more.
+     */
+    #inspect(target) {
+        const open = this.#toolsExpanded || this.#openedGroups.size > 0;
+        if (!open) {
+            this.#inspecting = false;
+            this.#followTail();
+            return;
+        }
+        if (this.#inspecting)
+            return;
+        this.#inspecting = true;
+        this.#follow = false;
+        // Opening from the tail with nothing in particular under the viewport
+        // keeps the reader at the end of the transcript, now in a browsing frame.
+        if (target === undefined)
+            this.#scrollStart = Number.MAX_SAFE_INTEGER;
+        else {
+            this.#focusBlock = target;
+            this.#focusBlockEdge = 'end';
+        }
     }
     #utf8 = new StringDecoder('utf8');
     #onData(chunk) {
@@ -1192,7 +1407,27 @@ export class LocalTui {
             await this.#acceptPastedText(text);
     }
     #dispatch(event) {
+        if (event.type === 'click') {
+            const target = this.#jumpToLatest;
+            if (this.#mouseTracking && !this.#paste && this.#pasteInFlight === 0 && target !== undefined
+                && event.row === target.row && event.column >= target.column && event.column < target.column + target.width) {
+                this.#followTail();
+                this.#render();
+            }
+            return;
+        }
+        if (event.type === 'wheel') {
+            if (this.#mouseTracking && !this.#paste && this.#pasteInFlight === 0) {
+                this.#scrollBy(event.direction === 'up' ? -3 : 3);
+            }
+            return;
+        }
         if (this.#state.status === 'compacting') {
+            if (event.type === 'key' && event.id === 'end' && this.#jumpToLatest !== undefined) {
+                this.#followTail();
+                this.#render();
+                return;
+            }
             if (event.type === 'key' && event.id === 'pageUp') {
                 this.#scrollBy(-this.#pageSize());
                 return;
@@ -1272,6 +1507,12 @@ export class LocalTui {
             this.#applyTranscriptSearch(event);
             return;
         }
+        if (event.type === 'key' && event.id === 'end' && this.#jumpToLatest !== undefined
+            && this.#settings === null && this.#copySelector === null && this.#search === null) {
+            this.#followTail();
+            this.#render();
+            return;
+        }
         if (event.type === 'key') {
             const action = this.#boundAction(event.id);
             if (action !== undefined && this.#runAction(action))
@@ -1620,45 +1861,24 @@ export class LocalTui {
         this.#agentHub = createAgentHub({ agents });
         this.#render();
     }
-    #prefs() {
-        return {
-            theme: this.#themeName,
-            colors: this.#colors,
-            motion: this.#motion,
-            terminalProgress: this.#terminalProgress,
-            expandTools: this.#expandTools,
-            checkUpdates: this.#checkUpdates,
-            startupChangelog: this.#startupChangelog,
-            notifications: this.#notificationPolicy,
-            notificationThreshold: this.#notificationThreshold,
-            statusBar: {
-                ...this.#statusBar,
-                groups: [...this.#statusBar.groups],
-                ...(this.#statusBar.order === undefined ? {} : { order: [...this.#statusBar.order] }),
-                ...(this.#statusBar.meta === undefined ? {} : { meta: [...this.#statusBar.meta] }),
-                ...(this.#statusBar.metaOrder === undefined ? {} : { metaOrder: [...this.#statusBar.metaOrder] }),
-                ...(this.#statusBar.colors === undefined ? {} : { colors: { ...this.#statusBar.colors } }),
-                ...(this.#statusBar.sides === undefined ? {} : { sides: { ...this.#statusBar.sides } }),
-            },
-        };
-    }
     #applyPrefs(prefs, options) {
         const previousMotion = this.#motion;
-        const expandChanged = prefs.expandTools !== this.#expandTools;
+        const density = resolveFoldDensity(prefs);
         this.#themeName = prefs.theme;
         this.#colors = prefs.colors;
         this.#syncTrueColor();
         this.#motion = prefs.motion ?? 'full';
         this.#terminalProgress = prefs.terminalProgress ?? false;
-        this.#expandTools = prefs.expandTools;
+        this.#foldDensity = density;
+        this.#foldPolicy = foldPolicy(density);
         this.#checkUpdates = prefs.checkUpdates ?? true;
         this.#startupChangelog = prefs.startupChangelog ?? 'summary';
         this.#notificationPolicy = prefs.notifications ?? 'off';
         this.#notificationThreshold = prefs.notificationThreshold ?? '30s';
         this.#configureNotifications();
         this.#statusBar = resolveStatusBarConfig(prefs.statusBar, prefs.statusPreset);
-        if (options.forceToolsSync || expandChanged)
-            this.#toolsExpanded = prefs.expandTools;
+        if (options.forceToolsSync)
+            this.#toolsExpanded = false;
         if (previousMotion !== this.#motion) {
             this.#stopRevealTick();
             this.#reveal = undefined;
@@ -1695,6 +1915,36 @@ export class LocalTui {
                 this.#render();
         }
     }
+    /**
+     * Write the Features section's state into the Profile patch.
+     *
+     * `disabled` is a Loader option rather than plugin config, so the settings
+     * service cannot express it; the Profile patch is the documented surface
+     * that can, and the Harness reads it while composing the tree. Only the
+     * managed block is rewritten, so hand-authored rows and comments survive.
+     * A failure is reported and the overlay keeps the value it shows.
+     */
+    #writeFeaturePatch() {
+        const path = this.#featurePatch;
+        const features = this.#features;
+        if (path === undefined || features === undefined)
+            return;
+        try {
+            let current = '';
+            try {
+                current = readFileSync(path, 'utf8');
+            }
+            catch {
+                current = '';
+            }
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, replaceFeatureBlock(current, renderFeatureBlock(features)), 'utf8');
+        }
+        catch (error) {
+            this.notice(`Feature toggles were not saved: ${error instanceof Error ? error.message : String(error)}`);
+            this.#render();
+        }
+    }
     #applySettings(event) {
         if (this.#settings === null)
             return;
@@ -1705,6 +1955,15 @@ export class LocalTui {
             return;
         }
         if (command.kind === 'apply') {
+            if (command.domain === 'features') {
+                if (command.state.features === undefined)
+                    return;
+                this.#settings = command.state;
+                this.#features = command.state.features;
+                this.#render();
+                this.#writeFeaturePatch();
+                return;
+            }
             if (command.domain === 'agent') {
                 if (this.#agentBehaviorPending || command.state.agent === undefined)
                     return;
@@ -1977,6 +2236,11 @@ export class LocalTui {
         }
         if (command.kind === 'suspend') {
             if (process.platform !== 'win32') {
+                if (this.#inspecting) {
+                    this.#followTail();
+                    this.#render();
+                }
+                this.#setMouseTracking(false);
                 try {
                     process.kill(process.pid, 'SIGTSTP');
                 }
@@ -2087,7 +2351,6 @@ export class LocalTui {
         this.#copySelector = null;
         this.#trajectory = null;
         this.#agentHub = null;
-        this.#followTail();
         // Image placeholders are TUI-owned. Mixed image+slash drafts stay a
         // submission so restore can keep the original markers; the runner strips
         // them only to detect and execute Harness commands.
@@ -2098,6 +2361,7 @@ export class LocalTui {
             this.#runSlash(slash.name, slash.args);
             return;
         }
+        this.#followTail();
         const pending = this.#pending;
         if (pending !== null) {
             pending.offAbort?.();
@@ -2131,12 +2395,12 @@ export class LocalTui {
         this.#images.clear();
         this.#ac = null;
         this.#search = null;
-        this.#followTail();
         const slash = images.length === 0 ? parseSlashInput(submittedText) : null;
         if (slash !== null) {
             this.#runSlash(slash.name, slash.args);
             return;
         }
+        this.#followTail();
         if (submittedText === '' && images.length === 0) {
             this.#render();
             return;
@@ -2152,25 +2416,13 @@ export class LocalTui {
         }
         const command = resolveSlashCommand(name, this.#commands());
         if (command === undefined) {
-            this.#notice('unknown command: /' + name);
-            this.#render();
-            return;
-        }
-        if (command.name === 'quit') {
-            this.#render();
-            this.#quit();
-            return;
-        }
-        if (command.name === 'clear') {
-            // Presentation-only reset: the agent may still own an active turn with
-            // live status, todos, and queued inbox state. Clearing those would make
-            // the next Ctrl-C (or follow-up) behave as if the session had finished.
-            this.#state = { ...this.#state, blocks: [] };
             this.#followTail();
-            this.#renderer.startEpoch();
+            this.#notice('unknown command: /' + name);
             this.#render();
             return;
         }
+        // Reading controls cover the current view; submitting a command that
+        // opens one must preserve the same return position as a keyboard action.
         if (command.name === 'settings') {
             this.#runSettings(args);
             return;
@@ -2179,11 +2431,8 @@ export class LocalTui {
             void this.#runCopy(args);
             return;
         }
-        if (command.name === 'tools') {
-            this.#toolCatalog();
-            this.#render();
-            return;
-        }
+        // A plugin decides whether its command opens a reading surface or changes
+        // the document. Forwarding alone must not discard the return position.
         if (!BUILTIN_SLASH_COMMANDS.some((entry) => entry.name === command.name)) {
             if (this.#inspected !== undefined) {
                 this.#notice('Return to the parent session to run /' + command.name + '.');
@@ -2203,6 +2452,27 @@ export class LocalTui {
             this.#render();
             return;
         }
+        this.#followTail();
+        if (command.name === 'quit') {
+            this.#render();
+            this.#quit();
+            return;
+        }
+        if (command.name === 'clear') {
+            // Presentation-only reset: the agent may still own an active turn with
+            // live status, todos, and queued inbox state. Clearing those would make
+            // the next Ctrl-C (or follow-up) behave as if the session had finished.
+            this.#state = { ...this.#state, blocks: [transcriptSeam('cleared')] };
+            this.#followTail();
+            this.#renderer.startEpoch();
+            this.#render();
+            return;
+        }
+        if (command.name === 'tools') {
+            this.#toolCatalog();
+            this.#render();
+            return;
+        }
         if (args !== '' && args !== 'full') {
             this.#notice('Usage: /help [full]');
             this.#render();
@@ -2324,7 +2594,7 @@ export class LocalTui {
         }
         this.#search = null;
         this.#ac = null;
-        this.#settings = createSettings(this.#prefs(), undefined, this.#agentBehavior);
+        this.#settings = createSettings(this.prefs(), undefined, this.#agentBehavior, this.#features);
         this.#render();
     }
     #notice(text) {
@@ -2393,7 +2663,13 @@ export class LocalTui {
         if (action === 'toggle-tools') {
             if (this.#search !== null)
                 return false;
-            this.#toggleToolExpansion();
+            this.#toggleFoldTarget();
+            return true;
+        }
+        if (action === 'toggle-tool-details') {
+            if (this.#search !== null)
+                return false;
+            this.#toggleToolDetails();
             return true;
         }
         if (action === 'search-history') {
@@ -2450,6 +2726,7 @@ export class LocalTui {
             return true;
         }
         try {
+            this.#setMouseTracking(false);
             this.#term.input.setRawMode?.(false);
             const text = editExternally(this.#editor.text);
             this.#editor.setText(text);
@@ -2466,26 +2743,130 @@ export class LocalTui {
         }
         return true;
     }
-    /** Expand or collapse the newest tool card, or the whole tool catalog. */
-    #toggleToolExpansion() {
-        const last = this.#state.blocks.at(-1);
-        const tool = last?.kind === 'toolCatalog'
-            ? undefined
-            : this.#state.blocks.findLast(block => block.kind === 'tool');
-        if (last?.kind === 'toolCatalog') {
-            this.#toolsExpanded = !this.#toolsExpanded;
+    /**
+     * Block index the reader is looking at: the first one that starts at or below
+     * the top of the transcript window. A collapsed row has to stay reachable
+     * after the reader scrolls away from the tail, so the toggle aims here rather
+     * than at the newest call.
+     */
+    #viewportBlock() {
+        const starts = this.#blockStarts;
+        if (starts.length === 0)
+            return undefined;
+        const at = this.#follow ? Number.POSITIVE_INFINITY : this.#scrollStart;
+        let index = starts.findIndex(row => row >= at);
+        if (index < 0)
+            index = starts.length - 1;
+        return index;
+    }
+    /** Restore the completed turn under the viewport, or close its inspection. */
+    #toggleFoldTarget() {
+        // Flush coalesced events so hit testing uses the blocks that are on screen.
+        if (this.#streamRenderTimer !== null)
+            this.#render();
+        // Inside an inspection the key is the way back out: it closes what was
+        // opened and returns to the live tail, wherever the reader has scrolled.
+        if (this.#inspecting) {
+            this.#followTail();
+            this.#render();
+            return;
         }
-        else if (tool?.kind === 'tool') {
-            if (this.#expandedToolCalls.has(tool.callId))
-                this.#expandedToolCalls.delete(tool.callId);
-            else
-                this.#expandedToolCalls.add(tool.callId);
+        const anchor = this.#viewportBlock();
+        const groups = turnGroups(this.#state).filter(item => !item.live);
+        // The answer, changed-file record, and following notices still address
+        // their turn when the reader is following the tail.
+        const reach = (group) => {
+            let at = group.until;
+            const blocks = this.#state.blocks;
+            while (at < blocks.length) {
+                const block = blocks[at];
+                if (block?.kind === 'workspace' || (block?.kind === 'notice' && block.boundary !== true)) {
+                    at += 1;
+                    continue;
+                }
+                break;
+            }
+            return at - 1;
+        };
+        const group = anchor === undefined
+            ? undefined
+            : groups.findLast(item => {
+                const first = this.#state.blocks[item.start - 1]?.kind === 'user' ? item.start - 1 : item.start;
+                return anchor >= first && anchor <= reach(item);
+            });
+        if (group !== undefined) {
+            this.#toggleSet(this.#openedGroups, group.key);
+            this.#inspect((group.answer ?? group.until) - 1);
+            this.#render();
+            return;
         }
-        else {
+        if (anchor !== undefined && this.#state.blocks[anchor]?.kind === 'toolCatalog') {
             this.#toolsExpanded = !this.#toolsExpanded;
+            this.#inspect(anchor);
+            this.#render();
         }
+        // A live turn already has the process presentation; Alt+O owns tool details.
+    }
+    #detailScope(group) {
+        return group.turn === undefined ? group.key : `turn:${group.turn}`;
+    }
+    #detailedToolIds() {
+        const calls = new Set();
+        if (this.#detailedTurns.size === 0)
+            return calls;
+        for (const group of turnGroups(this.#state)) {
+            if (!this.#detailedTurns.has(this.#detailScope(group)))
+                continue;
+            for (let at = group.start; at < group.until; at++) {
+                const block = this.#state.blocks[at];
+                if (block?.kind === 'tool')
+                    calls.add(block.callId);
+            }
+        }
+        return calls;
+    }
+    #toggleToolDetails() {
+        if (this.#streamRenderTimer !== null)
+            this.#render();
+        // A long tool can fill the viewport. Target the block containing its top,
+        // rather than the next block starting below it (possibly another turn).
+        const anchor = this.#follow ? this.#state.blocks.length - 1
+            : Math.max(0, this.#blockStarts.findLastIndex(row => row <= this.#scrollStart));
+        const groups = turnGroups(this.#state);
+        const group = groups.findLast(item => {
+            const first = this.#state.blocks[item.start - 1]?.kind === 'user' ? item.start - 1 : item.start;
+            let end = item.until;
+            while (end < this.#state.blocks.length) {
+                const block = this.#state.blocks[end];
+                if (block?.kind !== 'workspace' && !(block?.kind === 'notice' && block.boundary !== true))
+                    break;
+                end++;
+            }
+            return anchor >= first && anchor < end;
+        });
+        if (group === undefined)
+            return;
+        const scope = this.#detailScope(group);
+        const members = groups.filter(item => this.#detailScope(item) === scope);
+        if (members.every(member => member.calls === 0))
+            return;
+        this.#toggleSet(this.#detailedTurns, scope);
+        for (const member of members)
+            this.#openedGroups.add(member.key);
+        const tools = members.flatMap(member => this.#state.blocks.slice(member.start, member.until)
+            .flatMap((block, offset) => block.kind === 'tool' ? [member.start + offset] : []));
+        const target = tools.includes(anchor) ? anchor : tools[0];
+        this.#inspect(target);
+        this.#focusBlock = target;
+        this.#focusBlockEdge = 'start';
         this.#render();
     }
+    #toggleSet(set, key) {
+        if (set.has(key))
+            set.delete(key);
+        else
+            set.add(key);
+    }
     /** Fold one event into the active transcript search. */
     #applyTranscriptSearch(event) {
         const state = this.#transcriptSearch;
@@ -2521,21 +2902,55 @@ export function apply(ctx, config) {
             return () => { process.stdout.removeListener('resize', listener); };
         },
     };
-    const tui = new LocalTui(term, config.model, config.colors, parseThemeName(config.theme), copyToClipboard, {
+    const tui = new LocalTui(term, config.model, config.colors.get(), config.theme.get(), copyToClipboard, {
         deferInitialRender: true,
         terminalProfile,
         alternateScreenOverlays: terminalProfile === 'direct',
         herdrReporter: new HerdrAgentReporter(),
         historyPath: config.historyPath ?? join(dshHome, 'omdsh', 'history.jsonl'),
         keybindingsPath: config.keybindingsPath ?? join(dshHome, 'omdsh', 'keybindings.json'),
+        ...(() => {
+            const path = featurePatchPath(config.dshHome ?? dshHome);
+            return existsSync(path) ? { featurePatch: path } : {};
+        })(),
     });
     ctx.provide(TUI_SERVICE, tui);
     ctx.effect(() => () => { tui.dispose(); });
+    // Preferences are this entry's own volatile config: the initial read applies
+    // them without persisting, a committed form edit dispatches a volatile update
+    // to this fiber only, and an in-app `/settings` change writes back through the
+    // settings service, which persists the edit into the active profile patch.
+    const storedPrefs = () => {
+        const prefs = {
+            theme: config.theme.get(),
+            colors: resolveColors(config.colors.get(), term.output.isTTY === true),
+            motion: config.motion.get(),
+            terminalProgress: config.terminalProgress.get(),
+            foldDensity: config.foldDensity.get(),
+            checkUpdates: config.checkUpdates.get(),
+            startupChangelog: config.startupChangelog.get(),
+            notifications: config.notifications.get(),
+            notificationThreshold: config.notificationThreshold.get(),
+        };
+        const statusBar = config.statusBar.get();
+        // The reference holds a frozen snapshot; the provider keeps a mutable copy.
+        if (statusBar !== undefined)
+            prefs.statusBar = structuredClone(statusBar);
+        const statusPreset = config.statusPreset.get();
+        if (statusPreset !== undefined)
+            prefs.statusPreset = statusPreset;
+        return prefs;
+    };
+    tui.applyStoredPrefs(storedPrefs());
+    ctx.on('loader/volatile-update', () => { tui.applyStoredPrefs(storedPrefs()); });
+    // Persistence needs the settings service; without one the provider still runs
+    // and an in-app change stays session-local, as it did before.
     ctx.inject(['settings'], (settingsCtx) => {
-        const scope = settingsCtx.settings.register(TUI_SETTINGS_NAMESPACE, TuiSettingsSchema, { base: { theme: parseThemeName(config.theme), colors: resolveColors(config.colors, term.output.isTTY === true), expandTools: false } });
-        tui.applyStoredPrefs(scope.get());
-        tui.setPrefsPersist((prefs) => { void scope.update(prefs); });
-        scope.watch((next) => { tui.applyStoredPrefs(next); });
+        tui.setPrefsPersist((prefs) => {
+            const ops = Object.entries(prefs).map(([key, value]) => ({ op: 'set', path: [key], value }));
+            void settingsCtx.settings.mutate(TUI_SETTINGS_ENTRY, ops)
+                .catch((error) => { settingsCtx.logger.warn(error); });
+        });
     });
 }
 //# sourceMappingURL=provider-local.js.map