tsunami-code 3.9.0 → 3.11.0

package/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import readline from 'readline';
+import { createUI } from './lib/ui.js';
 import chalk from 'chalk';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
 import { join } from 'path';
@@ -26,7 +26,7 @@ import {
 } from './lib/memory.js';
 import { listMemories, readMemory, saveMemory, deleteMemory, getMemdirPath } from './lib/memdir.js';
 
-const VERSION = '3.9.0';
+const VERSION = '3.10.0';
 const CONFIG_DIR = join(os.homedir(), '.tsunami-code');
 const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
 const DEFAULT_SERVER = 'https://radiometric-reita-amuck.ngrok-free.dev';
@@ -68,13 +68,38 @@ function printBanner(serverUrl) {
   console.log(dim('  International AI Wars\n'));
 }
 
-function printToolCall(name, args) {
+function printToolCall(name, args, elapsedMs) {
   let parsed = {};
   try { parsed = JSON.parse(args); } catch {}
   const preview = Object.entries(parsed)
     .map(([k, v]) => `${k}=${JSON.stringify(String(v).slice(0, 60))}`)
     .join(', ');
-  process.stdout.write('\n' + dim(`  ⚙ ${name}(${preview})\n`));
+  const timing = elapsedMs != null ? chalk.dim(` (${(elapsedMs / 1000).toFixed(1)}s)`) : '';
+  process.stdout.write('\n' + dim(`  ⚙ ${name}`) + timing + dim(`(${preview})\n`));
+}
+
+// ── Spinner — shows while waiting for first token ────────────────────────────
+function createSpinner() {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  const labels = ['thinking', 'pondering', 'reasoning', 'analyzing'];
+  let fi = 0, li = 0, ticks = 0, interval = null;
+
+  const start = () => {
+    interval = setInterval(() => {
+      ticks++;
+      if (ticks % 25 === 0) li = (li + 1) % labels.length; // rotate label every ~2s
+      process.stdout.write(`\r  ${dim(frames[fi++ % frames.length] + ' ' + labels[li] + '...')}   `);
+    }, 80);
+  };
+
+  const stop = () => {
+    if (!interval) return;
+    clearInterval(interval);
+    interval = null;
+    process.stdout.write('\r' + ' '.repeat(35) + '\r');
+  };
+
+  return { start, stop };
 }
 
 function formatBytes(bytes) {
@@ -202,32 +227,16 @@ if (setServerIdx !== -1 && argv[setServerIdx + 1]) {
 }
 
 // ── Confirm Callback (dangerous command prompt) ─────────────────────────────
-function makeConfirmCallback(rl) {
+function makeConfirmCallback(ui) {
   const cb = async (cmd) => {
-    return new Promise((resolve) => {
-      rl.pause();
-      process.stdout.write(`\n  ${yellow('⚠  Dangerous:')} ${dim(cmd.slice(0, 120))}\n`);
-      process.stdout.write(`  ${yellow('Proceed?')} ${dim('(y/N) ')}`);
-      const handler = (data) => {
-        process.stdin.removeListener('data', handler);
-        rl.resume();
-        process.stdout.write('\n');
-        resolve(data.toString().trim().toLowerCase() === 'y');
-      };
-      process.stdin.once('data', handler);
-    });
+    process.stdout.write(`\n  ${yellow('⚠  Dangerous:')} ${dim(cmd.slice(0, 120))}\n`);
+    const ch = await ui.readChar(`  ${yellow('Proceed?')} ${dim('(y/N) ')}`);
+    return ch.toLowerCase() === 'y';
   };
 
-  cb._askUser = (question, resolve) => {
-    rl.pause();
-    process.stdout.write(`\n  ${cyan('?')} ${question}\n  ${dim('> ')}`);
-    const handler = (data) => {
-      process.stdin.removeListener('data', handler);
-      rl.resume();
-      process.stdout.write('\n');
-      resolve(data.toString().trim());
-    };
-    process.stdin.once('data', handler);
+  cb._askUser = async (question, resolve) => {
+    const answer = await ui.readLine(`\n  ${cyan('?')} ${question}\n  ${dim('> ')}`);
+    resolve(answer);
   };
 
   return cb;
@@ -326,7 +335,6 @@ async function run() {
     } catch { return []; }
   }
   const historyEntries = loadHistory();
-  let historyIdx = -1;
 
   // Preflight checks
   process.stdout.write(dim('  Checking server connection...'));
@@ -477,16 +485,6 @@ async function run() {
     return [[], line];
   }
 
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: planMode ? yellow('❯ [plan] ') : cyan('❯ '),
-    terminal: process.stdin.isTTY,
-    completer: tabCompleter,
-  });
-
-  rl.prompt();
-
   let isProcessing = false;
   let pendingClose = false;
 
@@ -494,15 +492,23 @@ async function run() {
   function gracefulExit(code = 0) {
     try { endSession(sessionDir); } catch {}
     try { disconnectMcp(); } catch {}
+    ui.exitUI();
     console.log(dim('\n  Goodbye.\n'));
     process.exit(code);
   }
 
-  rl.on('close', () => {
-    if (isProcessing) { pendingClose = true; return; }
-    gracefulExit(0);
+  const ui = createUI({
+    planMode,
+    onLine: handleLine,
+    onTab:  tabCompleter,
+    onExit: (code) => {
+      if (isProcessing) { pendingClose = true; return; }
+      gracefulExit(code);
+    },
   });
 
+  ui.start(historyEntries);
+
   // ── Memory commands ───────────────────────────────────────────────────────────
   async function handleMemoryCommand(args) {
     const sub = args[0]?.toLowerCase();
@@ -602,36 +608,32 @@ async function run() {
   let mlBuffer = [];
   let mlHeredoc = false;
 
-  rl.on('line', async (input) => {
+  async function handleLine(input) {
     // ── Multiline: heredoc mode (""" toggle) ──────────────────────────────────
     if (input.trimStart() === '"""' || input.trimStart() === "'''") {
       if (!mlHeredoc) {
         mlHeredoc = true;
-        rl.setPrompt(dim('··· '));
-        rl.prompt();
+        ui.setContinuation(true);
         return;
       } else {
         // Close heredoc — submit accumulated buffer
         mlHeredoc = false;
         const assembled = mlBuffer.join('\n');
         mlBuffer = [];
-        rl.setPrompt(planMode ? yellow('❯ [plan] ') : cyan('❯ '));
-        // Fall through with assembled as the input
+        ui.setContinuation(false);
         return _handleInput(assembled);
       }
     }
 
     if (mlHeredoc) {
       mlBuffer.push(input);
-      rl.prompt();
       return;
     }
 
     // ── Multiline: backslash continuation ─────────────────────────────────────
     if (input.endsWith('\\')) {
       mlBuffer.push(input.slice(0, -1));
-      rl.setPrompt(dim('··· '));
-      rl.prompt();
+      ui.setContinuation(true);
       return;
     }
 
@@ -640,21 +642,20 @@ async function run() {
       mlBuffer.push(input);
       const assembled = mlBuffer.join('\n');
       mlBuffer = [];
-      rl.setPrompt(planMode ? yellow('❯ [plan] ') : cyan('❯ '));
+      ui.setContinuation(false);
       return _handleInput(assembled);
     }
 
     return _handleInput(input);
-  });
+  }
 
   async function _handleInput(input) {
     const line = input.trim();
-    if (!line) { rl.prompt(); return; }
+    if (!line) { return; }
 
     // Append to persistent history
     if (!line.startsWith('/')) {
       appendHistory(line);
-      historyIdx = -1;
     }
 
     if (line.startsWith('/')) {
@@ -671,7 +672,7 @@ async function run() {
           : skillMatch.prompt;
         messages.push({ role: 'user', content: userContent });
         const fullMessages = [{ role: 'system', content: systemPrompt }, ...messages];
-        rl.pause(); isProcessing = true;
+        ui.pause(); isProcessing = true;
         process.stdout.write('\n' + dim(`  ◈ Running skill: ${skillMatch.skill.name}\n\n`));
         let firstToken = true;
         try {
@@ -679,10 +680,10 @@ async function run() {
             if (firstToken) { process.stdout.write('  '); firstToken = false; }
             process.stdout.write(token);
           }, (name, args) => { printToolCall(name, args); firstToken = true; },
-          { sessionDir, cwd, planMode }, makeConfirmCallback(rl));
+          { sessionDir, cwd, planMode }, makeConfirmCallback(ui));
           process.stdout.write('\n\n');
         } catch(e) { console.error(red(`  Error: ${e.message}\n`)); }
-        isProcessing = false; rl.resume(); rl.prompt();
+        isProcessing = false; ui.resume();
         return;
       }
 
@@ -733,7 +734,7 @@ async function run() {
           planMode = !planMode;
           if (planMode) console.log(yellow('  Plan mode ON — read-only, no writes or execution.\n'));
           else console.log(green('  Plan mode OFF — full capabilities restored.\n'));
-          rl.setPrompt(planMode ? yellow('❯ [plan] ') : cyan('❯ '));
+          ui.setPlanMode(planMode);
           break;
         case 'undo': {
           const restored = undo();
@@ -1149,7 +1150,7 @@ Output ONLY the TSUNAMI.md content, starting with "# Project: <name>"`;
         default:
           console.log(red(`  Unknown command: /${cmd}\n`));
       }
-      rl.prompt();
+      ui.resume();
       return;
     }
 
@@ -1181,33 +1182,52 @@ Output ONLY the TSUNAMI.md content, starting with "# Project: <name>"`;
     ];
     messages.push({ role: 'user', content: userContent });
 
-    rl.pause();
+    ui.pause();
     isProcessing = true;
     process.stdout.write('\n');
 
     // Open a new undo turn — all Write/Edit calls during this turn grouped together
     beginUndoTurn();
 
+    const spinner = createSpinner();
+    const turnStart = Date.now();
     let firstToken = true;
+    let toolTimers = {}; // track per-tool duration
+
+    spinner.start();
     const highlight = createHighlighter((s) => process.stdout.write(s));
+
     try {
       await agentLoop(
         currentServerUrl,
         fullMessages,
         (token) => {
-          if (firstToken) { process.stdout.write('  '); firstToken = false; }
+          if (firstToken) {
+            spinner.stop();
+            process.stdout.write('  ');
+            firstToken = false;
+          }
           highlight(token);
         },
         (toolName, toolArgs) => {
           flushHighlighter(highlight);
-          printToolCall(toolName, toolArgs);
+          spinner.stop();
+          const elapsed = toolTimers[toolName] != null ? Date.now() - toolTimers[toolName] : null;
+          toolTimers[toolName] = Date.now();
+          printToolCall(toolName, toolArgs, elapsed);
+          spinner.start();
           firstToken = true;
         },
         { sessionDir, cwd, planMode },
-        makeConfirmCallback(rl)
+        makeConfirmCallback(ui)
       );
+      spinner.stop();
       flushHighlighter(highlight);
 
+      const elapsed = ((Date.now() - turnStart) / 1000).toFixed(1);
+      const tok = tokenStats.output > 0 ? ` · ${tokenStats.output - (_outputTokens || 0)} tok` : '';
+      process.stdout.write(dim(`\n  ↳ ${elapsed}s${tok}\n`));
+
       // Token estimation
       const inputChars = fullMessages.reduce((s, m) => s + (typeof m.content === 'string' ? m.content.length : 0), 0);
       _inputTokens += Math.round(inputChars / 4);
@@ -1230,8 +1250,9 @@ Output ONLY the TSUNAMI.md content, starting with "# Project: <name>"`;
       const newSkills = loadSkills(cwd);
       if (newSkills.length !== skills.length) skills = newSkills;
 
-      process.stdout.write('\n\n');
+      process.stdout.write('\n');
     } catch (e) {
+      spinner.stop();
       process.stdout.write('\n');
       console.error(red(`  Error: ${e.message}\n`));
     }
@@ -1241,27 +1262,13 @@ Output ONLY the TSUNAMI.md content, starting with "# Project: <name>"`;
       gracefulExit(0);
       return;
     }
-    rl.resume();
-    rl.prompt();
+    ui.resume();
   }
 
+  // SIGINT from kill -INT (keyboard Ctrl+C is handled in raw mode inside ui.js)
   process.on('SIGINT', () => {
-    if (!isProcessing) {
-      gracefulExit(0);
-    } else {
-      // Remove interrupted command from history (from history.ts removeLastFromHistory)
-      try {
-        if (existsSync(HISTORY_FILE)) {
-          const lines = readFileSync(HISTORY_FILE, 'utf8').trimEnd().split('\n').filter(Boolean);
-          if (lines.length > 0) lines.pop();
-          import('fs').then(({ writeFileSync: wfs }) => {
-            try { wfs(HISTORY_FILE, lines.join('\n') + (lines.length ? '\n' : ''), 'utf8'); } catch {}
-          });
-        }
-      } catch {}
-      pendingClose = true;
-      console.log(dim('\n  (interrupted)\n'));
-    }
+    if (!isProcessing) gracefulExit(0);
+    else pendingClose = true;
   });
 }
 

package/lib/ui.js

@@ -0,0 +1,354 @@
+// lib/ui.js — sticky-bottom terminal UI
+// Pins a 3-line input box at the bottom of the terminal.
+// All output (model replies, tool calls, spinner) scrolls above it.
+// Uses ANSI scroll region (\x1b[top;botr) so the bottom box never scrolls.
+
+import chalk from 'chalk';
+
+const cyan  = (s) => chalk.cyan(s);
+const yellow = (s) => chalk.yellow(s);
+const dim   = (s) => chalk.dim(s);
+
+const BOX_LINES = 3; // ╭─ header ─╮ / │ ❯ input │ / ╰──────────╯
+
+export function createUI({ planMode: initPlanMode = false, onLine, onTab, onExit }) {
+  let planMode       = initPlanMode;
+  let continuation   = false;   // true → show ··· prompt
+  let inputBuf       = '';
+  let cursorPos      = 0;
+  let history        = [];      // strings, oldest→newest
+  let histIdx        = 0;       // points past end when not navigating
+  let histDraft      = '';      // saved current input while browsing history
+  let processing     = false;
+  let lineHandler    = null;    // set during readLine / readChar
+  let _interrupted   = false;
+
+  const rows = () => process.stdout.rows  || 24;
+  const cols = () => process.stdout.columns || 80;
+
+  // ── Scroll region ──────────────────────────────────────────────────────────
+  // Confines terminal scroll to rows 1..(rows-BOX_LINES).
+  // The bottom BOX_LINES rows sit outside the scroll region and stay fixed.
+
+  function setScrollRegion() {
+    process.stdout.write(`\x1b[1;${rows() - BOX_LINES}r`);
+  }
+
+  function resetScrollRegion() {
+    process.stdout.write('\x1b[r');
+  }
+
+  function goOutputArea() {
+    // Place cursor at the last line of the scroll region so next write lands there.
+    process.stdout.write(`\x1b[${rows() - BOX_LINES};1H`);
+  }
+
+  // ── Box drawing ────────────────────────────────────────────────────────────
+
+  function drawBox() {
+    const w = cols();
+    const r = rows();
+    const r1 = r - BOX_LINES + 1;   // top border row
+    const r2 = r - BOX_LINES + 2;   // input row
+    const r3 = r - BOX_LINES + 3;   // bottom border row
+
+    // Save cursor so we can restore it after drawing.
+    process.stdout.write('\x1b[s');
+
+    // Top border ─────────────────────────────────────────
+    const label     = ' tsunami ';
+    const rightFill = Math.max(0, w - 2 - 1 - label.length);
+    const topLine   = `╭─${label}${'─'.repeat(rightFill)}╮`;
+    process.stdout.write(`\x1b[${r1};1H\x1b[2K${topLine.slice(0, w)}`);
+
+    // Input line ──────────────────────────────────────────
+    let prefix;
+    if (continuation)  prefix = ` ${dim('···')} `;
+    else if (planMode) prefix = ` ${yellow('❯')} ${dim('[plan]')} `;
+    else               prefix = ` ${cyan('❯')} `;
+
+    // Strip ANSI codes to measure visible width of prefix.
+    const prefixVis = prefix.replace(/\x1b\[[0-9;]*m/g, '');
+    const innerW    = w - 2;                              // space between │ │
+    const maxInput  = Math.max(0, innerW - prefixVis.length - 1); // trailing space
+
+    // Slide window so cursor stays visible.
+    let dispInput  = inputBuf;
+    let dispCursor = cursorPos;
+    if (dispInput.length > maxInput) {
+      const start = Math.max(0, cursorPos - maxInput + 1);
+      dispInput  = inputBuf.slice(start);
+      dispCursor = cursorPos - start;
+    }
+    const display = dispInput.slice(0, maxInput);
+    const pad     = ' '.repeat(Math.max(0, maxInput - display.length));
+    process.stdout.write(`\x1b[${r2};1H\x1b[2K│${prefix}${display}${pad} │`);
+
+    // Bottom border ───────────────────────────────────────
+    const botLine = `╰${'─'.repeat(w - 2)}╯`;
+    process.stdout.write(`\x1b[${r3};1H\x1b[2K${botLine.slice(0, w)}`);
+
+    // Restore cursor to correct column in the input row.
+    const curCol = 1 + prefixVis.length + 1 + Math.min(dispCursor, display.length);
+    process.stdout.write(`\x1b[${r2};${curCol}H`);
+  }
+
+  // ── Raw key handler ────────────────────────────────────────────────────────
+
+  function handleKey(chunk) {
+    const key = chunk.toString('utf8');
+
+    // Delegate to temporary line handler (readLine / readChar in progress).
+    if (lineHandler) { lineHandler(key); return; }
+
+    // Ctrl+C ──────────────────────────────────────────────
+    if (key === '\x03') {
+      if (processing) {
+        _interrupted = true;
+        process.stdout.write(dim('\n  (interrupted)\n'));
+      } else if (inputBuf !== '') {
+        inputBuf  = '';
+        cursorPos = 0;
+        drawBox();
+      } else {
+        exitUI();
+        onExit(0);
+      }
+      return;
+    }
+
+    // Ctrl+D ──────────────────────────────────────────────
+    if (key === '\x04') {
+      if (!processing && inputBuf === '') { exitUI(); onExit(0); }
+      return;
+    }
+
+    if (processing) return;   // swallow all other keys while model is running
+
+    // Enter ───────────────────────────────────────────────
+    if (key === '\r' || key === '\n') {
+      const line = inputBuf;
+      if (line || continuation) {
+        if (line) {
+          history.push(line);
+          histIdx   = history.length;
+          histDraft = '';
+        }
+        inputBuf  = '';
+        cursorPos = 0;
+        drawBox();
+        goOutputArea();
+        process.stdout.write('\n');
+        onLine(line);
+      }
+      return;
+    }
+
+    // Backspace ───────────────────────────────────────────
+    if (key === '\x7f' || key === '\x08') {
+      if (cursorPos > 0) {
+        inputBuf = inputBuf.slice(0, cursorPos - 1) + inputBuf.slice(cursorPos);
+        cursorPos--;
+        drawBox();
+      }
+      return;
+    }
+
+    // Tab ─────────────────────────────────────────────────
+    if (key === '\t') {
+      if (!onTab) return;
+      const [hits] = onTab(inputBuf);
+      if (!hits.length) return;
+      if (hits.length === 1) {
+        inputBuf  = hits[0];
+        cursorPos = hits[0].length;
+        drawBox();
+        return;
+      }
+      // Multiple hits — show list and fill common prefix.
+      const prefix = hits.reduce((a, b) => {
+        let i = 0;
+        while (i < a.length && i < b.length && a[i] === b[i]) i++;
+        return a.slice(0, i);
+      });
+      goOutputArea();
+      const shown = hits.slice(0, 8).join('  ') + (hits.length > 8 ? ` …+${hits.length - 8}` : '');
+      process.stdout.write('\n  ' + dim(shown) + '\n');
+      if (prefix.length > inputBuf.length) {
+        inputBuf  = prefix;
+        cursorPos = prefix.length;
+      }
+      drawBox();
+      return;
+    }
+
+    // Arrow / navigation escape sequences ─────────────────
+    if (key === '\x1b[A') {   // up — history back
+      if (histIdx > 0) {
+        if (histIdx === history.length) histDraft = inputBuf;
+        histIdx--;
+        inputBuf  = history[histIdx] || '';
+        cursorPos = inputBuf.length;
+        drawBox();
+      }
+      return;
+    }
+    if (key === '\x1b[B') {   // down — history forward
+      if (histIdx < history.length) {
+        histIdx++;
+        inputBuf  = histIdx === history.length ? histDraft : history[histIdx] || '';
+        cursorPos = inputBuf.length;
+        drawBox();
+      }
+      return;
+    }
+    if (key === '\x1b[D')   { cursorPos = Math.max(0, cursorPos - 1);             drawBox(); return; } // ←
+    if (key === '\x1b[C')   { cursorPos = Math.min(inputBuf.length, cursorPos+1); drawBox(); return; } // →
+    if (key === '\x1b[H' || key === '\x01') { cursorPos = 0;               drawBox(); return; } // Home / Ctrl+A
+    if (key === '\x1b[F' || key === '\x05') { cursorPos = inputBuf.length; drawBox(); return; } // End  / Ctrl+E
+    if (key === '\x1b[3~') { // Delete
+      if (cursorPos < inputBuf.length) {
+        inputBuf = inputBuf.slice(0, cursorPos) + inputBuf.slice(cursorPos + 1);
+        drawBox();
+      }
+      return;
+    }
+
+    // Editing shortcuts ────────────────────────────────────
+    if (key === '\x0b') { inputBuf = inputBuf.slice(0, cursorPos); drawBox(); return; }         // Ctrl+K
+    if (key === '\x15') { inputBuf = inputBuf.slice(cursorPos); cursorPos = 0; drawBox(); return; } // Ctrl+U
+    if (key === '\x17') { // Ctrl+W — kill word backwards
+      const before    = inputBuf.slice(0, cursorPos).trimEnd();
+      const lastSpace = before.lastIndexOf(' ');
+      const newBefore = lastSpace < 0 ? '' : before.slice(0, lastSpace + 1);
+      inputBuf  = newBefore + inputBuf.slice(cursorPos);
+      cursorPos = newBefore.length;
+      drawBox();
+      return;
+    }
+    if (key === '\x0c') { // Ctrl+L — clear screen
+      process.stdout.write('\x1b[2J\x1b[1;1H');
+      setScrollRegion();
+      drawBox();
+      return;
+    }
+
+    // Ignore unhandled escape sequences.
+    if (key.startsWith('\x1b')) return;
+
+    // Printable chars (including multi-byte UTF-8).
+    if (key >= ' ' || key.charCodeAt(0) > 127) {
+      inputBuf   = inputBuf.slice(0, cursorPos) + key + inputBuf.slice(cursorPos);
+      cursorPos += key.length;
+      drawBox();
+    }
+  }
+
+  // ── readLine — full line read during processing (AskUser tool) ────────────
+  function readLine(promptText) {
+    return new Promise((resolve) => {
+      let buf = '';
+      process.stdout.write(promptText);
+      lineHandler = (key) => {
+        if (key === '\r' || key === '\n') {
+          lineHandler = null;
+          process.stdout.write('\n');
+          resolve(buf);
+        } else if (key === '\x7f' || key === '\x08') {
+          if (buf.length > 0) { buf = buf.slice(0, -1); process.stdout.write('\x08 \x08'); }
+        } else if (key === '\x03') {
+          lineHandler = null;
+          process.stdout.write('\n');
+          resolve('');
+        } else if (key >= ' ') {
+          buf += key;
+          process.stdout.write(key);
+        }
+      };
+    });
+  }
+
+  // ── readChar — single-key confirm prompt ──────────────────────────────────
+  function readChar(promptText) {
+    return new Promise((resolve) => {
+      process.stdout.write(promptText);
+      lineHandler = (key) => {
+        if (key === '\x03' || key === '\r' || key === '\n' || key >= ' ') {
+          lineHandler = null;
+          const ch = (key === '\r' || key === '\n' || key === '\x03') ? '' : key;
+          process.stdout.write(ch + '\n');
+          resolve(ch);
+        }
+      };
+    });
+  }
+
+  // ── Public API ─────────────────────────────────────────────────────────────
+
+  function start(preloadHistory = []) {
+    if (!process.stdin.isTTY) return;
+
+    history = [...preloadHistory];   // oldest→newest
+    histIdx = history.length;
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', handleKey);
+
+    process.stdout.on('resize', () => {
+      setScrollRegion();
+      drawBox();
+    });
+
+    // Push content up to make room for the box at the bottom.
+    process.stdout.write('\n'.repeat(BOX_LINES));
+    setScrollRegion();
+    goOutputArea();
+    drawBox();
+  }
+
+  function pause() {
+    processing = true;
+    goOutputArea();   // cursor into scroll region, ready for output
+  }
+
+  function resume() {
+    processing = false;
+    drawBox();        // cursor back into input box
+  }
+
+  function setPlanMode(val) {
+    planMode = val;
+    if (!processing) drawBox();
+  }
+
+  function setContinuation(val) {
+    continuation = val;
+    if (!processing) drawBox();
+  }
+
+  function wasInterrupted() {
+    const v = _interrupted;
+    _interrupted = false;
+    return v;
+  }
+
+  function exitUI() {
+    resetScrollRegion();
+    // Clear the box lines so the terminal is clean on exit.
+    const r = rows();
+    for (let i = 0; i < BOX_LINES; i++) {
+      process.stdout.write(`\x1b[${r - BOX_LINES + 1 + i};1H\x1b[2K`);
+    }
+    process.stdout.write(`\x1b[${r - BOX_LINES + 1};1H`);
+    try { process.stdin.setRawMode(false); } catch {}
+  }
+
+  function stop(code = 0) {
+    exitUI();
+    process.exit(code);
+  }
+
+  return { start, pause, resume, setPlanMode, setContinuation, readLine, readChar, wasInterrupted, stop, exitUI };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsunami-code",
-  "version": "3.9.0",
+  "version": "3.11.0",
   "description": "Tsunami Code CLI — AI coding agent by Keystone World Management Navy Seal Unit XI3",
   "type": "module",
   "bin": {