openhorse 0.2.22 → 0.2.23

package/dist/tui-ui/runner.js

@@ -8,10 +8,16 @@ const layout_1 = require("./layout");
 const pickers_1 = require("./pickers");
 const render_scheduler_1 = require("./render-scheduler");
 const state_1 = require("./state");
+const input_ownership_1 = require("./input-ownership");
+const transcript_inspector_1 = require("./transcript-inspector");
+const transcript_inspector_layout_1 = require("./transcript-inspector-layout");
 const transcript_cache_1 = require("./transcript-cache");
 const transcript_layout_1 = require("./transcript-layout");
 const theme_1 = require("./theme");
 const history_1 = require("../runtime/composer/history");
+const promises_1 = require("fs/promises");
+const os_1 = require("os");
+const path_1 = require("path");
 /** Actions that should use 'stream' priority (FPS-capped). */
 const STREAM_ACTIONS = new Set([
     'updateTranscript',
@@ -25,20 +31,36 @@ class TuiRunner {
     constructor(options) {
         this.options = options;
         this.parser = new input_parser_1.TuiInputParser();
+        this.inputOwnership = new input_ownership_1.TuiInputOwnershipController();
         this.transcriptCache = new transcript_cache_1.TranscriptLayoutCache();
         this.history = history_1.initialHistoryState;
         this.surfaceFailed = false;
+        this.inspectorReady = false;
+        this.inspectorSearchActive = false;
+        this.modalTransition = Promise.resolve();
+        this.commitSequence = 0;
+        this.commitInFlight = false;
+        this.commitMismatchRetries = 0;
         this.state = state_1.initialTuiUiState;
         this.lastFrame = null;
         this.surfaceResizePending = false;
         this.resizeEpoch = 0;
         this.surfaceResizeGeneration = 0;
-        this.counters = { layoutCount: 0, paintCount: 0, changedRows: 0, commitCount: 0 };
+        this.counters = {
+            layoutCount: 0,
+            paintCount: 0,
+            changedRows: 0,
+            commitCount: 0,
+        };
         this.width = options.width;
         this.height = options.height;
         this.surface = options.surface ?? null;
         this.theme = (0, theme_1.resolveTuiTheme)(options.theme);
         this.themeId = options.themeId ?? theme_1.DEFAULT_TUI_THEME_ID;
+        this.inspectorSurface = options.inspectorSurface ?? null;
+        this.inspectorController = options.detailRepository
+            ? new transcript_inspector_1.TranscriptInspectorController(options.detailRepository, options.cwd ?? process.cwd())
+            : null;
         this.scheduler = (0, render_scheduler_1.createTuiRenderScheduler)(() => this.renderLive(), options.schedulerDeps);
         this.events = (0, state_1.createTuiUiEventSink)(action => this.dispatch(action));
         // Initial render: paint the live region immediately.
@@ -59,6 +81,8 @@ class TuiRunner {
     }
     /** Stop stale-width paints as soon as the terminal reports SIGWINCH. */
     beginResize(width = this.width) {
+        if (this.state.inspector)
+            return;
         if (!this.surface || this.surfaceFailed)
             return;
         this.surfaceResizePending = true;
@@ -66,6 +90,12 @@ class TuiRunner {
         this.surfaceResizeGeneration = this.surface.beginResize(width);
     }
     resize(width, height) {
+        if (this.state.inspector) {
+            this.width = width;
+            this.height = height;
+            this.paintInspector();
+            return;
+        }
         this.beginResize(width);
         const resizeEpoch = this.resizeEpoch;
         const surfaceResizeGeneration = this.surfaceResizeGeneration;
@@ -102,19 +132,16 @@ class TuiRunner {
     dispatch(action) {
         const prevState = this.state;
         this.state = (0, state_1.tuiUiReducer)(this.state, action);
+        if (action.type === 'setToolOutputViewMode' && action.mode !== prevState.toolOutputViewMode) {
+            this.transcriptCache.clear();
+        }
         // Check if any transcript entries became committable (finalized).
         this.tryCommit(prevState);
         const priority = STREAM_ACTIONS.has(action.type) ? 'stream' : 'immediate';
         this.scheduler.request(priority);
     }
     feedInput(chunk) {
-        const raw = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : chunk;
-        if ((0, input_parser_1.isLikelyUnbracketedMultilinePaste)(raw)) {
-            const event = { type: 'paste', value: (0, input_parser_1.normalizePastedText)(raw) };
-            this.applyInputEvent(event);
-            return [event];
-        }
-        const events = this.parser.feed(chunk);
+        const events = this.parser.feed(chunk, { detectUnbracketedMultilinePaste: true });
         for (const event of events) {
             this.applyInputEvent(event);
         }
@@ -143,6 +170,10 @@ class TuiRunner {
      * transcript so tests can inspect complete content via getLastFrame().
      */
     renderLive() {
+        if (this.state.inspector) {
+            this.paintInspector();
+            return;
+        }
         if (this.surface && !this.surfaceFailed) {
             if (this.surfaceResizePending)
                 return;
@@ -188,7 +219,7 @@ class TuiRunner {
      * but not yet queued.
      */
     tryCommit(prevState, force = false) {
-        if (!this.surface || this.surfaceResizePending)
+        if (!this.surface || this.surfaceResizePending || this.state.inspector || this.commitInFlight)
             return;
         const prevCommittable = prevState.committableTranscriptCount;
         const currCommittable = this.state.committableTranscriptCount;
@@ -209,6 +240,7 @@ class TuiRunner {
             rows: this.layoutTranscriptRecord(entry, this.transcriptWidth),
         }));
         const batch = {
+            batchId: `tui-commit-${++this.commitSequence}`,
             generation: this.state.transcriptGeneration,
             reason: 'finalize',
             entries: committedEntries,
@@ -218,38 +250,89 @@ class TuiRunner {
         // live region).
         const generation = batch.generation;
         const getLatestLiveFrame = () => this.buildLiveFrame(this.width);
+        this.commitInFlight = true;
+        let continueCommit = true;
         // Surface commit is async (serialized FIFO). Fire-and-forget: the
         // commit's internal getLatestLiveFrame already rebuilds the live region,
         // so no additional scheduler paint is needed here.
         void this.surface
             .commit(batch, getLatestLiveFrame)
-            .then(() => {
-            if (this.state.transcriptGeneration !== generation)
+            .then(result => {
+            if (result.batchId !== batch.batchId ||
+                result.generation !== generation ||
+                result.committedEntries !== entriesToCommit.length) {
+                if (this.state.transcriptGeneration === generation) {
+                    this.state = {
+                        ...this.state,
+                        queuedTranscriptCount: Math.max(0, this.state.queuedTranscriptCount - entriesToCommit.length),
+                    };
+                    this.commitMismatchRetries += 1;
+                    if (this.commitMismatchRetries > 1) {
+                        continueCommit = false;
+                        this.state = (0, state_1.tuiUiReducer)(this.state, {
+                            type: 'setStatus',
+                            message: 'TUI transcript acknowledgement mismatch; retained content for retry.',
+                        });
+                    }
+                }
+                void this.surface?.forceRedraw(this.buildLiveFrame(this.width));
                 return;
-            this.state = (0, state_1.markTranscriptCommitted)(this.state, entriesToCommit.length);
+            }
+            const acknowledgement = (0, state_1.acknowledgeTranscriptCommit)(this.state, {
+                generation,
+                recordIds: result.displayKeys ?? [],
+            });
+            if (!acknowledgement.accepted) {
+                if (this.state.transcriptGeneration === generation) {
+                    this.state = {
+                        ...this.state,
+                        queuedTranscriptCount: Math.max(0, this.state.queuedTranscriptCount - entriesToCommit.length),
+                    };
+                    this.commitMismatchRetries += 1;
+                    if (this.commitMismatchRetries > 1) {
+                        continueCommit = false;
+                        this.state = (0, state_1.tuiUiReducer)(this.state, {
+                            type: 'setStatus',
+                            message: 'TUI transcript acknowledgement mismatch; retained content for retry.',
+                        });
+                    }
+                }
+                void this.surface?.forceRedraw(this.buildLiveFrame(this.width));
+                return;
+            }
+            this.state = acknowledgement.state;
+            this.commitMismatchRetries = 0;
             this.counters.commitCount += 1;
         })
-            .catch(error => this.handleSurfaceError(error));
+            .catch(error => this.handleSurfaceError(error))
+            .finally(() => {
+            this.commitInFlight = false;
+            if (!this.surfaceFailed && continueCommit)
+                this.tryCommit(this.state, true);
+        });
     }
     /** Layout a transcript record once per revision/width/theme combination. */
     layoutTranscriptRecord(entry, width) {
         const cached = this.transcriptCache.get(entry.id, entry.revision, this.state.transcriptGeneration, width, this.themeId);
         if (cached)
             return cached;
-        const rows = (0, transcript_layout_1.layoutTranscriptEntry)(entry, { width, theme: this.theme });
+        const rows = (0, transcript_layout_1.layoutTranscriptEntry)(entry, {
+            width,
+            theme: this.theme,
+            toolOutputMode: this.state.toolOutputViewMode,
+        });
         this.transcriptCache.set(entry.id, entry.revision, rows, this.state.transcriptGeneration, width, this.themeId);
         return rows;
     }
     get transcriptWidth() {
-        return this.surface
-            ? Math.max(1, this.width - 1)
-            : Math.max(1, this.width);
+        return this.surface ? Math.max(1, this.width - 1) : Math.max(1, this.width);
     }
     transcriptLayoutOptions() {
         return {
             transcriptWidth: this.transcriptWidth,
             theme: this.theme,
-            layoutTranscriptRecord: (entry, width) => (this.layoutTranscriptRecord(entry, width)),
+            toolOutputMode: this.state.toolOutputViewMode,
+            layoutTranscriptRecord: (entry, width) => this.layoutTranscriptRecord(entry, width),
         };
     }
     handleSurfaceError(error) {
@@ -264,6 +347,10 @@ class TuiRunner {
         this.options.onSurfaceError?.(error);
     }
     applyInputEvent(event) {
+        if (this.state.inspector) {
+            this.applyInspectorInput(event);
+            return;
+        }
         if (this.state.overlay?.type === 'permission') {
             if (event.type === 'text') {
                 const answer = event.value.trim().toLowerCase();
@@ -308,10 +395,16 @@ class TuiRunner {
                     this.dispatch({ type: 'moveOverlaySelection', delta: 1 });
                     return;
                 case 'pageup':
-                    this.dispatch({ type: 'moveOverlaySelection', delta: -Math.max(1, overlay.request.maxVisibleItems ?? 10) });
+                    this.dispatch({
+                        type: 'moveOverlaySelection',
+                        delta: -Math.max(1, overlay.request.maxVisibleItems ?? 10),
+                    });
                     return;
                 case 'pagedown':
-                    this.dispatch({ type: 'moveOverlaySelection', delta: Math.max(1, overlay.request.maxVisibleItems ?? 10) });
+                    this.dispatch({
+                        type: 'moveOverlaySelection',
+                        delta: Math.max(1, overlay.request.maxVisibleItems ?? 10),
+                    });
                     return;
                 case 'enter':
                     this.submitPrompt({ allowEmpty: true });
@@ -357,6 +450,11 @@ class TuiRunner {
                     this.completeCommand(overlay.items[overlay.selectedIndex], false);
                     return;
                 case 'enter':
+                    if (/^\/(?:tool-output|redraw)(?:\s|$)/u.test(this.state.prompt.value.trim())) {
+                        this.dispatch({ type: 'closeOverlay' });
+                        this.submitPrompt();
+                        return;
+                    }
                     this.completeCommand(overlay.items[overlay.selectedIndex], true);
                     return;
                 case 'escape':
@@ -415,6 +513,12 @@ class TuiRunner {
             return;
         }
         switch (key) {
+            case 'ctrl+o':
+                this.openToolInspector();
+                return;
+            case 'ctrl+l':
+                this.forceOwnedRedraw();
+                return;
             case 'enter':
                 this.submitPrompt();
                 return;
@@ -472,7 +576,7 @@ class TuiRunner {
     historyBack() {
         if (this.state.overlay)
             return; // overlay handles up/down itself
-        const { value, cursor } = this.state.prompt;
+        const { value } = this.state.prompt;
         const next = (0, history_1.historyPrevious)(this.history, value);
         this.history = next;
         const displayValue = (0, history_1.historyCurrentValue)(next, value);
@@ -537,7 +641,11 @@ class TuiRunner {
         const { value, cursor } = this.state.prompt;
         const { line } = lineColOfCursor(value, cursor);
         const lines = value.split('\n');
-        this.dispatch({ type: 'setPrompt', value, cursor: cursorOfLineCol(value, line, lines[line].length) });
+        this.dispatch({
+            type: 'setPrompt',
+            value,
+            cursor: cursorOfLineCol(value, line, lines[line].length),
+        });
     }
     submitPrompt(options = {}) {
         const input = this.state.prompt.value;
@@ -546,6 +654,8 @@ class TuiRunner {
         // Push to history before clearing.
         this.history = (0, history_1.pushHistoryEntry)(this.history, input);
         this.dispatch({ type: 'setPrompt', value: '', cursor: 0 });
+        if (this.handleLocalCommand(input))
+            return;
         try {
             const submission = this.options.onSubmit?.(input);
             if (submission) {
@@ -559,6 +669,42 @@ class TuiRunner {
     reportSubmitFailure() {
         this.events.append({ role: 'error', content: 'Input submission failed.' });
     }
+    handleLocalCommand(input) {
+        const command = input.trim();
+        if (command === '/redraw') {
+            this.forceOwnedRedraw();
+            return true;
+        }
+        const match = command.match(/^\/tool-output(?:\s+(adaptive|collapsed|full))?$/u);
+        if (match) {
+            const mode = match[1];
+            if (mode)
+                this.dispatch({ type: 'setToolOutputViewMode', mode });
+            this.dispatch({
+                type: 'setStatus',
+                message: `tool output: ${mode ?? this.state.toolOutputViewMode}`,
+            });
+            return true;
+        }
+        if (command.startsWith('/tool-output')) {
+            this.dispatch({
+                type: 'setStatus',
+                message: 'Usage: /tool-output adaptive|collapsed|full',
+            });
+            return true;
+        }
+        return false;
+    }
+    forceOwnedRedraw() {
+        if (this.surface && !this.surfaceFailed) {
+            void this.surface
+                .forceRedraw(this.buildLiveFrame(this.width))
+                .catch(error => this.handleSurfaceError(error));
+            return;
+        }
+        this.lastFrame = null;
+        this.scheduler.request('immediate');
+    }
     updatePrompt(next) {
         this.dispatch({ type: 'setPrompt', value: next.value, cursor: next.cursor });
         this.syncPromptOverlay(next.value);
@@ -571,7 +717,7 @@ class TuiRunner {
             this.dispatch({
                 type: 'showCommandPalette',
                 query: value.slice(1),
-                items: (0, pickers_1.visibleCommandItems)(value),
+                items: visibleTuiCommandItems(value),
             });
             return;
         }
@@ -593,7 +739,8 @@ class TuiRunner {
         if (!item)
             return;
         const command = (0, commands_1.getCommands)().find(candidate => candidate.name === item.value);
-        const needsArgs = Boolean(command?.argumentHint || command?.params?.some(param => param.required));
+        const needsArgs = item.value === 'tool-output' ||
+            Boolean(command?.argumentHint || command?.params?.some(param => param.required));
         const value = `/${item.value}${needsArgs ? ' ' : ''}`;
         const promptAlreadyMatchesCommand = this.state.prompt.value.trim() === `/${item.value}`;
         const nextValue = promptAlreadyMatchesCommand ? `/${item.value}` : value;
@@ -620,6 +767,366 @@ class TuiRunner {
         this.dispatch({ type: 'closeOverlay' });
         void this.options.onPermissionDecision?.(overlay.request.id, approved);
     }
+    /** Restore any temporary Inspector terminal ownership before shutdown. */
+    async closeModalSurface() {
+        if (this.state.inspector || this.inspectorSurface?.isMounted) {
+            this.closeToolInspector();
+        }
+        await this.modalTransition;
+    }
+    /** Wait until the current Inspector ownership transition is complete. */
+    async waitForModalSurface() {
+        await this.modalTransition;
+    }
+    /** Flush every finalized transcript batch, including batches queued by acknowledgements. */
+    async flushTranscriptCommits() {
+        if (!this.surface || this.surfaceFailed)
+            return;
+        for (let attempt = 0; attempt < 1024; attempt += 1) {
+            await this.surface.whenIdle();
+            await Promise.resolve();
+            if (!this.commitInFlight && (0, state_1.pendingCommitRecords)(this.state).length === 0)
+                return;
+            if (!this.commitInFlight)
+                this.tryCommit(this.state, true);
+        }
+        throw new Error('TUI transcript commits did not settle');
+    }
+    openToolInspector() {
+        if (this.state.inspector || !this.inspectorController || !this.inspectorSurface)
+            return;
+        this.inputOwnership.capture('inspector', {
+            value: this.state.prompt.value,
+            cursor: this.state.prompt.cursor,
+            parserState: this.parser.getState(),
+        });
+        this.state = (0, state_1.tuiUiReducer)(this.state, { type: 'openToolInspector' });
+        this.inspectorReady = false;
+        this.inspectorSearchActive = false;
+        this.modalTransition = this.modalTransition
+            .then(async () => {
+            await this.surface?.suspend();
+            this.inspectorReady = true;
+            await this.inspectorSurface.mount(this.buildInspectorFrame());
+        })
+            .catch(error => this.handleSurfaceError(error));
+    }
+    closeToolInspector() {
+        if (!this.state.inspector && !this.inspectorSurface?.isMounted)
+            return;
+        this.inspectorController?.cancel();
+        this.state = (0, state_1.tuiUiReducer)(this.state, { type: 'closeToolInspector' });
+        const snapshot = this.inputOwnership.restore();
+        if (snapshot) {
+            this.parser.setState(snapshot.parserState);
+            this.state = (0, state_1.tuiUiReducer)(this.state, {
+                type: 'setPrompt',
+                value: snapshot.value,
+                cursor: snapshot.cursor,
+            });
+        }
+        this.inspectorReady = false;
+        this.inspectorSearchActive = false;
+        this.modalTransition = this.modalTransition
+            .then(async () => {
+            await this.inspectorSurface?.unmount();
+            if (this.surface) {
+                await this.surface.restore(() => this.buildLiveFrame(this.width), this.width, this.height);
+            }
+            this.scheduler.request('immediate');
+        })
+            .catch(error => this.handleSurfaceError(error));
+    }
+    applyInspectorInput(event) {
+        if (event.type === 'paste')
+            return;
+        if (event.type === 'text') {
+            if (!this.inspectorSearchActive) {
+                if (event.value === 'j') {
+                    this.moveInspectorSelection(1);
+                    return;
+                }
+                if (event.value === 'k') {
+                    this.moveInspectorSelection(-1);
+                    return;
+                }
+                if (event.value === ' ') {
+                    void this.loadSelectedInspectorDetail(false);
+                    return;
+                }
+                if (event.value === 'g') {
+                    this.moveInspectorSelectionTo('first');
+                    return;
+                }
+                if (event.value === 'G') {
+                    this.moveInspectorSelectionTo('last');
+                    return;
+                }
+                if (event.value === 'n' && this.state.inspector?.searchQuery) {
+                    this.moveInspectorSelection(1, true);
+                    return;
+                }
+                if (event.value === 'N' && this.state.inspector?.searchQuery) {
+                    this.moveInspectorSelection(-1, true);
+                    return;
+                }
+                if (event.value === 'v') {
+                    this.openSelectedInspectorDetailInEditor();
+                    return;
+                }
+            }
+            if (!this.inspectorSearchActive && (event.value === 'q' || event.value === 'Q')) {
+                this.closeToolInspector();
+                return;
+            }
+            if (!this.inspectorSearchActive && event.value === '/') {
+                this.inspectorSearchActive = true;
+                this.state = (0, state_1.tuiUiReducer)(this.state, { type: 'setToolInspectorSearch', query: '' });
+                this.paintInspector();
+                return;
+            }
+            if (!this.inspectorSearchActive && event.value === '[') {
+                this.exportInspectorResults();
+                return;
+            }
+            if (this.inspectorSearchActive) {
+                const query = `${this.state.inspector?.searchQuery ?? ''}${event.value}`;
+                this.state = (0, state_1.tuiUiReducer)(this.state, { type: 'setToolInspectorSearch', query });
+                this.paintInspector();
+            }
+            return;
+        }
+        switch (event.key) {
+            case 'ctrl+o':
+            case 'escape':
+                this.closeToolInspector();
+                return;
+            case 'ctrl+c':
+                this.closeToolInspector();
+                return;
+            case 'up':
+                this.moveInspectorSelection(-1);
+                return;
+            case 'down':
+                this.moveInspectorSelection(1);
+                return;
+            case 'pageup':
+            case 'ctrl+u':
+                this.state = (0, state_1.tuiUiReducer)(this.state, { type: 'scrollToolInspector', delta: -10 });
+                this.paintInspector();
+                return;
+            case 'pagedown':
+            case 'ctrl+d':
+                this.state = (0, state_1.tuiUiReducer)(this.state, { type: 'scrollToolInspector', delta: 10 });
+                void this.loadSelectedInspectorDetail(true);
+                return;
+            case 'home':
+                this.moveInspectorSelectionTo('first');
+                return;
+            case 'end':
+                this.moveInspectorSelectionTo('last');
+                return;
+            case 'backspace': {
+                if (!this.inspectorSearchActive)
+                    return;
+                const query = this.state.inspector?.searchQuery ?? '';
+                this.state = (0, state_1.tuiUiReducer)(this.state, {
+                    type: 'setToolInspectorSearch',
+                    query: query.slice(0, -1),
+                });
+                this.paintInspector();
+                return;
+            }
+            case 'enter':
+                if (this.inspectorSearchActive) {
+                    this.inspectorSearchActive = false;
+                    this.paintInspector();
+                    return;
+                }
+                void this.loadSelectedInspectorDetail(false);
+                return;
+            case 'ctrl+e':
+                this.state = (0, state_1.tuiUiReducer)(this.state, { type: 'toggleAllToolInspectorEntries' });
+                this.paintInspector();
+                return;
+            case 'ctrl+l':
+                this.paintInspector();
+                return;
+        }
+    }
+    async loadSelectedInspectorDetail(append) {
+        const inspector = this.state.inspector;
+        if (!inspector || !this.inspectorController)
+            return;
+        const view = this.inspectorController.view(this.state.recentToolDetails, inspector);
+        const selected = view.selected;
+        if (!selected)
+            return;
+        const expanded = inspector.expandedCallIds.includes(selected.callId);
+        if (!append && expanded) {
+            this.state = (0, state_1.tuiUiReducer)(this.state, {
+                type: 'toggleToolInspectorEntry',
+                callId: selected.callId,
+            });
+            this.paintInspector();
+            return;
+        }
+        if (!expanded) {
+            this.state = (0, state_1.tuiUiReducer)(this.state, {
+                type: 'toggleToolInspectorEntry',
+                callId: selected.callId,
+            });
+        }
+        this.paintInspector();
+        await this.inspectorController.load(selected, append && view.detail?.nextOffsetBytes !== undefined);
+        if (this.state.inspector)
+            this.paintInspector();
+    }
+    moveInspectorSelection(delta, wrap = false) {
+        const inspector = this.state.inspector;
+        if (!inspector || !this.inspectorController)
+            return;
+        const view = this.inspectorController.view(this.state.recentToolDetails, inspector);
+        if (view.entries.length === 0)
+            return;
+        const target = wrap
+            ? (view.selectedIndex + delta + view.entries.length) % view.entries.length
+            : Math.max(0, Math.min(view.entries.length - 1, view.selectedIndex + delta));
+        this.inspectorController.cancel();
+        this.state = (0, state_1.tuiUiReducer)(this.state, { type: 'setToolInspectorSelection', index: target });
+        this.paintInspector();
+    }
+    moveInspectorSelectionTo(edge) {
+        const inspector = this.state.inspector;
+        if (!inspector || !this.inspectorController)
+            return;
+        const view = this.inspectorController.view(this.state.recentToolDetails, inspector);
+        if (view.entries.length === 0)
+            return;
+        this.inspectorController.cancel();
+        this.state = (0, state_1.tuiUiReducer)(this.state, {
+            type: 'setToolInspectorSelection',
+            index: edge === 'first' ? 0 : view.entries.length - 1,
+        });
+        this.paintInspector();
+    }
+    exportInspectorResults() {
+        const inspector = this.state.inspector;
+        if (!inspector || !this.inspectorController)
+            return;
+        const entries = this.inspectorController.view(this.state.recentToolDetails, inspector).entries;
+        this.closeToolInspector();
+        this.modalTransition = this.modalTransition
+            .then(async () => {
+            if (!this.surface) {
+                this.state = (0, state_1.tuiUiReducer)(this.state, {
+                    type: 'setStatus',
+                    message: 'Inspector export requires an inline terminal surface.',
+                });
+                return;
+            }
+            for (const entry of entries) {
+                let pageIndex = 0;
+                for await (const page of this.inspectorController.readPages(entry)) {
+                    const heading = pageIndex === 0 ? `#${entry.sequence} ${entry.toolName}\n` : '';
+                    const rows = (0, transcript_layout_1.layoutTranscriptEntry)({
+                        role: 'tool',
+                        content: `${heading}${page.content}`,
+                    }, {
+                        width: this.transcriptWidth,
+                        theme: this.theme,
+                        toolOutputMode: 'full',
+                    });
+                    await this.surface.commit({
+                        batchId: `tui-inspector-export-${++this.commitSequence}`,
+                        generation: this.state.transcriptGeneration,
+                        reason: 'append',
+                        entries: [
+                            {
+                                displayKey: `inspector-export-${entry.callId}-${pageIndex}`,
+                                rows,
+                            },
+                        ],
+                    }, () => this.buildLiveFrame(this.width));
+                    pageIndex += 1;
+                }
+            }
+            this.state = (0, state_1.tuiUiReducer)(this.state, {
+                type: 'setStatus',
+                message: `Exported ${entries.length} tool result${entries.length === 1 ? '' : 's'} to scrollback.`,
+            });
+            this.scheduler.request('immediate');
+        })
+            .catch(error => this.handleSurfaceError(error));
+    }
+    openSelectedInspectorDetailInEditor() {
+        const inspector = this.state.inspector;
+        if (!inspector || !this.inspectorController)
+            return;
+        const selected = this.inspectorController.view(this.state.recentToolDetails, inspector).selected;
+        if (!selected)
+            return;
+        if (!this.options.onOpenExternalEditor) {
+            this.state = (0, state_1.tuiUiReducer)(this.state, {
+                type: 'setStatus',
+                message: 'External editor is unavailable in this TUI environment.',
+            });
+            this.paintInspector();
+            return;
+        }
+        this.closeToolInspector();
+        this.modalTransition = this.modalTransition
+            .then(async () => {
+            const directory = await (0, promises_1.mkdtemp)((0, path_1.join)((0, os_1.tmpdir)(), 'openhorse-tool-'));
+            const filePath = (0, path_1.join)(directory, `${selected.sequence}-${safeFileName(selected.toolName)}.txt`);
+            try {
+                await this.inspectorController.writeDetailToFile(selected, filePath);
+                await this.options.onOpenExternalEditor(filePath);
+                this.state = (0, state_1.tuiUiReducer)(this.state, {
+                    type: 'setStatus',
+                    message: `Viewed #${selected.sequence} ${selected.toolName} in external editor.`,
+                });
+            }
+            finally {
+                await (0, promises_1.rm)(directory, { recursive: true, force: true });
+            }
+            this.forceOwnedRedraw();
+        })
+            .catch(error => {
+            this.state = (0, state_1.tuiUiReducer)(this.state, {
+                type: 'setStatus',
+                message: `External editor failed: ${error instanceof Error ? error.message : String(error)}`,
+            });
+            this.forceOwnedRedraw();
+        });
+    }
+    paintInspector() {
+        if (!this.state.inspector ||
+            !this.inspectorController ||
+            !this.inspectorSurface ||
+            !this.inspectorReady)
+            return;
+        const frame = this.buildInspectorFrame();
+        this.lastFrame = frame;
+        void this.inspectorSurface.paint(frame).catch(error => this.handleSurfaceError(error));
+    }
+    buildInspectorFrame() {
+        const inspector = this.state.inspector;
+        const view = inspector && this.inspectorController
+            ? this.inspectorController.view(this.state.recentToolDetails, inspector)
+            : {
+                entries: [],
+                selectedIndex: 0,
+                expandedCallIds: [],
+                searchQuery: '',
+                detailOffset: 0,
+            };
+        return (0, transcript_inspector_layout_1.renderTranscriptInspectorFrame)(view, {
+            width: this.width,
+            height: this.height,
+            theme: this.theme,
+        });
+    }
 }
 exports.TuiRunner = TuiRunner;
 function insertAtCursor(value, cursor, text) {
@@ -629,6 +1136,28 @@ function insertAtCursor(value, cursor, text) {
         cursor: safeCursor + text.length,
     };
 }
+function visibleTuiCommandItems(input) {
+    const query = input.startsWith('/')
+        ? input.slice(1).trim().split(/\s+/u, 1)[0].toLowerCase()
+        : '';
+    const local = [
+        {
+            value: 'tool-output',
+            label: '/tool-output',
+            description: 'Set TUI tool output mode',
+        },
+        {
+            value: 'redraw',
+            label: '/redraw',
+            description: 'Redraw the TUI-owned live region',
+        },
+    ].filter(item => item.value.includes(query));
+    const localNames = new Set(local.map(item => item.value));
+    return [...local, ...(0, pickers_1.visibleCommandItems)(input).filter(item => !localNames.has(item.value))];
+}
+function safeFileName(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/gu, '-').replace(/^-+|-+$/gu, '') || 'tool';
+}
 function deleteBeforeCursor(value, cursor) {
     const safeCursor = clampCursor(value, cursor);
     if (safeCursor === 0)