deepclause-sdk 0.0.73 → 0.0.75

package/dist/cli/tui.js

@@ -7,10 +7,11 @@ import { listCommands } from './commands.js';
 import { getConfigPath, loadConfig, resolveModelSlot, setModel } from './config.js';
 import { run } from './run.js';
 import { formatToolArgs } from './tool-args.js';
-import { appendConductorSessionMessages, createSessionExecutionLogWriter, createLocalSkill, createConductorSession, getConductorSessionDetail, listConductorSessions, runConductorTurn, } from '../system/runtime/conductor.js';
+import { appendConductorSessionMessages, createSessionExecutionLogWriter, createLocalSkill, createConductorSession, getConductorSessionDetail, listConductorSessions, mergeSessionUsage, runConductorTurn, } from '../system/runtime/conductor.js';
 import { getSystemAssetSourcePaths } from '../system/assets/index.js';
 import { createShellManager, describeShellExecutionBackend, } from '../system/runtime/shell-manager.js';
 import { buildToolCompletionEvent, buildToolFailureEvent, buildToolStartEvent, createShellToolEventBridge, } from '../system/runtime/shell-tool-events.js';
+import { recordTokenUsage } from '../system/runtime/token-usage.js';
 const IGNORED_LIVE_LOG_TOOLS = new Set(['set_result', 'update_memory']);
 const BUILTIN_SLASH_COMMANDS = ['new', 'sessions', 'help', 'run', 'compile', 'skill-creator', 'set-model', 'cancel', 'exit', 'quit'];
 const MODEL_SLOTS = ['gateway', 'run', 'compile'];
@@ -305,6 +306,67 @@ export function releaseTuiInputStream(stream) {
     }
     stream.pause();
 }
+class MouseParser {
+    buffer = '';
+    feed(data, onEvent) {
+        this.buffer += data.toString('utf8');
+        while (this.buffer.length > 0) {
+            const mouseStart = this.buffer.indexOf('\u001b[<');
+            if (mouseStart === -1) {
+                if (this.buffer.length > 0) {
+                    this.buffer = '';
+                }
+                break;
+            }
+            this.buffer = this.buffer.slice(mouseStart);
+            const parsed = this.tryParseMouse();
+            if (parsed === null) {
+                if (this.buffer.length > 256) {
+                    this.buffer = '';
+                }
+                break;
+            }
+            onEvent(parsed);
+        }
+    }
+    tryParseMouse() {
+        const mIdx = this.buffer.indexOf('M', 3);
+        const mIdxSgr = this.buffer.indexOf('m', 3);
+        const end = mIdx !== -1 && (mIdxSgr === -1 || mIdx < mIdxSgr) ? mIdx : mIdxSgr;
+        if (end === -1)
+            return null;
+        const payload = this.buffer.slice(3, end);
+        const isRelease = this.buffer[end] === 'm';
+        this.buffer = this.buffer.slice(end + 1);
+        const semicolon = payload.indexOf(';');
+        if (semicolon === -1)
+            return null;
+        const secondSemicolon = payload.indexOf(';', semicolon + 1);
+        if (secondSemicolon === -1)
+            return null;
+        const cb = Number.parseInt(payload.slice(0, semicolon), 10);
+        const col = Number.parseInt(payload.slice(semicolon + 1, secondSemicolon), 10);
+        const row = Number.parseInt(payload.slice(secondSemicolon + 1), 10);
+        if (Number.isNaN(cb) || Number.isNaN(col) || Number.isNaN(row))
+            return null;
+        const shift = (cb & 4) !== 0;
+        const meta = (cb & 8) !== 0;
+        const ctrl = (cb & 16) !== 0;
+        const buttonCode = cb & 3;
+        if (isRelease) {
+            return { button: 'release', row, column: col, shift, ctrl, meta };
+        }
+        if ((cb & 64) !== 0) {
+            return { button: buttonCode === 0 ? 'wheel-up' : 'wheel-down', row, column: col, shift, ctrl, meta };
+        }
+        const isMotion = (cb & 32) !== 0;
+        if (isMotion) {
+            return { button: 'motion', row, column: col, shift, ctrl, meta };
+        }
+        const buttonMap = { 0: 'left', 1: 'middle', 2: 'right' };
+        return { button: buttonMap[buttonCode] ?? 'left', row, column: col, shift, ctrl, meta };
+    }
+}
 class FullscreenTui {
     workspaceRoot;
     options;
@@ -329,8 +391,21 @@ class FullscreenTui {
         process: 0,
         context: 0,
     };
+    lastPaneMetrics = {
+        sessions: { maxStart: 0, viewportLines: 0, maxStartIsExact: true },
+        messages: { maxStart: 0, viewportLines: 0, maxStartIsExact: true },
+        process: { maxStart: 0, viewportLines: 0, maxStartIsExact: true },
+        context: { maxStart: 0, viewportLines: 0, maxStartIsExact: true },
+    };
     currentPreview = null;
     currentAbortController = null;
+    toolAbortController = null;
+    toolAbortSignalRef = {};
+    mouseParser = null;
+    mouseDataHandler = null;
+    mouseEscapeState = 'idle';
+    selection = null;
+    isDraggingSelection = false;
     inputValue = '';
     cursor = 0;
     busy = false;
@@ -350,6 +425,8 @@ class FullscreenTui {
     lastRenderAt = 0;
     previousFrameLines = null;
     previousFrameSize = null;
+    resizeHandler = null;
+    wrapCache = new Map();
     constructor(workspaceRoot, options = {}) {
         this.workspaceRoot = workspaceRoot;
         this.options = options;
@@ -360,12 +437,22 @@ class FullscreenTui {
             await this.refreshCommands();
             await this.refreshSessions({ createIfMissing: true });
             this.statusLine = `Ready. Shell ${this.getShellBackend().backendLabel} in ${path.relative(this.workspaceRoot, this.shellWorkspacePath) || '.'}. F10 or Ctrl+G opens menus. Left/right changes pane when the menu is closed.`;
-            emitKeypressEvents(input);
             if (input.isTTY) {
                 input.setRawMode(true);
             }
+            emitKeypressEvents(input);
             input.on('keypress', this.onKeypress);
-            output.write('\u001b[?1049h\u001b[2J\u001b[H');
+            this.mouseParser = new MouseParser();
+            this.mouseDataHandler = (chunk) => {
+                this.mouseParser.feed(chunk, (event) => this.handleMouseEvent(event));
+            };
+            input.prependListener('data', this.mouseDataHandler);
+            this.resizeHandler = () => {
+                this.wrapCache.clear();
+                this.requestRender();
+            };
+            output.on('resize', this.resizeHandler);
+            output.write('\u001b[?1049h\u001b[?1002h\u001b[?1006h\u001b[2J\u001b[H');
             this.requestRender();
             await new Promise((resolve) => {
                 this.closeResolver = resolve;
@@ -380,16 +467,315 @@ class FullscreenTui {
                 clearInterval(this.animationTimer);
                 this.animationTimer = null;
             }
-            input.off('keypress', this.onKeypress);
+            if (this.mouseDataHandler) {
+                input.removeListener('data', this.mouseDataHandler);
+                this.mouseDataHandler = null;
+            }
+            this.mouseParser = null;
+            input.removeListener('keypress', this.onKeypress);
+            if (this.resizeHandler) {
+                output.off('resize', this.resizeHandler);
+                this.resizeHandler = null;
+            }
             releaseTuiInputStream(input);
             this.previousFrameLines = null;
             this.previousFrameSize = null;
-            output.write('\u001b[?25h\u001b[?1049l');
+            output.write('\u001b[?25h\u001b[?1006l\u001b[?1002l\u001b[?1049l');
         }
     }
     onKeypress = (text, key) => {
+        if (key.sequence === '\x1b[<') {
+            this.mouseEscapeState = 'consuming';
+            return;
+        }
+        if (this.mouseEscapeState === 'consuming') {
+            if (text === 'M' || text === 'm') {
+                this.mouseEscapeState = 'idle';
+            }
+            return;
+        }
         void this.handleKeypress(text, key);
     };
+    handleMouseEvent(event) {
+        if (event.button === 'wheel-up' || event.button === 'wheel-down') {
+            if (event.shift)
+                return;
+            const direction = event.button === 'wheel-up' ? 'up' : 'down';
+            const paneKind = this.paneKindAtPosition(event.row, event.column);
+            if (paneKind) {
+                this.focusedPane = paneKind;
+            }
+            this.scrollFocusedPane(direction, 3);
+            return;
+        }
+        if (event.button === 'left' && !event.shift && !event.ctrl && !event.meta) {
+            const menuIndex = this.menuIndexAtColumn(event.column);
+            if (menuIndex !== null && event.row === 1) {
+                this.clearSelection();
+                if (this.uiMode !== 'menu') {
+                    this.uiMode = 'menu';
+                }
+                this.menuState.activeIndex = menuIndex;
+                this.menuState.selectedIndex = 0;
+                this.menuState.typeahead = '';
+                this.requestRender();
+                return;
+            }
+            if (this.uiMode === 'menu' && event.row >= 2) {
+                const menuItemIndex = this.menuItemAtRow(event.row);
+                if (menuItemIndex !== null) {
+                    this.menuState.selectedIndex = menuItemIndex;
+                    this.requestRender();
+                    void this.activateCurrentMenuItem();
+                    return;
+                }
+            }
+            const paneKind = this.paneKindAtPosition(event.row, event.column);
+            if (!paneKind) {
+                this.clearSelection();
+                this.requestRender();
+                return;
+            }
+            const panePos = this.paneContentPosition(paneKind, event.row, event.column);
+            if (!panePos) {
+                this.clearSelection();
+                this.focusedPane = paneKind;
+                this.requestRender();
+                return;
+            }
+            this.selection = { pane: paneKind, startRow: panePos.bodyRow, startCol: panePos.innerCol, endRow: panePos.bodyRow, endCol: panePos.innerCol };
+            this.isDraggingSelection = true;
+            this.focusedPane = paneKind;
+            this.requestRender();
+            return;
+        }
+        if (event.button === 'motion' && !event.shift && this.isDraggingSelection && this.selection) {
+            const paneKind = this.paneKindAtPosition(event.row, event.column);
+            if (paneKind && paneKind === this.selection.pane) {
+                const panePos = this.paneContentPosition(paneKind, event.row, event.column);
+                if (panePos) {
+                    this.selection.endRow = panePos.bodyRow;
+                    this.selection.endCol = panePos.innerCol;
+                    this.requestRender();
+                }
+            }
+            return;
+        }
+        if (event.button === 'release' && !event.shift && this.isDraggingSelection) {
+            this.isDraggingSelection = false;
+            if (this.selection) {
+                const text = this.extractSelectionText();
+                if (text) {
+                    this.copyToClipboard(text);
+                    this.statusLine = 'Copied selection to clipboard.';
+                }
+            }
+            this.clearSelection();
+            this.requestRender();
+            return;
+        }
+        if (event.button === 'release') {
+            this.isDraggingSelection = false;
+            return;
+        }
+    }
+    clearSelection() {
+        if (this.selection) {
+            this.selection = null;
+        }
+        this.isDraggingSelection = false;
+    }
+    paneContentPosition(paneKind, screenRow, screenCol) {
+        const columns = output.columns ?? 120;
+        const rows = output.rows ?? 40;
+        if (screenRow < 2 || screenRow >= rows - 1)
+            return null;
+        if (this.uiMode !== 'command')
+            return null;
+        const contentHeight = rows - 3;
+        const widths = computePaneWidths(columns);
+        const rightHeights = computeRightPaneHeights(contentHeight);
+        const contentRow = screenRow - 2;
+        let paneLeft;
+        let paneWidth;
+        let paneTop;
+        switch (paneKind) {
+            case 'sessions':
+                paneLeft = 0;
+                paneWidth = widths.left;
+                paneTop = 0;
+                break;
+            case 'messages':
+                paneLeft = widths.left + 1;
+                paneWidth = widths.center;
+                paneTop = 0;
+                break;
+            case 'process':
+                paneLeft = widths.left + 1 + widths.center + 1;
+                paneWidth = widths.right;
+                paneTop = 0;
+                break;
+            case 'context':
+                paneLeft = widths.left + 1 + widths.center + 1;
+                paneWidth = widths.right;
+                paneTop = rightHeights.process;
+                break;
+        }
+        if (screenCol < paneLeft + 2 || screenCol > paneLeft + paneWidth - 1)
+            return null;
+        const bodyRow = contentRow - paneTop - 1;
+        if (bodyRow < 0)
+            return null;
+        const innerCol = screenCol - paneLeft - 2;
+        return { bodyRow, innerCol };
+    }
+    extractSelectionText() {
+        if (!this.selection)
+            return '';
+        const sel = this.selection;
+        const paneBody = this.getPaneBody(sel.pane);
+        const columns = output.columns ?? 120;
+        const widths = computePaneWidths(columns);
+        const width = sel.pane === 'sessions' ? widths.left : sel.pane === 'messages' ? widths.center : widths.right;
+        const innerWidth = Math.max(1, width - 2);
+        const wrappedLines = wrapBodyLines(paneBody, innerWidth);
+        const startRow = Math.min(sel.startRow, sel.endRow);
+        const endRow = Math.max(sel.startRow, sel.endRow);
+        const startCol = sel.startRow <= sel.endRow ? sel.startCol : sel.endCol;
+        const endCol = sel.startRow <= sel.endRow ? sel.endCol : sel.startCol;
+        if (startRow === endRow) {
+            const line = wrappedLines[startRow] ?? '';
+            return this.stripAnsi(line.slice(startCol, endCol + 1));
+        }
+        const parts = [];
+        const firstLine = wrappedLines[startRow] ?? '';
+        parts.push(this.stripAnsi(firstLine.slice(startCol)));
+        for (let row = startRow + 1; row < endRow; row++) {
+            parts.push(this.stripAnsi(wrappedLines[row] ?? ''));
+        }
+        const lastLine = wrappedLines[endRow] ?? '';
+        parts.push(this.stripAnsi(lastLine.slice(0, endCol + 1)));
+        return parts.join('\n');
+    }
+    stripAnsi(text) {
+        return text.replace(/\u001b\[[0-9;]*m/g, '');
+    }
+    copyToClipboard(text) {
+        const osc52 = `\u001b]52;c;${Buffer.from(text).toString('base64')}\u0007`;
+        output.write(osc52);
+    }
+    applySelectionHighlight(lines, widths, rightHeights, _contentHeight) {
+        const sel = this.selection;
+        if (!sel)
+            return;
+        const startRow = Math.min(sel.startRow, sel.endRow);
+        const endRow = Math.max(sel.startRow, sel.endRow);
+        const startCol = sel.startRow <= sel.endRow ? sel.startCol : sel.endCol;
+        const endCol = sel.startRow <= sel.endRow ? sel.endCol : sel.startCol;
+        let paneLeft;
+        let paneWidth;
+        let paneTop;
+        switch (sel.pane) {
+            case 'sessions':
+                paneLeft = 0;
+                paneWidth = widths.left;
+                paneTop = 0;
+                break;
+            case 'messages':
+                paneLeft = widths.left + 1;
+                paneWidth = widths.center;
+                paneTop = 0;
+                break;
+            case 'process':
+                paneLeft = widths.left + 1 + widths.center + 1;
+                paneWidth = widths.right;
+                paneTop = 0;
+                break;
+            case 'context':
+                paneLeft = widths.left + 1 + widths.center + 1;
+                paneWidth = widths.right;
+                paneTop = rightHeights.process;
+                break;
+        }
+        const innerDisplayStart = paneLeft + 1;
+        const innerDisplayEnd = paneLeft + paneWidth - 2;
+        for (let bodyRow = startRow; bodyRow <= endRow; bodyRow++) {
+            const screenLineIdx = 1 + paneTop + 1 + bodyRow;
+            if (screenLineIdx >= lines.length)
+                break;
+            const line = lines[screenLineIdx];
+            const rowStartCol = bodyRow === startRow ? innerDisplayStart + startCol : innerDisplayStart;
+            const rowEndCol = bodyRow === endRow ? innerDisplayStart + endCol + 1 : innerDisplayEnd + 1;
+            const clampedStartCol = Math.max(innerDisplayStart, rowStartCol);
+            const clampedEndCol = Math.min(innerDisplayEnd + 1, rowEndCol);
+            if (clampedStartCol >= clampedEndCol)
+                continue;
+            const strStart = displayColumnToStringIndex(line, clampedStartCol);
+            const strEnd = displayColumnToStringIndex(line, clampedEndCol);
+            const before = line.slice(0, strStart);
+            const segment = line.slice(strStart, strEnd);
+            const after = line.slice(strEnd);
+            const highlighted = this.invertAnsiColors(segment);
+            lines[screenLineIdx] = `${before}${highlighted}${after}`;
+        }
+    }
+    invertAnsiColors(text) {
+        return `\u001b[7m${text}\u001b[27m`;
+    }
+    paneKindAtPosition(row, column) {
+        const columns = output.columns ?? 120;
+        const rows = output.rows ?? 40;
+        if (row < 2 || row >= rows - 1)
+            return null;
+        if (this.uiMode !== 'command')
+            return null;
+        const widths = computePaneWidths(columns);
+        const rightHeights = computeRightPaneHeights(rows - 3);
+        const contentRow = row - 1;
+        if (column <= widths.left)
+            return 'sessions';
+        if (column <= widths.left + 1 + widths.center)
+            return 'messages';
+        if (contentRow <= rightHeights.process)
+            return 'process';
+        return 'context';
+    }
+    menuIndexAtColumn(column) {
+        const menuLabels = ['Session', 'Skills', 'Files', 'Run', 'View', 'Help'];
+        let pos = 1 + measureDisplayWidth(' DeepClause ');
+        for (let i = 0; i < menuLabels.length; i++) {
+            const labelWidth = measureDisplayWidth(` [${i + 1}] ${menuLabels[i]} `);
+            if (column >= pos && column < pos + labelWidth)
+                return i;
+            pos += labelWidth;
+        }
+        return null;
+    }
+    menuItemAtRow(row) {
+        if (this.uiMode !== 'menu')
+            return null;
+        const contentRow = row - 2;
+        if (contentRow < 2)
+            return null;
+        const itemRow = contentRow - 2;
+        if (itemRow < 0)
+            return null;
+        const linesPerItem = 3;
+        const itemIndex = Math.floor(itemRow / linesPerItem);
+        const menu = this.getMenuDefinitions()[this.menuState.activeIndex];
+        if (!menu || itemIndex >= menu.items.length || itemIndex < 0)
+            return null;
+        return itemIndex;
+    }
+    async activateCurrentMenuItem() {
+        const menu = this.getMenuDefinitions()[this.menuState.activeIndex];
+        if (!menu)
+            return;
+        const item = menu.items[this.menuState.selectedIndex];
+        if (!item || item.enabled === false)
+            return;
+        await this.runMenuAction(item.id);
+    }
     async handleKeypress(text, key) {
         if ((key.ctrl && key.name === 'g') || key.name === 'f10') {
             this.toggleMenuMode();
@@ -422,6 +808,19 @@ class FullscreenTui {
             this.close();
             return;
         }
+        if (key.ctrl && key.name === 't' && this.busy) {
+            if (this.toolAbortController && !this.toolAbortController.signal.aborted) {
+                this.toolAbortController.abort('Aborted by user');
+                this.toolAbortController = null;
+                this.toolAbortSignalRef.signal = undefined;
+                this.statusLine = 'Tool execution cancelled.';
+            }
+            else {
+                this.statusLine = 'No active tool to cancel.';
+            }
+            this.requestRender();
+            return;
+        }
         if (this.uiMode === 'menu') {
             await this.handleMenuKeypress(text, key);
             return;
@@ -454,7 +853,7 @@ class FullscreenTui {
                     return;
                 }
                 if (this.cursor > 0) {
-                    this.cursor -= 1;
+                    this.cursor = this.graphemeLeftIndex(this.inputValue, this.cursor);
                 }
                 break;
             case 'right':
@@ -463,7 +862,7 @@ class FullscreenTui {
                     return;
                 }
                 if (this.cursor < this.inputValue.length) {
-                    this.cursor += 1;
+                    this.cursor = this.graphemeRightIndex(this.inputValue, this.cursor);
                 }
                 break;
             case 'home':
@@ -636,13 +1035,13 @@ class FullscreenTui {
                 return;
             case 'left':
                 if (this.cursor > 0) {
-                    this.cursor -= 1;
+                    this.cursor = this.graphemeLeftIndex(this.inputValue, this.cursor);
                     this.requestRender();
                 }
                 return;
             case 'right':
                 if (this.cursor < this.inputValue.length) {
-                    this.cursor += 1;
+                    this.cursor = this.graphemeRightIndex(this.inputValue, this.cursor);
                     this.requestRender();
                 }
                 return;
@@ -869,6 +1268,8 @@ class FullscreenTui {
         activity.pushLine(`task ${promptText}`);
         this.busy = true;
         this.currentAbortController = new AbortController();
+        this.toolAbortController = new AbortController();
+        this.toolAbortSignalRef.signal = this.toolAbortController.signal;
         this.startAnimation();
         this.statusLine = 'Running conductor...';
         this.requestRender();
@@ -880,8 +1281,10 @@ class FullscreenTui {
                 headless: true,
                 sandbox: this.options.sandbox,
                 signal: this.currentAbortController.signal,
+                toolAbortSignalRef: this.toolAbortSignalRef,
                 onUserInput: (question) => this.requestClarification(question),
                 onEvent: (event) => {
+                    this.manageToolAbortSignal(event.event);
                     activity.handle(event);
                     this.updatePreviewFromEvent(event);
                     this.requestRender();
@@ -906,6 +1309,8 @@ class FullscreenTui {
         finally {
             this.busy = false;
             this.currentAbortController = null;
+            this.toolAbortController = null;
+            this.toolAbortSignalRef.signal = undefined;
             this.stopAnimation();
             if (this.exitRequested) {
                 this.close();
@@ -927,6 +1332,8 @@ class FullscreenTui {
         activity.pushLine(`skill /${skillName}${args.length > 0 ? ` ${args.join(' ')}` : ''}`);
         this.busy = true;
         this.currentAbortController = new AbortController();
+        this.toolAbortController = new AbortController();
+        this.toolAbortSignalRef.signal = this.toolAbortController.signal;
         this.startAnimation();
         this.statusLine = `Running /${skillName}...`;
         this.requestRender();
@@ -935,14 +1342,17 @@ class FullscreenTui {
                 sessionId: this.selectedSessionId || undefined,
                 sandbox: this.options.sandbox,
                 signal: this.currentAbortController.signal,
+                toolAbortSignalRef: this.toolAbortSignalRef,
                 onUserInput: (question) => this.requestClarification(question),
                 onEvent: (event) => {
+                    this.manageToolAbortSignal(event.event);
                     activity.handle(event);
                     this.updatePreviewFromEvent(event);
                     this.requestRender();
                 },
             });
             activity.finish();
+            await this.refreshSessions({ selectedSessionId: this.selectedSessionId });
             await this.refreshCommands();
             this.finishExecutionPreview({
                 persist: true,
@@ -961,6 +1371,8 @@ class FullscreenTui {
         finally {
             this.busy = false;
             this.currentAbortController = null;
+            this.toolAbortController = null;
+            this.toolAbortSignalRef.signal = undefined;
             this.stopAnimation();
             if (this.exitRequested) {
                 this.close();
@@ -989,6 +1401,8 @@ class FullscreenTui {
         activity.pushLine(`run ${commandText}`);
         this.busy = true;
         this.currentAbortController = new AbortController();
+        this.toolAbortController = new AbortController();
+        this.toolAbortSignalRef.signal = this.toolAbortController.signal;
         this.startAnimation();
         this.statusLine = `Running ${commandText}...`;
         this.requestRender();
@@ -997,14 +1411,17 @@ class FullscreenTui {
                 sessionId: this.selectedSessionId || undefined,
                 sandbox: this.options.sandbox,
                 signal: this.currentAbortController.signal,
+                toolAbortSignalRef: this.toolAbortSignalRef,
                 onUserInput: (question) => this.requestClarification(question),
                 onEvent: (event) => {
+                    this.manageToolAbortSignal(event.event);
                     activity.handle(event);
                     this.updatePreviewFromEvent(event);
                     this.requestRender();
                 },
             });
             activity.finish();
+            await this.refreshSessions({ selectedSessionId: this.selectedSessionId });
             await this.refreshCommands();
             this.finishExecutionPreview({
                 persist: true,
@@ -1023,6 +1440,8 @@ class FullscreenTui {
         finally {
             this.busy = false;
             this.currentAbortController = null;
+            this.toolAbortController = null;
+            this.toolAbortSignalRef.signal = undefined;
             this.stopAnimation();
             if (this.exitRequested) {
                 this.close();
@@ -1050,6 +1469,8 @@ class FullscreenTui {
         activity.pushLine(`skill ${commandText}`);
         this.busy = true;
         this.currentAbortController = new AbortController();
+        this.toolAbortController = new AbortController();
+        this.toolAbortSignalRef.signal = this.toolAbortController.signal;
         this.startAnimation();
         this.statusLine = `Running /${commandName}...`;
         this.requestRender();
@@ -1059,12 +1480,14 @@ class FullscreenTui {
                 signal: this.currentAbortController.signal,
                 onUserInput: (question) => this.requestClarification(question),
                 onEvent: (event) => {
+                    this.manageToolAbortSignal(event.event);
                     activity.handle(event);
                     this.updatePreviewFromEvent(event);
                     this.requestRender();
                 },
             });
             activity.finish();
+            await this.refreshSessions({ selectedSessionId: this.selectedSessionId });
             await this.refreshCommands();
             this.finishExecutionPreview({
                 persist: true,
@@ -1082,6 +1505,8 @@ class FullscreenTui {
         finally {
             this.busy = false;
             this.currentAbortController = null;
+            this.toolAbortController = null;
+            this.toolAbortSignalRef.signal = undefined;
             this.stopAnimation();
             if (this.exitRequested) {
                 this.close();
@@ -1113,6 +1538,8 @@ class FullscreenTui {
         activity.pushLine(`shell ${persistOutput ? '!!' : '!'}${trimmedCommand}`);
         this.busy = true;
         this.currentAbortController = new AbortController();
+        this.toolAbortController = this.currentAbortController;
+        this.toolAbortSignalRef.signal = this.toolAbortController.signal;
         this.startAnimation();
         this.statusLine = `Running ${persistOutput ? '!!' : '!'}${trimmedCommand}...`;
         this.requestRender();
@@ -1157,6 +1584,8 @@ class FullscreenTui {
         finally {
             this.busy = false;
             this.currentAbortController = null;
+            this.toolAbortController = null;
+            this.toolAbortSignalRef.signal = undefined;
             this.stopAnimation();
             if (this.exitRequested) {
                 this.close();
@@ -2278,13 +2707,13 @@ class FullscreenTui {
         this.animationTimer = null;
     }
     scrollFocusedPane(direction, amount) {
-        const metrics = this.getPaneMetrics(this.focusedPane);
-        if (metrics.maxStart === 0) {
-            this.statusLine = `${paneDisplayName(this.focusedPane)} fits on screen.`;
-            this.requestRender();
-            return;
-        }
         if (this.focusedPane === 'sessions') {
+            const metrics = this.getLastPaneMetrics(this.focusedPane) ?? this.getPaneMetrics(this.focusedPane);
+            if (metrics.maxStart === 0) {
+                this.statusLine = `${paneDisplayName(this.focusedPane)} fits on screen.`;
+                this.requestRender();
+                return;
+            }
             const delta = direction === 'down' ? amount : -amount;
             this.paneScroll.sessions = clamp(this.paneScroll.sessions + delta, 0, metrics.maxStart);
             this.statusLine = `Sessions scroll ${this.paneScroll.sessions + 1}/${metrics.maxStart + 1}.`;
@@ -2292,8 +2721,19 @@ class FullscreenTui {
             return;
         }
         const pane = this.focusedPane;
+        const metrics = this.getLastPaneMetrics(pane)
+            ?? (this.paneScroll[pane] === 0 ? this.getRenderPaneMetrics(pane) : this.getPaneMetrics(pane));
+        if (metrics.maxStart === 0) {
+            this.paneScroll[pane] = 0;
+            this.statusLine = `${paneDisplayName(pane)} fits on screen.`;
+            this.requestRender();
+            return;
+        }
         const delta = direction === 'up' ? amount : -amount;
-        this.paneScroll[pane] = clamp(this.paneScroll[pane] + delta, 0, metrics.maxStart);
+        const nextScroll = this.paneScroll[pane] + delta;
+        this.paneScroll[pane] = metrics.maxStartIsExact
+            ? clamp(nextScroll, 0, metrics.maxStart)
+            : Math.max(0, nextScroll);
         this.statusLine = this.paneScroll[pane] === 0
             ? `${paneDisplayName(pane)} following newest content.`
             : `${paneDisplayName(pane)} scrolled ${this.paneScroll[pane]} line${this.paneScroll[pane] === 1 ? '' : 's'} above latest.`;
@@ -2338,6 +2778,36 @@ class FullscreenTui {
     currentProcessActivity() {
         return this.activityFor(this.selectedSessionId || 'global');
     }
+    graphemeLeftIndex(text, index) {
+        if (index <= 0)
+            return 0;
+        if (!graphemeSegmenter)
+            return index - 1;
+        const graphemes = Array.from(graphemeSegmenter.segment(text), (g) => g.segment);
+        let pos = 0;
+        for (const g of graphemes) {
+            if (pos + g.length >= index)
+                break;
+            pos += g.length;
+        }
+        return pos;
+    }
+    graphemeRightIndex(text, index) {
+        if (index >= text.length)
+            return text.length;
+        if (!graphemeSegmenter)
+            return index + 1;
+        const graphemes = Array.from(graphemeSegmenter.segment(text), (g) => g.segment);
+        let pos = 0;
+        for (const g of graphemes) {
+            if (pos >= index) {
+                pos += g.length;
+                break;
+            }
+            pos += g.length;
+        }
+        return Math.min(pos, text.length);
+    }
     insertText(text) {
         const previousInput = this.inputValue;
         this.inputValue = `${this.inputValue.slice(0, this.cursor)}${text}${this.inputValue.slice(this.cursor)}`;
@@ -2349,8 +2819,9 @@ class FullscreenTui {
             return;
         }
         const previousInput = this.inputValue;
-        this.inputValue = `${this.inputValue.slice(0, this.cursor - 1)}${this.inputValue.slice(this.cursor)}`;
-        this.cursor -= 1;
+        const deleteFrom = this.graphemeLeftIndex(this.inputValue, this.cursor);
+        this.inputValue = `${this.inputValue.slice(0, deleteFrom)}${this.inputValue.slice(this.cursor)}`;
+        this.cursor = deleteFrom;
         this.refreshCommandBarStatus(previousInput);
     }
     deleteForward() {
@@ -2492,23 +2963,28 @@ class FullscreenTui {
         }
         lines.push(status);
         lines.push(inputLine);
+        if (this.selection) {
+            this.applySelectionHighlight(lines, widths, rightHeights, contentHeight);
+        }
         this.paintFrame(lines, { columns, rows });
         if (workspaceView?.cursor && !this.pendingPrompt) {
             output.write(`\u001b[${workspaceView.cursor.row};${workspaceView.cursor.column}H`);
             return;
         }
-        const cursorColumn = Math.min(columns, inputPrefix.length + this.cursor + 1);
+        const textBeforeCursor = this.inputValue.slice(0, this.cursor);
+        const cursorColumn = Math.min(columns, inputPrefix.length + measureDisplayWidth(textBeforeCursor) + 1);
         output.write(`\u001b[${rows};${cursorColumn}H`);
     }
     paintFrame(lines, size) {
-        const patch = computeFramePatch(this.previousFrameLines, lines, this.previousFrameSize, size);
+        const paddedLines = lines.map((line) => padRight(line, size.columns));
+        const patch = computeFramePatch(this.previousFrameLines, paddedLines, this.previousFrameSize, size);
         let buffer = '\u001b[0m';
         if (patch.fullRender) {
-            buffer += `\u001b[H\u001b[2J${lines.join('\n')}\u001b[?25h`;
+            buffer += `\u001b[H${paddedLines.join('\n')}\u001b[?25h`;
         }
         else if (patch.changedRows.length > 0) {
             for (const change of patch.changedRows) {
-                buffer += `\u001b[${change.row};1H\u001b[2K${change.line}`;
+                buffer += `\u001b[${change.row};1H${change.line}`;
             }
             buffer += '\u001b[?25h';
         }
@@ -2516,7 +2992,7 @@ class FullscreenTui {
             buffer += '\u001b[?25h';
         }
         output.write(buffer);
-        this.previousFrameLines = [...lines];
+        this.previousFrameLines = [...paddedLines];
         this.previousFrameSize = size;
     }
     buildHeaderLine() {
@@ -2530,32 +3006,35 @@ class FullscreenTui {
         return `${sessionLabel}   ${mode}   ${skillLabel}`;
     }
     buildStatusLine() {
+        const spinner = this.busy || this.currentPreview?.entries.some((entry) => entry.pending)
+            ? ` ${currentSpinnerFrame()}`
+            : '';
         if (this.uiMode === 'menu') {
             const menu = this.getMenuDefinitions()[this.menuState.activeIndex];
-            return `Menu ${menu?.label ?? ''} | ${menu?.items[this.menuState.selectedIndex]?.description ?? 'Choose an action.'}`;
+            return `${spinner} Menu ${menu?.label ?? ''} | ${menu?.items[this.menuState.selectedIndex]?.description ?? 'Choose an action.'}`;
         }
         if ((this.uiMode === 'picker' || this.uiMode === 'palette') && this.pickerState) {
             const selected = this.pickerState.filteredItems[this.pickerState.selectedIndex];
-            return `${this.pickerState.title} | ${selected?.description ?? this.pickerState.emptyText}`;
+            return `${spinner} ${this.pickerState.title} | ${selected?.description ?? this.pickerState.emptyText}`;
         }
         if (this.uiMode === 'viewer' && this.viewerState) {
-            return `${this.viewerState.title} | ${this.viewerState.path ? path.relative(this.workspaceRoot, this.viewerState.path) : 'read-only view'}`;
+            return `${spinner} ${this.viewerState.title} | ${this.viewerState.path ? path.relative(this.workspaceRoot, this.viewerState.path) : 'read-only view'}`;
         }
         if (this.uiMode === 'editor' && this.editorState) {
             const dirty = this.editorState.dirty ? 'modified' : 'saved';
-            return `${this.editorState.title} | ${dirty} | Ln ${this.editorState.cursorLine + 1}, Col ${this.editorState.cursorColumn + 1}`;
+            return `${spinner} ${this.editorState.title} | ${dirty} | Ln ${this.editorState.cursorLine + 1}, Col ${this.editorState.cursorColumn + 1}`;
         }
         const focus = paneDisplayName(this.focusedPane);
         if (!this.pendingPrompt && this.focusedPane !== 'sessions') {
             const follow = this.paneScroll[this.focusedPane] === 0 ? 'follow' : `scroll ${this.paneScroll[this.focusedPane]}`;
-            return `${this.statusLine} | Focus ${focus} | ${follow}`;
+            return `${spinner} ${this.statusLine} | Focus ${focus} | ${follow}`;
         }
         if (this.pendingPrompt) {
             return this.pendingPrompt.kind === 'clarify'
-                ? `Clarify: ${condenseWhitespace(this.pendingPrompt.prompt)} | Focus ${focus}`
-                : `Input: ${condenseWhitespace(this.pendingPrompt.prompt)} | Focus ${focus}`;
+                ? `${spinner} Clarify: ${condenseWhitespace(this.pendingPrompt.prompt)} | Focus ${focus}`
+                : `${spinner} Input: ${condenseWhitespace(this.pendingPrompt.prompt)} | Focus ${focus}`;
         }
-        return `${this.statusLine} | Focus ${focus}`;
+        return `${spinner} ${this.statusLine} | Focus ${focus}`;
     }
     buildInputPrefix() {
         if (this.uiMode === 'menu') {
@@ -2708,6 +3187,11 @@ class FullscreenTui {
     }
     buildPaneView(kind, title, width, height) {
         const metrics = this.getRenderPaneMetrics(kind, width, height);
+        this.lastPaneMetrics[kind] = {
+            maxStart: metrics.maxStart,
+            viewportLines: metrics.viewportLines,
+            maxStartIsExact: metrics.maxStartIsExact,
+        };
         const paneTitle = this.buildPaneTitle(title, kind, metrics);
         return buildPane(paneTitle, metrics.lines.slice(metrics.start, metrics.start + metrics.viewportLines), width, height, kind, this.focusedPane === kind);
     }
@@ -2843,6 +3327,8 @@ class FullscreenTui {
             ['<- ->', 'Pane'],
             [this.focusedPane === 'sessions' ? 'Up/Down' : 'PgUp/PgDn', this.focusedPane === 'sessions' ? 'Select' : 'Scroll'],
             ['End', this.focusedPane === 'sessions' ? 'Bottom' : 'Follow'],
+            ['Drag', 'Select'],
+            ...(this.busy ? [['Ctrl+T', 'Cancel']] : []),
             ['/cancel', 'Stop'],
         ];
     }
@@ -2857,6 +3343,16 @@ class FullscreenTui {
             ? `${title}${this.focusedPane === kind ? ' [focus]' : ''} [follow]`
             : `${title}${this.focusedPane === kind ? ' [focus]' : ''} [-${this.paneScroll[kind]}]`;
     }
+    cachedCollectTailWrappedLines(cacheKey, body, innerWidth, limit) {
+        const cached = this.wrapCache.get(cacheKey);
+        const bodyKey = `${body.length}:${body.length > 0 ? body[body.length - 1] : ''}:${limit}`;
+        if (cached && cached.bodyRef === body && cached.bodyKey === bodyKey && cached.innerWidth === innerWidth) {
+            return { lines: cached.result, truncated: body.length > 0 && cached.result.length < body.length };
+        }
+        const result = collectTailWrappedLines(body, innerWidth, limit);
+        this.wrapCache.set(cacheKey, { bodyRef: body, bodyKey, innerWidth, result: result.lines });
+        return result;
+    }
     getRenderPaneMetrics(kind, width = paneDimensionsForKind(kind, output.columns ?? 120, output.rows ?? 40).width, height = paneDimensionsForKind(kind, output.columns ?? 120, output.rows ?? 40).height) {
         if ((kind === 'process' || kind === 'messages') && this.paneScroll[kind] === 0) {
             const innerWidth = Math.max(1, width - 2);
@@ -2864,20 +3360,25 @@ class FullscreenTui {
             const rawBody = kind === 'messages'
                 ? this.buildMessagesPaneBody({ recentEntryLimit: Math.max(8, viewportLines * 2) })
                 : this.buildProcessPaneBody({ tailLineLimit: Math.max(16, viewportLines * 4) });
-            const tail = collectTailWrappedLines(rawBody, innerWidth, viewportLines);
+            const tail = this.cachedCollectTailWrappedLines(`${kind}:tail`, rawBody, innerWidth, viewportLines);
             return {
                 lines: tail.lines,
                 start: 0,
                 maxStart: tail.truncated ? 1 : 0,
                 viewportLines,
+                maxStartIsExact: !tail.truncated,
             };
         }
         return this.getPaneMetrics(kind, width, height);
     }
+    getLastPaneMetrics(kind) {
+        const metrics = this.lastPaneMetrics[kind];
+        return metrics.viewportLines > 0 ? metrics : null;
+    }
     getPaneMetrics(kind, width = paneDimensionsForKind(kind, output.columns ?? 120, output.rows ?? 40).width, height = paneDimensionsForKind(kind, output.columns ?? 120, output.rows ?? 40).height) {
         const innerWidth = Math.max(1, width - 2);
         const rawBody = this.getPaneBody(kind);
-        const lines = wrapBodyLines(rawBody, innerWidth);
+        const lines = this.cachedWrapBodyLines(kind, rawBody, innerWidth);
         const viewportLines = Math.max(0, height - 2);
         const maxStart = Math.max(0, lines.length - viewportLines);
         if (kind === 'sessions') {
@@ -2887,6 +3388,7 @@ class FullscreenTui {
                 start: this.paneScroll.sessions,
                 maxStart,
                 viewportLines,
+                maxStartIsExact: true,
             };
         }
         this.paneScroll[kind] = clamp(this.paneScroll[kind], 0, maxStart);
@@ -2895,8 +3397,19 @@ class FullscreenTui {
             start: Math.max(0, maxStart - this.paneScroll[kind]),
             maxStart,
             viewportLines,
+            maxStartIsExact: true,
         };
     }
+    cachedWrapBodyLines(cacheKey, body, innerWidth) {
+        const cached = this.wrapCache.get(cacheKey);
+        const bodyKey = `${body.length}:${body.length > 0 ? body[body.length - 1] : ''}`;
+        if (cached && cached.bodyRef === body && cached.bodyKey === bodyKey && cached.innerWidth === innerWidth) {
+            return cached.result;
+        }
+        const result = wrapBodyLines(body, innerWidth);
+        this.wrapCache.set(cacheKey, { bodyRef: body, bodyKey, innerWidth, result });
+        return result;
+    }
     getPaneBody(kind) {
         switch (kind) {
             case 'sessions':
@@ -2904,7 +3417,7 @@ class FullscreenTui {
             case 'messages':
                 return this.buildMessagesPaneBody();
             case 'process':
-                return this.buildProcessPaneBody();
+                return this.buildProcessPaneBody({ tailLineLimit: MAX_ACTIVITY_LINES });
             case 'context':
                 return this.buildContextPaneBody();
         }
@@ -2922,8 +3435,7 @@ class FullscreenTui {
         }
     }
     formatMessageHeader(entry) {
-        const spinner = entry.pending ? ` ${currentSpinnerFrame()}` : '';
-        return formatDisplayMessageHeader(entry, spinner);
+        return formatDisplayMessageHeader(entry, '');
     }
     close() {
         if (!this.closeResolver) {
@@ -2933,6 +3445,21 @@ class FullscreenTui {
         this.closeResolver = null;
         resolve();
     }
+    manageToolAbortSignal(event) {
+        if (event.type !== 'tool_call' || !event.toolState) {
+            return;
+        }
+        if (event.toolState === 'starting' || event.toolState === 'running') {
+            if (!this.toolAbortController || this.toolAbortController.signal.aborted) {
+                this.toolAbortController = new AbortController();
+            }
+            this.toolAbortSignalRef.signal = this.toolAbortController.signal;
+        }
+        else {
+            this.toolAbortController = null;
+            this.toolAbortSignalRef.signal = undefined;
+        }
+    }
     isEditingInput() {
         return this.uiMode !== 'editor' && this.inputValue.length > 0;
     }
@@ -3225,6 +3752,7 @@ export async function runFileCommand(workspaceRoot, fileSpec, args, options = {}
     }, args, options);
 }
 async function executeRunnableCommand(workspaceRoot, target, args, options = {}) {
+    const usageByModel = {};
     const executionLog = options.sessionId
         ? createSessionExecutionLogWriter({
             workspaceRoot,
@@ -3236,6 +3764,9 @@ async function executeRunnableCommand(workspaceRoot, target, args, options = {})
         })
         : null;
     const emitLogEvent = (event) => {
+        if (event.event.type === 'usage') {
+            recordTokenUsage(usageByModel, event.modelId, event.event.usage);
+        }
         executionLog?.recordEvent(event);
         options.onEvent?.(event);
     };
@@ -3246,12 +3777,14 @@ async function executeRunnableCommand(workspaceRoot, target, args, options = {})
             stream: true,
             sandbox: options.sandbox,
             signal: options.signal,
+            toolAbortSignalRef: options.toolAbortSignalRef,
             onUserInput: options.onUserInput,
             onEvent: (event) => emitLogEvent({ scope: 'child', childSlug: target.childSlug, event }),
             onChildEvent: (childSlug, event) => emitLogEvent({ scope: 'child', childSlug, event }),
         });
         if (options.sessionId) {
             await appendConductorSessionMessages(workspaceRoot, options.sessionId, buildPersistedRunnableTranscript(target.inputText, result));
+            await mergeSessionUsage(workspaceRoot, options.sessionId, usageByModel);
         }
         await executionLog?.finish({
             status: result.error ? 'error' : 'success',
@@ -3267,6 +3800,7 @@ async function executeRunnableCommand(workspaceRoot, target, args, options = {})
                 output: [],
                 error: error.message,
             }));
+            await mergeSessionUsage(workspaceRoot, options.sessionId, usageByModel);
         }
         await executionLog?.finish({
             status: 'error',
@@ -3494,6 +4028,15 @@ export function previewMessageFromEvent(logEvent) {
                 return null;
             }
             return previewQuestionMessage(logEvent.event.prompt, logEvent.scope === 'child' ? logEvent.childSlug : undefined);
+        case 'memory_compaction':
+            return {
+                role: 'system',
+                kind: 'output',
+                tag: logEvent.scope === 'child' ? logEvent.childSlug : undefined,
+                content: logEvent.event.content
+                    ? `Memory compaction: ${logEvent.event.content}`
+                    : 'Memory compaction triggered.',
+            };
         default:
             return null;
     }
@@ -4053,6 +4596,37 @@ function expandTabs(text, tabWidth) {
 export function measureDisplayWidth(text) {
     return splitGraphemes(text).reduce((total, grapheme) => total + graphemeDisplayWidth(grapheme), 0);
 }
+function displayColumnToStringIndex(text, displayCol) {
+    let col = 0;
+    let i = 0;
+    const len = text.length;
+    while (i < len) {
+        if (text.charCodeAt(i) === 0x1b && i + 1 < len && text[i + 1] === '[') {
+            const end = text.indexOf('m', i + 2);
+            if (end !== -1) {
+                i = end + 1;
+                continue;
+            }
+        }
+        if (col >= displayCol)
+            return i;
+        const code = text.codePointAt(i);
+        const charWidth = code >= 0x1100 && (code <= 0x115f || code === 0x2329 || code === 0x232a ||
+            (code >= 0x2e80 && code <= 0xa4cf && code !== 0x303f) ||
+            (code >= 0xac00 && code <= 0xd7a3) ||
+            (code >= 0xf900 && code <= 0xfaff) ||
+            (code >= 0xfe10 && code <= 0xfe19) ||
+            (code >= 0xfe30 && code <= 0xfe6f) ||
+            (code >= 0xff01 && code <= 0xff60) ||
+            (code >= 0xffe0 && code <= 0xffe6) ||
+            (code >= 0x1f300 && code <= 0x1f9ff) ||
+            (code >= 0x20000 && code <= 0x2fffd) ||
+            (code >= 0x30000 && code <= 0x3fffd)) ? 2 : 1;
+        col += charWidth;
+        i += code > 0xffff ? 2 : 1;
+    }
+    return i;
+}
 export function padRight(text, width) {
     const visibleWidth = measureDisplayWidth(text);
     return visibleWidth >= width ? text : `${text}${' '.repeat(width - visibleWidth)}`;