@thegitai/cli 1.0.0-preview.3 → 1.0.0-preview.5

package/dist/src/project-index.js

@@ -39,10 +39,21 @@ function removeFile(index, relPath) {
     index.chunksByFile.delete(relPath);
     index.fileSignatures.delete(relPath);
 }
+function countIndexedChunks(index) {
+    return Array.from(index.chunksByFile.values()).reduce((sum, chunks) => sum + chunks.length, 0);
+}
 async function initializeIndex(index) {
     if (index.initialized) {
-        return Array.from(index.chunksByFile.values()).reduce((sum, chunks) => sum + chunks.length, 0);
+        return countIndexedChunks(index);
+    }
+    if (!index._initializing) {
+        index._initializing = scanProjectIntoIndex(index).finally(() => {
+            index._initializing = null;
+        });
     }
+    return index._initializing;
+}
+async function scanProjectIntoIndex(index) {
     const files = listProjectFiles(index.rootDir);
     const chunks = await scanFiles(index.rootDir, files);
     index.fileSignatures.clear();
@@ -106,6 +117,7 @@ export function createIndex({ rootDir, onStatus = null, onContextLog = null, })
     return {
         rootDir: path.resolve(rootDir),
         initialized: false,
+        _initializing: null,
         fileSignatures: new Map(),
         chunksByFile: new Map(),
         onStatus,

package/dist/src/turn-failure-marker.js

@@ -0,0 +1,11 @@
+const TURN_FAILURE_MARKER_PATTERN = /^Turn failed before completion: ([a-z][a-z0-9_-]*)\.?$/i;
+export function formatTurnFailureMarker(category) {
+    const normalized = category.trim().toLowerCase();
+    const safeCategory = /^[a-z][a-z0-9_-]*$/.test(normalized)
+        ? normalized
+        : 'unknown_error';
+    return `Turn failed before completion: ${safeCategory}.`;
+}
+export function isTurnFailureMarker(text) {
+    return TURN_FAILURE_MARKER_PATTERN.test(text.trim());
+}

package/dist/src/ui/repl.js

@@ -1,6 +1,7 @@
 import { createRatatuiBridge } from './tui/bridge.js';
 import { buildTuiFrame, formatJobElapsed, formatTodoProgress, renderTranscriptEntryLines, } from './tui/build-frame.js';
 import { createTerminalTitleController } from './tui/terminal-title.js';
+import { captureTerminalWrites, releaseTerminalWrites, } from './tui/terminal-writes.js';
 export { getSlashCommandSuggestions } from './tui/build-frame.js';
 import { agentModeLabel, nextAgentMode, } from '../agent-mode.js';
 import { chat, models } from '../api/index.js';
@@ -9,6 +10,7 @@ import { getJobBufferedOutput, getJobOutputPreview, hasRunningBackgroundJobs, ki
 import { clearTodos, listTodos, setTodoSession } from '../todo-list.js';
 import { setScratchSession } from '../scratch-dir.js';
 import { cancelActiveCommand } from '../executor.js';
+import { isTurnFailureMarker } from '../turn-failure-marker.js';
 import { setCommandOutputHook, withTuiMode } from '../runtime-mode.js';
 import { collectBackgroundJobUiKillMutations, collectBackgroundJobUiOutputMutations, } from '../tool-executor.js';
 import { clearConversation, } from '../session.js';
@@ -780,7 +782,7 @@ function displayUserTextFromHistoryEntry(entry) {
         .slice(contentStart, contentEnd === -1 ? text.length : contentEnd)
         .trim();
 }
-function buildTranscriptFromSessionHistory(history) {
+export function buildTranscriptFromSessionHistory(history) {
     const entries = [];
     const pendingCalls = new Map();
     for (const entry of history) {
@@ -826,6 +828,14 @@ function buildTranscriptFromSessionHistory(history) {
         }
         const text = textFromHistoryEntry(entry);
         if ((entry.role === 'model' || entry.role === 'assistant') && text) {
+            if (isTurnFailureMarker(text)) {
+                entries.push({
+                    body: 'This request did not complete.',
+                    kind: 'system',
+                    title: 'Previous turn',
+                });
+                continue;
+            }
             entries.push({ body: text, kind: 'assistant', title: 'Response' });
         }
     }
@@ -1273,17 +1283,12 @@ async function saveSessionBoth({ serverSessionClient, session, }) {
     saveSessionState(session);
     await serverSessionClient.save(session);
 }
-function shouldUseRatatuiShell() {
-    if (process.env.THEGITAI_PLAIN === '1')
-        return false;
-    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
-}
-export function shouldUseClientRatatuiShell() {
-    return shouldUseRatatuiShell();
-}
 export async function runClientInteractive({ appendPromptHistory, authConfig, debugUi, projectIndex, serverModels, serverSessionClient, session, usageText, initialPrompt, }) {
-    if (!shouldUseRatatuiShell()) {
-        throw new Error('Client TUI requires an interactive terminal.');
+    if (process.stdin.isTTY !== true) {
+        throw new Error('stdin is not a terminal');
+    }
+    if (process.stdout.isTTY !== true) {
+        throw new Error('stdout is not a terminal');
     }
     await withTuiMode(async () => {
         setBackgroundJobSession(session.sessionId);
@@ -1299,6 +1304,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         let cleanupSudoPasswordPrompt = null;
         let sudoPasswordBuffer = '';
         const bridge = createRatatuiBridge();
+        captureTerminalWrites();
         const { handleShellKeyEvent } = await import('./tui/shell-input.js');
         let terminalCols = 80;
         let terminalRows = 24;
@@ -1343,7 +1349,9 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 store.update((current) => current.status === status ? { ...current, status: 'Ready' } : current);
             }, 2500);
         };
-        const terminalTitle = createTerminalTitleController();
+        const terminalTitle = createTerminalTitleController({
+            write: (title) => bridge.setTitle(title),
+        });
         const syncTerminalTitle = () => {
             const state = store.getState();
             terminalTitle.sync({
@@ -1649,6 +1657,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 status: 'Exiting...',
             }));
             void bridge.close().then(() => {
+                releaseTerminalWrites();
                 resolveDone?.();
             });
         };
@@ -1968,7 +1977,6 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 syncBackgroundJobsState();
                 setTodoSession(session.sessionId);
                 syncTodosState();
-                await saveActiveSession();
                 syncShellStateFromSession();
                 store.update((next) => ({
                     ...next,
@@ -2228,6 +2236,8 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             activeTurnAbort = turnAbort;
             lastTurnStartedAt = turnStartedAt;
             todosTouchedThisTurn = false;
+            clearTodos();
+            syncTodosState();
             const userEntry = {
                 body: input,
                 kind: 'user',
@@ -2567,6 +2577,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             setTodoSession(null);
             setBackgroundJobUpdateHook(null);
             await bridge.close();
+            releaseTerminalWrites();
             setCommandOutputHook(null);
         }
     });

package/dist/src/ui/tui/bridge.js

@@ -155,6 +155,9 @@ export function createRatatuiBridge() {
         clear() {
             writeParent({ op: 'clear' });
         },
+        setTitle(title) {
+            writeParent({ op: 'title', text: title });
+        },
         async close() {
             if (closed)
                 return;

package/dist/src/ui/tui/build-frame.js

@@ -2,7 +2,7 @@ import { agentModeLabel } from '../../agent-mode.js';
 import { truncate } from '../../utils.js';
 import { formatClientTokenUsage } from '../repl.js';
 import { renderFormattedBodyLines, renderPreformattedBodyLines, } from './markdown-render.js';
-import { line, plainLine, span, wrapText } from './text.js';
+import { displayWidth, line, plainLine, sliceToWidth, span, wrapText, } from './text.js';
 const WORKING_CLOCK_ICON = '◷';
 const BRAILLE_SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴'];
 const TODO_PANEL_MAX_ROWS = 12;
@@ -17,7 +17,7 @@ const OVERLAY_PANEL_MAX_WIDTH = 86;
 const OVERLAY_PANEL_MARGIN_LINES = 2;
 const OVERLAY_BORDER_COLOR = 'yellow';
 const OVERLAY_WARNING_COLOR = 'ansi256(208)';
-const MODEL_PICKER_PANEL_MAX_WIDTH = 120;
+const MODEL_PICKER_PANEL_MAX_WIDTH = 144;
 const MODEL_PICKER_PANEL_MARGIN_LINES = 2;
 const MODEL_PICKER_BORDER_COLOR = 'cyan';
 const MODEL_PICKER_ACCENT_COLOR = 'cyan';
@@ -133,14 +133,14 @@ function diffLinePrefix(kind) {
             return ' ';
     }
 }
-function fitLine(content, maxWidth) {
+export function fitLine(content, maxWidth) {
     if (maxWidth <= 0)
         return '';
-    if (content.length <= maxWidth)
+    if (displayWidth(content) <= maxWidth)
         return content;
     if (maxWidth === 1)
         return '…';
-    return `${content.slice(0, maxWidth - 1)}…`;
+    return `${sliceToWidth(content, maxWidth - 1)}…`;
 }
 export function formatPromptDirectoryLabel(projectRoot, homeDir = process.env.HOME ?? '') {
     const trimmed = String(projectRoot ?? '').trim();
@@ -573,7 +573,7 @@ function buildLiveLines(state, width, spinnerFrame, elapsedSeconds) {
     return lines;
 }
 function lineCharCount(row) {
-    return row.spans.reduce((total, item) => total + [...item.text].length, 0);
+    return row.spans.reduce((total, item) => total + displayWidth(item.text), 0);
 }
 function overlayPanelLine(row, width, color) {
     const padding = Math.max(0, width - lineCharCount(row));
@@ -689,10 +689,15 @@ function modelPickerHeaderLine(innerWidth) {
     }
     return line(modelPickerCell('#', MODEL_PICKER_NUMBER_WIDTH, heading), modelPickerCell('Model', MODEL_PICKER_MODEL_WIDTH, heading), span(MODEL_PICKER_SEPARATOR, { color: 'gray' }), modelPickerCell('Cost', MODEL_PICKER_COST_WIDTH, heading), span(MODEL_PICKER_SEPARATOR, { color: 'gray' }), modelPickerCell('Notes', modelPickerNotesWidth(innerWidth), heading));
 }
-function buildModelPickerPanel(options, selectedIndex, width) {
+function buildModelPickerPanel(options, selectedIndex, width, availableHeight) {
     const panelWidth = Math.max(28, Math.min(width, MODEL_PICKER_PANEL_MAX_WIDTH));
     const innerWidth = Math.max(1, panelWidth - 4);
-    const margin = Array.from({ length: MODEL_PICKER_PANEL_MARGIN_LINES }, () => plainLine(''));
+    const compactBodyLineCount = options.length + 6;
+    const spacerLineCount = Math.max(0, options.length - 1);
+    const useRowSpacing = compactBodyLineCount + spacerLineCount <= availableHeight;
+    const bodyLineCount = compactBodyLineCount + (useRowSpacing ? spacerLineCount : 0);
+    const marginLineCount = Math.max(0, Math.min(MODEL_PICKER_PANEL_MARGIN_LINES, Math.floor((availableHeight - bodyLineCount) / 2)));
+    const margin = Array.from({ length: marginLineCount }, () => plainLine(''));
     const body = [
         modelPickerTopBorder(panelWidth),
         modelPickerPanelSideLine(modelPickerHeaderLine(innerWidth), innerWidth),
@@ -700,6 +705,9 @@ function buildModelPickerPanel(options, selectedIndex, width) {
     ];
     options.forEach((option, index) => {
         body.push(...modelPickerItemLines(option, index === selectedIndex, innerWidth));
+        if (useRowSpacing && index < options.length - 1) {
+            body.push(modelPickerPanelSideLine(plainLine(''), innerWidth));
+        }
     });
     const fullHint = '↑/↓ navigate  •  Enter select  •  Esc cancel';
     const compactHint = '↑/↓  •  enter  •  esc';
@@ -774,7 +782,7 @@ function buildCommandPalettePanel(suggestions, selectedIndex, width) {
     body.push(modelPickerPanelSideLine(plainLine(''), innerWidth), modelPickerPanelSideLine(line(span('─'.repeat(innerWidth), { color: MODEL_PICKER_BORDER_COLOR })), innerWidth), modelPickerPanelSideLine(plainLine('↑/↓ choose  •  Tab or Enter accept  •  Esc cancel', { color: 'gray' }), innerWidth), plainLine(`╰${'─'.repeat(panelWidth - 2)}╯`, { color: MODEL_PICKER_BORDER_COLOR }));
     return [...margin, ...body, ...margin];
 }
-function buildOverlayLines(state, width, nowMs) {
+function buildOverlayLines(state, width, height, nowMs) {
     const lines = [];
     const panelWidth = Math.max(24, Math.min(width, OVERLAY_PANEL_MAX_WIDTH));
     const innerWidth = Math.max(1, panelWidth - 4);
@@ -847,7 +855,7 @@ function buildOverlayLines(state, width, nowMs) {
     }
     if (state.modelPickerOpen) {
         const options = buildModelPickerOptions(state.currentModelId, state.serverModels);
-        lines.push(...buildModelPickerPanel(options, state.modelPickerIndex, width));
+        lines.push(...buildModelPickerPanel(options, state.modelPickerIndex, width, height));
     }
     if (state.jobsPickerOpen) {
         lines.push(...buildJobsPickerLines(state, width, nowMs));
@@ -931,7 +939,7 @@ export function buildTuiFrame(state, cols, rows, spinnerFrame, elapsedSeconds, n
             lines: [...composerLines, plainLine(''), ...composerFooterLines(state)],
         });
     }
-    const overlayLines = buildOverlayLines(state, contentWidth, nowMs);
+    const overlayLines = buildOverlayLines(state, contentWidth, rows, nowMs);
     if (overlayLines.length > 0) {
         sections.push({ kind: 'overlay', lines: overlayLines });
     }

package/dist/src/ui/tui/markdown-render.js

@@ -1,6 +1,8 @@
-import { line, plainLine, span, wrapText } from './text.js';
-const TABLE_BORDER_WIDTH = 2;
-const TABLE_CELL_OVERHEAD_WIDTH = 3;
+import { displayWidth, line, padToWidth, plainLine, sliceToWidth, span, wrapText, wrapToWidth, } from './text.js';
+const MIN_TABLE_COLUMN_WIDTH = 3;
+function tableRowOverhead(columnCount) {
+    return 3 * columnCount + 1;
+}
 function parseInlineSegments(text) {
     const source = String(text ?? '');
     const segments = [];
@@ -110,45 +112,37 @@ function stripInlineFormattingForWidth(text) {
         .replace(/\*\*([^*]+)\*\*/g, '$1');
 }
 function fitTableColumnWidths(columnWidths, maxWidth) {
-    const widths = columnWidths.map((width) => Math.max(3, Math.floor(width)));
-    if (widths.length === 0)
-        return widths;
-    const overhead = TABLE_BORDER_WIDTH + widths.length * TABLE_CELL_OVERHEAD_WIDTH;
-    const budget = Math.max(widths.length * 3, maxWidth - overhead);
-    const total = widths.reduce((sum, width) => sum + width, 0);
-    if (total <= budget)
-        return widths;
-    let remaining = budget;
-    const scaled = widths.map((width) => {
-        const next = Math.max(3, Math.floor((width / total) * budget));
-        remaining -= next;
-        return next;
-    });
-    while (remaining > 0) {
-        let targetIndex = 0;
-        for (let index = 1; index < widths.length; index++) {
-            if (widths[index] - scaled[index] > widths[targetIndex] - scaled[targetIndex]) {
-                targetIndex = index;
-            }
-        }
-        scaled[targetIndex]++;
-        remaining--;
+    const columnCount = columnWidths.length;
+    if (columnCount === 0)
+        return [];
+    const natural = columnWidths.map((width) => Math.max(1, Math.floor(width)));
+    const budget = Math.floor(maxWidth) - tableRowOverhead(columnCount);
+    const total = natural.reduce((sum, width) => sum + width, 0);
+    if (budget >= total)
+        return natural;
+    const floorWidth = Math.max(1, Math.min(MIN_TABLE_COLUMN_WIDTH, Math.floor(budget / columnCount)));
+    const widths = natural.map((width) => Math.min(width, floorWidth));
+    let used = widths.reduce((sum, width) => sum + width, 0);
+    if (used > budget) {
+        const share = Math.max(1, Math.floor(budget / columnCount));
+        for (let index = 0; index < columnCount; index++)
+            widths[index] = share;
+        used = share * columnCount;
     }
-    while (remaining < 0) {
-        let targetIndex = -1;
-        for (let index = 0; index < scaled.length; index++) {
-            if (scaled[index] <= 3)
+    let remaining = budget - used;
+    while (remaining > 0) {
+        let grew = false;
+        for (let index = 0; index < columnCount && remaining > 0; index++) {
+            if (widths[index] >= natural[index])
                 continue;
-            if (targetIndex === -1 || scaled[index] > scaled[targetIndex]) {
-                targetIndex = index;
-            }
+            widths[index]++;
+            remaining--;
+            grew = true;
         }
-        if (targetIndex === -1)
+        if (!grew)
             break;
-        scaled[targetIndex]--;
-        remaining++;
     }
-    return scaled;
+    return widths;
 }
 function normalizeMarkdownTableCells(cells, columnCount) {
     return Array.from({ length: columnCount }, (_, index) => cells[index] ?? '');
@@ -176,7 +170,7 @@ function parseMarkdownTableBlock(lines, startIndex) {
     const normalizedHeaders = normalizeMarkdownTableCells(headers, columnCount);
     const columnWidths = normalizedHeaders.map((header, columnIndex) => {
         const values = [header, ...rows.map((row) => row[columnIndex] ?? '')];
-        return Math.max(3, ...values.map((value) => stripInlineFormattingForWidth(value).length));
+        return Math.max(MIN_TABLE_COLUMN_WIDTH, ...values.map((value) => displayWidth(stripInlineFormattingForWidth(value))));
     });
     return {
         nextIndex,
@@ -280,24 +274,33 @@ function wrapInlineToLines(text, width, bodyColor, prefix = '') {
         rowWidth = 0;
     };
     const appendSpan = (part) => {
-        const current = rows[rows.length - 1];
-        const limit = safeWidth - (indent ? prefix.length : 0);
+        let current = rows[rows.length - 1];
+        const limit = safeWidth - (rows.length === 1 && indent ? displayWidth(prefix) : 0);
         let remaining = part.text;
         while (remaining.length > 0) {
             const room = limit - rowWidth;
             if (room <= 0) {
                 startRow();
+                current = rows[rows.length - 1];
                 continue;
             }
-            if (remaining.length <= room) {
+            const width = displayWidth(remaining);
+            if (width <= room) {
                 current.push(span(remaining, styleFromSpan(part)));
-                rowWidth += remaining.length;
+                rowWidth += width;
                 remaining = '';
                 break;
             }
-            current.push(span(remaining.slice(0, room), styleFromSpan(part)));
-            remaining = remaining.slice(room);
+            const head = sliceToWidth(remaining, room);
+            if (displayWidth(head) > room && current.length > 0) {
+                startRow();
+                current = rows[rows.length - 1];
+                continue;
+            }
+            current.push(span(head, styleFromSpan(part)));
+            remaining = remaining.slice(head.length);
             startRow();
+            current = rows[rows.length - 1];
         }
     };
     for (const segment of segments) {
@@ -316,36 +319,35 @@ function wrapInlineToLines(text, width, bodyColor, prefix = '') {
         return line(...bodySpans);
     });
 }
-function padCell(text, width) {
-    const plain = stripInlineFormattingForWidth(text);
-    if (plain.length >= width)
-        return plain.slice(0, width);
-    return plain + ' '.repeat(width - plain.length);
-}
 function renderTableLines(table, width) {
     const columnWidths = fitTableColumnWidths(table.columnWidths, width);
+    const border = (left, joint, right) => line(span(left +
+        columnWidths.map((colWidth) => '─'.repeat(colWidth + 2)).join(joint) +
+        right, { color: 'cyan', dim: true }));
     const renderRow = (cells, bold) => {
-        const parts = columnWidths.map((colWidth, index) => span(` ${padCell(cells[index] ?? '', colWidth)} `, {
-            color: 'cyan',
-            bold,
-        }));
-        return line(span('│', { color: 'cyan' }), ...parts, span('│', { color: 'cyan' }));
+        const wrapped = columnWidths.map((colWidth, index) => wrapToWidth(stripInlineFormattingForWidth(cells[index] ?? ''), colWidth));
+        const height = Math.max(1, ...wrapped.map((cellLines) => cellLines.length));
+        const rows = [];
+        for (let row = 0; row < height; row++) {
+            const spans = [span('│', { color: 'cyan' })];
+            for (let column = 0; column < columnWidths.length; column++) {
+                const text = wrapped[column]?.[row] ?? '';
+                spans.push(span(` ${padToWidth(text, columnWidths[column])} `, {
+                    color: 'cyan',
+                    bold,
+                }));
+                spans.push(span('│', { color: 'cyan' }));
+            }
+            rows.push(line(...spans));
+        }
+        return rows;
     };
-    const separator = line(span('├' +
-        columnWidths.map((colWidth) => '─'.repeat(colWidth + 2)).join('┼') +
-        '┤', { color: 'cyan', dim: true }));
-    const top = line(span('┌' +
-        columnWidths.map((colWidth) => '─'.repeat(colWidth + 2)).join('┬') +
-        '┐', { color: 'cyan', dim: true }));
-    const bottom = line(span('└' +
-        columnWidths.map((colWidth) => '─'.repeat(colWidth + 2)).join('┴') +
-        '┘', { color: 'cyan', dim: true }));
     return [
-        top,
-        renderRow(table.headers, true),
-        separator,
-        ...table.rows.map((row) => renderRow(row, false)),
-        bottom,
+        border('┌', '┬', '┐'),
+        ...renderRow(table.headers, true),
+        border('├', '┼', '┤'),
+        ...table.rows.flatMap((row) => renderRow(row, false)),
+        border('└', '┴', '┘'),
     ];
 }
 function getEntryColor(kind) {
@@ -410,10 +412,7 @@ export function renderFormattedBodyLines(body, width, kind) {
         }
         if (formattedLine.kind === 'table' && formattedLine.table) {
             output.push(...renderTableLines(formattedLine.table, bodyWidth).map((tableLine) => {
-                const spans = tableLine.spans.map((part) => ({
-                    ...part,
-                    text: `  ${part.text}`,
-                }));
+                const spans = tableLine.spans.map((part, index) => index === 0 ? { ...part, text: `  ${part.text}` } : part);
                 return { spans };
             }));
             continue;

package/dist/src/ui/tui/terminal-title.js

@@ -1,3 +1,4 @@
+import { isTuiMode } from '../../runtime-mode.js';
 const BRAILLE_SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴'];
 const TITLE_BRAND = 'TheGitAI';
 const TITLE_MARK_PREFIX = '❯_';
@@ -19,6 +20,8 @@ export function formatTerminalTitle(state, spinnerFrame = 0) {
     return `${TITLE_MARK_PREFIX}● ${TITLE_BRAND}`;
 }
 export function writeTerminalTitle(title, stream = process.stdout) {
+    if (isTuiMode())
+        return;
     if (!('isTTY' in stream) || !stream.isTTY)
         return;
     stream.write(`\x1b]0;${title}\x07`);

package/dist/src/ui/tui/terminal-writes.js

@@ -0,0 +1,48 @@
+const MAX_CAPTURED_CHARS = 1_000_000;
+let restore = null;
+let captured = [];
+let capturedChars = 0;
+function chunkToString(chunk, encoding) {
+    if (typeof chunk === 'string')
+        return chunk;
+    if (chunk instanceof Uint8Array) {
+        return Buffer.from(chunk).toString(typeof encoding === 'string' ? encoding : 'utf8');
+    }
+    return String(chunk ?? '');
+}
+export function captureTerminalWrites() {
+    if (restore)
+        return;
+    const streams = [process.stdout, process.stderr];
+    const originals = streams.map((stream) => stream.write.bind(stream));
+    for (const stream of streams) {
+        stream.write = (chunk, encoding, callback) => {
+            if (capturedChars < MAX_CAPTURED_CHARS) {
+                const text = chunkToString(chunk, encoding);
+                captured.push(text);
+                capturedChars += text.length;
+            }
+            const done = typeof encoding === 'function' ? encoding : callback;
+            if (typeof done === 'function')
+                done();
+            return true;
+        };
+    }
+    restore = () => {
+        streams.forEach((stream, index) => {
+            stream.write = originals[index];
+        });
+    };
+}
+export function releaseTerminalWrites() {
+    if (!restore)
+        return;
+    restore();
+    restore = null;
+    if (captured.length > 0) {
+        const text = captured.join('');
+        captured = [];
+        capturedChars = 0;
+        process.stderr.write(text);
+    }
+}