@orbit-intelligence/orbit-agent 0.3.12

package/dist/src/tui/colors.js

@@ -0,0 +1,13 @@
+import { intToRgb } from './style.js';
+/** 0xRRGGBB → '#rrggbb' for Ink's Chalk-compatible colour strings. */
+export function rgbToHex(v) {
+    const [r, g, b] = intToRgb(v);
+    return `#${[r, g, b].map((x) => x.toString(16).padStart(2, '0')).join('')}`;
+}
+/** Resolve a named theme style (e.g. 'accent') to a hex colour string. */
+export function themeColor(theme, key) {
+    const style = theme.table.style(theme.styles[key]);
+    if (style?.fg != null)
+        return rgbToHex(style.fg);
+    return '#999999';
+}

package/dist/src/tui/components/AgentDock.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useStore } from '../context.js';
+import { themeColor } from '../colors.js';
+const STATUS_DOT = {
+    idle: '○',
+    thinking: '◌',
+    streaming: '●',
+    tool: '⚙',
+    waiting: '…',
+    interrupted: '⊘',
+    error: '✗',
+    done: '✓',
+};
+function statusColor(theme, status) {
+    if (!theme)
+        return '#969cbc';
+    switch (status) {
+        case 'error':
+            return themeColor(theme, 'danger');
+        case 'done':
+            return themeColor(theme, 'success');
+        case 'thinking':
+        case 'streaming':
+        case 'tool':
+            return themeColor(theme, 'info');
+        case 'interrupted':
+            return themeColor(theme, 'warning');
+        default:
+            return themeColor(theme, 'muted');
+    }
+}
+/** Orchestration agent strip, toggled with /agents or Ctrl+T. */
+export function AgentDock({ width, height }) {
+    const store = useStore();
+    const agents = [...store.agents.values()];
+    if (!store.dockOpen)
+        return null;
+    const cap = height ?? agents.length + 1;
+    if (cap <= 0)
+        return null;
+    const accent = store.theme ? themeColor(store.theme, 'accent') : '#7aa2f7';
+    const dim = store.theme ? themeColor(store.theme, 'dim') : '#565f89';
+    const shown = agents.slice(0, Math.max(0, cap - 1));
+    return (_jsxs(Box, { width: width, flexDirection: "column", children: [_jsx(Text, { color: accent, wrap: "truncate-end", children: "\u2508 agents \u2508" }), shown.length === 0 && cap >= 2 && _jsx(Text, { color: dim, wrap: "truncate-end", children: "no agents running" }), shown.map((a) => (_jsxs(Box, { children: [_jsx(Text, { color: statusColor(store.theme, a.status), children: STATUS_DOT[a.status] ?? '○' }), _jsx(Text, { color: dim, wrap: "truncate-end", children: ` ${a.name}` }), a.task && _jsx(Text, { color: dim, wrap: "truncate-end", children: ` · ${a.task}` })] }, a.id)))] }));
+}

package/dist/src/tui/components/Composer.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text, useWindowSize } from 'ink';
+import { useStore } from '../context.js';
+import { renderAnsi } from '../ansi.js';
+import { renderInputArea } from './input.js';
+import { composerHeight } from '../geometry.js';
+import { buildTheme } from '../style.js';
+/**
+ * The sticky prompt at the bottom of the screen. Reuses the existing
+ * `renderInputArea` logic (soft-wrap + block cursor baked into the ANSI).
+ * The OS cursor is deliberately left hidden (Ink default): the inverted
+ * block cell is the only cursor, so on mobile keyboards there is no second,
+ * misaligned caret fighting the real edit position.
+ */
+export function Composer() {
+    const store = useStore();
+    const { columns } = useWindowSize();
+    const ask = store.pendingAsk;
+    const theme = store.theme ?? buildTheme('tokyonight');
+    let rows;
+    let cursorCol = 0;
+    if (ask) {
+        const dim = theme.table.sgr(theme.styles['dim']);
+        rows = [`${dim}permission prompt open — answer in the panel above${'\x1b[0m'}`];
+        cursorCol = 0;
+    }
+    else {
+        const height = composerHeight(store.input, columns);
+        const rendered = renderInputArea(store.input, theme, columns, height, store.streaming);
+        rows = rendered.rows;
+        cursorCol = rendered.cursorCol;
+    }
+    void cursorCol;
+    return (_jsx(Box, { flexDirection: "column", children: rows.map((r, i) => (_jsx(Box, { height: 1, children: _jsx(Text, { wrap: "truncate-end", children: renderAnsi(r, `composer-${i}`) }) }, i))) }));
+}

package/dist/src/tui/components/Header.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useStore } from '../context.js';
+import { themeColor } from '../colors.js';
+function shortPath(cwd) {
+    const home = process.env.HOME;
+    if (home && cwd.startsWith(home))
+        return `~${cwd.slice(home.length) || '/'}`;
+    const parts = cwd.split('/').filter(Boolean);
+    if (parts.length <= 3)
+        return cwd || '/';
+    return `…/${parts.slice(-3).join('/')}`;
+}
+export function Header({ width }) {
+    const store = useStore();
+    const accent = store.theme ? themeColor(store.theme, 'accent') : '#7aa2f7';
+    const muted = store.theme ? themeColor(store.theme, 'muted') : '#565f89';
+    const dim = store.theme ? themeColor(store.theme, 'dim') : '#3b4281';
+    const border = store.theme ? themeColor(store.theme, 'border') : '#565f89';
+    const model = store.route ? `${store.route.provider}/${store.route.model}` : 'no route';
+    const dir = shortPath(store.cwd || process.cwd());
+    return (_jsxs(Box, { width: width, borderStyle: "single", borderColor: border, flexDirection: "column", paddingX: 1, children: [_jsxs(Box, { height: 1, children: [_jsx(Text, { color: accent, bold: true, wrap: "truncate-end", children: '>_ orbit' }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: ` (v${store.version})` }), _jsx(Text, { color: muted, wrap: "truncate-end", children: `   model: ${model}` }), _jsx(Text, { color: dim, wrap: "truncate-end", children: '   /model' })] }), _jsx(Box, { height: 1, children: _jsx(Text, { color: dim, wrap: "truncate-end", children: `directory: ${dir}` }) })] }));
+}

package/dist/src/tui/components/ModelPicker.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useStore } from '../context.js';
+import { themeColor } from '../colors.js';
+const MAX_VISIBLE = 8;
+/** Interactive model selector shown above the composer (opened by /model). */
+export function ModelPicker({ width }) {
+    const store = useStore();
+    const list = store.models;
+    const accent = store.theme ? themeColor(store.theme, 'accent') : '#7aa2f7';
+    const dim = store.theme ? themeColor(store.theme, 'dim') : '#565f89';
+    const muted = store.theme ? themeColor(store.theme, 'muted') : '#969cbc';
+    if (list.length === 0) {
+        return (_jsx(Box, { width: width, children: _jsx(Text, { color: dim, children: "no models available \u2014 configure a provider key first" }) }));
+    }
+    const idx = Math.min(Math.max(store.modelPicker.index, 0), list.length - 1);
+    const start = Math.max(0, Math.min(idx, list.length - MAX_VISIBLE));
+    const window = list.slice(start, start + MAX_VISIBLE);
+    return (_jsxs(Box, { width: width, flexDirection: "column", children: [start > 0 && _jsxs(Text, { color: muted, children: ["\u25B2 ", (start).toLocaleString(), " more\u2026"] }), window.map((m, i) => {
+                const at = start + i;
+                return (_jsxs(Box, { children: [_jsx(Text, { color: at === idx ? accent : dim, children: at === idx ? '❯ ' : '  ' }), _jsx(Text, { color: at === idx ? accent : dim, children: m })] }, m));
+            }), start + MAX_VISIBLE < list.length && _jsx(Text, { color: muted, children: "\u25BC more\u2026" }), _jsx(Text, { color: muted, children: "\u2191\u2193 select \u00B7 Enter choose \u00B7 Esc close" })] }));
+}

package/dist/src/tui/components/PermissionModal.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { ASK_OPTIONS } from '../store.js';
+import { useStore } from '../context.js';
+import { themeColor } from '../colors.js';
+const PANEL_H = 5;
+/**
+ * In-flow permission panel rendered above the separator/composer (not an
+ * absolute overlay), so it can never overlap streamed content or code fences.
+ * Keep PANEL_H in sync with ASK_H in geometry.ts.
+ */
+export function PermissionModal({ cols }) {
+    const store = useStore();
+    const ask = store.pendingAsk;
+    const theme = store.theme;
+    if (!ask)
+        return null;
+    const accent = theme ? themeColor(theme, 'accent') : '#7aa2f7';
+    const warning = theme ? themeColor(theme, 'warning') : '#e0af68';
+    const dim = theme ? themeColor(theme, 'dim') : '#565f89';
+    const muted = theme ? themeColor(theme, 'muted') : '#969cbc';
+    const width = Math.max(20, cols);
+    const body = ask.prompt || 'Allow this action?';
+    return (_jsxs(Box, { width: width, height: PANEL_H, flexDirection: "column", borderStyle: "round", borderColor: ask.index === 0 ? accent : warning, paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: warning, children: '⚠ ' }), _jsx(Text, { bold: true, wrap: "truncate-end", children: body })] }), _jsx(Box, { children: ASK_OPTIONS.map((opt, i) => {
+                    const active = i === ask.index;
+                    const color = active ? (i === 0 ? accent : warning) : dim;
+                    return (_jsxs(Box, { paddingRight: 4, children: [_jsx(Text, { color: color, children: active ? '❯ ' : '  ' }), _jsx(Text, { bold: active, color: color, children: opt })] }, opt));
+                }) }), _jsx(Box, { children: _jsx(Text, { color: muted, children: '↑↓ select · Enter choose · Esc/y/n answer' }) })] }));
+}

package/dist/src/tui/components/SlashMenu.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useStore } from '../context.js';
+import { themeColor } from '../colors.js';
+/** Inline slash-command menu shown under the transcript while typing `/`. */
+export function SlashMenu({ width }) {
+    const store = useStore();
+    const matches = store.slashMatches();
+    if (matches.length === 0)
+        return null;
+    const accent = store.theme ? themeColor(store.theme, 'accent') : '#7aa2f7';
+    const dim = store.theme ? themeColor(store.theme, 'dim') : '#565f89';
+    const muted = store.theme ? themeColor(store.theme, 'muted') : '#969cbc';
+    return (_jsxs(Box, { width: width, flexDirection: "column", children: [matches.map((m) => (_jsxs(Box, { children: [_jsx(Text, { color: accent, children: m.cmd }), _jsx(Text, { color: dim, children: ` ${m.desc}` })] }, m.cmd))), _jsx(Text, { color: muted, children: "Tab autocompletes \u00B7 Esc closes" })] }));
+}

package/dist/src/tui/components/StatusLine.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useStore } from '../context.js';
+import { themeColor } from '../colors.js';
+function shortPath(cwd) {
+    const home = process.env.HOME;
+    if (home && cwd.startsWith(home))
+        return `~${cwd.slice(home.length) || '/'}`;
+    const parts = cwd.split('/').filter(Boolean);
+    if (parts.length <= 3)
+        return cwd || '/';
+    return `…/${parts.slice(-3).join('/')}`;
+}
+/** One line under the prompt: `model · path · state`. */
+export function StatusLine({ width }) {
+    const store = useStore();
+    const model = store.route ? `${store.route.provider}/${store.route.model}` : 'no model';
+    const state = store.pendingAsk ? 'confirm' : store.streaming ? 'running' : 'idle';
+    const path = shortPath(store.cwd || process.cwd());
+    const dim = store.theme ? themeColor(store.theme, 'dim') : '#565f89';
+    const muted = store.theme ? themeColor(store.theme, 'muted') : '#969cbc';
+    const info = store.theme ? themeColor(store.theme, 'info') : '#7dcfff';
+    const body = `${model} · ${path} · `;
+    const stateColor = state === 'running' ? info : dim;
+    const right = ' /help';
+    return (_jsxs(Box, { width: width, justifyContent: "space-between", children: [_jsxs(Text, { color: muted, wrap: "truncate-end", children: [body, _jsx(Text, { color: stateColor, children: state })] }), _jsx(Text, { color: dim, wrap: "truncate-end", children: right })] }));
+}

package/dist/src/tui/components/Transcript.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useStore } from '../context.js';
+import { renderAnsi } from '../ansi.js';
+/**
+ * Scrollable transcript window. Rows are pre-wrapped single terminal lines, so
+ * the visible window is a pure slice of the flat row array: PageUp moves the
+ * window back (`scrollOffset`), everything else sticks to the newest lines.
+ */
+export function Transcript({ rows, viewport }) {
+    const store = useStore();
+    const height = Math.max(0, viewport);
+    const total = rows.length;
+    let start;
+    if (store.scrollOffset > 0) {
+        start = Math.max(0, Math.min(store.scrollOffset, Math.max(0, total - height)));
+    }
+    else {
+        start = Math.max(0, total - height);
+    }
+    const visible = rows.slice(start, start + height);
+    // Reserve the full region so layout height stays stable while scrolling.
+    if (height === 0)
+        return _jsx(Box, { flexGrow: 1 });
+    return (_jsx(Box, { flexGrow: 1, flexDirection: "column", overflow: "hidden", children: Array.from({ length: height }, (_, i) => {
+            const row = visible[i];
+            if (!row)
+                return _jsx(Box, { height: 1 }, `pad${i}`);
+            return (_jsx(Box, { height: 1, children: _jsx(Text, { wrap: "truncate-end", children: renderAnsi(row.text, row.id) }) }, row.id));
+        }) }));
+}

package/dist/src/tui/components/WorkingStatus.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import { useStore } from '../context.js';
+import { themeColor } from '../colors.js';
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/** `• Working (Ns · esc to interrupt)` shown while the agent streams. */
+export function WorkingStatus() {
+    const store = useStore();
+    const [frame, setFrame] = useState(0);
+    const [startAt] = useState(() => Date.now());
+    const [tick, setTick] = useState(0);
+    useEffect(() => {
+        if (!store.streaming)
+            return;
+        const id = setInterval(() => {
+            setFrame((f) => f + 1);
+            setTick((t) => t + 1);
+        }, 300);
+        return () => clearInterval(id);
+    }, [store.streaming]);
+    if (!store.streaming)
+        return null;
+    const seconds = Math.max(1, Math.floor((Date.now() - startAt) / 1000));
+    const spinner = FRAMES[frame % FRAMES.length];
+    void tick;
+    const muted = store.theme ? themeColor(store.theme, 'muted') : '#969cbc';
+    return (_jsx(Box, { justifyContent: "center", children: _jsx(Text, { color: muted, children: `${spinner} Working (${seconds}s · esc to interrupt)` }) }));
+}

package/dist/src/tui/components/input.js

@@ -0,0 +1,246 @@
+import stringWidth from 'string-width';
+import { wrapText } from '../text.js';
+const PROMPT = '❯ ';
+const CONTINUE = '  ';
+export class InputState {
+    lines = [''];
+    cursorLine = 0;
+    cursorCol = 0;
+    history = [];
+    historyIdx = -1;
+    pasteMode = false;
+    currentBuffer() {
+        return this.lines.join('\n');
+    }
+    clear() {
+        this.lines = [''];
+        this.cursorLine = 0;
+        this.cursorCol = 0;
+        this.historyIdx = -1;
+    }
+    pushHistory(text) {
+        if (text.trim().length > 0)
+            this.history.push(text);
+        this.historyIdx = this.history.length;
+    }
+    submitBuffer() {
+        const text = this.currentBuffer();
+        this.pushHistory(text);
+        this.clear();
+        return text;
+    }
+    insertChar(ch) {
+        const line = this.lines[this.cursorLine];
+        this.lines[this.cursorLine] = line.slice(0, this.cursorCol) + ch + line.slice(this.cursorCol);
+        this.cursorCol += ch.length;
+    }
+    insertNewline() {
+        const before = this.lines[this.cursorLine].slice(0, this.cursorCol);
+        const after = this.lines[this.cursorLine].slice(this.cursorCol);
+        this.lines[this.cursorLine] = before;
+        this.lines.splice(this.cursorLine + 1, 0, after);
+        this.cursorLine++;
+        this.cursorCol = 0;
+    }
+    backspace() {
+        if (this.cursorCol > 0) {
+            const line = this.lines[this.cursorLine];
+            this.lines[this.cursorLine] = line.slice(0, this.cursorCol - 1) + line.slice(this.cursorCol);
+            this.cursorCol--;
+        }
+        else if (this.cursorLine > 0) {
+            const prevLen = this.lines[this.cursorLine - 1].length;
+            this.lines[this.cursorLine - 1] += this.lines[this.cursorLine];
+            this.lines.splice(this.cursorLine, 1);
+            this.cursorLine--;
+            this.cursorCol = prevLen;
+        }
+    }
+    delete() {
+        const line = this.lines[this.cursorLine];
+        if (this.cursorCol < line.length) {
+            this.lines[this.cursorLine] = line.slice(0, this.cursorCol) + line.slice(this.cursorCol + 1);
+        }
+        else if (this.cursorLine < this.lines.length - 1) {
+            this.lines[this.cursorLine] += this.lines[this.cursorLine + 1];
+            this.lines.splice(this.cursorLine + 1, 1);
+        }
+    }
+    moveLeft() {
+        if (this.cursorCol > 0)
+            this.cursorCol--;
+        else if (this.cursorLine > 0) {
+            this.cursorLine--;
+            this.cursorCol = this.lines[this.cursorLine].length;
+        }
+    }
+    moveRight() {
+        const line = this.lines[this.cursorLine];
+        if (this.cursorCol < line.length)
+            this.cursorCol++;
+        else if (this.cursorLine < this.lines.length - 1) {
+            this.cursorLine++;
+            this.cursorCol = 0;
+        }
+    }
+    moveUp() {
+        const line = this.lines[this.cursorLine];
+        const target = Math.min(this.cursorCol, line.length);
+        // Move to the visual line above when possible (soft-wrap aware).
+        if (this.cursorLine > 0) {
+            this.cursorLine--;
+            this.cursorCol = Math.min(target, this.lines[this.cursorLine].length);
+        }
+    }
+    moveDown() {
+        const target = this.cursorCol;
+        if (this.cursorLine < this.lines.length - 1) {
+            this.cursorLine++;
+            this.cursorCol = Math.min(target, this.lines[this.cursorLine].length);
+        }
+    }
+    moveToStart() { this.cursorCol = 0; }
+    moveToEnd() { this.cursorCol = this.lines[this.cursorLine].length; }
+    moveHistoryUp() {
+        if (this.historyIdx <= 0)
+            return;
+        this.historyIdx--;
+        this.replaceWithHistory();
+    }
+    moveHistoryDown() {
+        if (this.historyIdx >= this.history.length - 1) {
+            this.historyIdx = this.history.length;
+            this.clear();
+            return;
+        }
+        this.historyIdx++;
+        this.replaceWithHistory();
+    }
+    replaceWithHistory() {
+        const entry = this.history[this.historyIdx] ?? '';
+        this.lines = entry.split('\n');
+        this.cursorLine = this.lines.length - 1;
+        this.cursorCol = this.lines[this.cursorLine].length;
+    }
+    deleteWordBack() {
+        const line = this.lines[this.cursorLine];
+        if (this.cursorCol === 0) {
+            this.backspace();
+            return;
+        }
+        let i = this.cursorCol - 1;
+        while (i > 0 && line[i] === ' ')
+            i--;
+        while (i > 0 && line[i - 1] !== ' ' && line[i - 1] !== '\n')
+            i--;
+        this.lines[this.cursorLine] = line.slice(0, i) + line.slice(this.cursorCol);
+        this.cursorCol = i;
+    }
+    deleteToEnd() {
+        const line = this.lines[this.cursorLine];
+        this.lines[this.cursorLine] = line.slice(0, this.cursorCol);
+    }
+    deleteToStart() {
+        const line = this.lines[this.cursorLine];
+        this.lines[this.cursorLine] = line.slice(this.cursorCol);
+        this.cursorCol = 0;
+    }
+}
+/**
+ * Render the input region at `width` × `height` (rows). Returns styled rows
+ * (subject to background-baking by composeRow) and cursor coordinates.
+ * The cursor row is always kept on screen.
+ */
+export function renderInputArea(state, theme, width, height, streaming) {
+    const textSgr = theme.table.sgr(theme.styles['text']);
+    const dimSgr = theme.table.sgr(theme.styles['muted']);
+    const accentSgr = theme.table.sgr(theme.styles['accent']);
+    const invSgr = theme.table.sgr(theme.styles['selection']);
+    const reset = '\x1b[0m';
+    const contentW = Math.max(1, width - 2);
+    const visuals = [];
+    for (let li = 0; li < state.lines.length; li++) {
+        const raw = state.lines[li];
+        if (raw === '') {
+            visuals.push({ text: '', lineIdx: li, startChar: 0, endChar: 0 });
+            continue;
+        }
+        const wrapped = wrapText(raw, contentW);
+        let start = 0;
+        for (const piece of wrapped) {
+            visuals.push({ text: piece, lineIdx: li, startChar: start, endChar: start + piece.length });
+            start += piece.length;
+        }
+    }
+    // Cursor → visual row + column.
+    let cursorVis = 0;
+    let cursorTargetEnd = state.cursorLine; // prefer row containing cursor end
+    for (let i = 0; i < visuals.length; i++) {
+        const v = visuals[i];
+        if (v.lineIdx > state.cursorLine)
+            break;
+        const containsBefore = v.lineIdx < state.cursorLine ||
+            (v.lineIdx === state.cursorLine && state.cursorCol >= v.startChar);
+        if (containsBefore && v.lineIdx <= state.cursorLine) {
+            cursorVis = i;
+            // If the cursor sits exactly at a wrap boundary it belongs to this row.
+            if (v.lineIdx === state.cursorLine && state.cursorCol <= v.endChar) {
+                cursorTargetEnd = v.endChar;
+            }
+            if (state.cursorCol >= v.startChar && state.cursorCol <= v.endChar) {
+                cursorTargetEnd = v.endChar;
+                break;
+            }
+            if (state.cursorLine === v.lineIdx)
+                break;
+        }
+    }
+    // Cursor column within its visual row:
+    const cRow = visuals[cursorVis];
+    const cursorX = cRow
+        ? Math.min(state.cursorCol - cRow.startChar, stringWidth(cRow.text))
+        : 0;
+    // Window the visual rows so the cursor stays visible.
+    let windowStart = 0;
+    if (visuals.length > height) {
+        windowStart = Math.max(0, Math.min(cursorVis, visuals.length - height));
+        if (cursorVis < windowStart)
+            windowStart = cursorVis;
+        if (cursorVis >= windowStart + height)
+            windowStart = cursorVis - height + 1;
+        windowStart = Math.max(0, Math.min(windowStart, visuals.length - height));
+    }
+    const shown = visuals.slice(windowStart, windowStart + height);
+    const rows = [];
+    for (let i = 0; i < shown.length; i++) {
+        const v = shown[i];
+        const isFirst = i === 0 && windowStart === 0 && v.lineIdx === 0;
+        const prefix = isFirst ? `${accentSgr}${PROMPT}${reset}` : `${dimSgr}${CONTINUE}${reset}`;
+        const absCol = isFirst ? 2 : 2;
+        const rowIsCursor = windowStart + i === cursorVis;
+        let line;
+        if (rowIsCursor) {
+            const before = v.text.slice(0, cursorX);
+            const at = v.text[cursorX];
+            const after = v.text.slice(cursorX + 1);
+            line = `${textSgr}${before}${invSgr}${at ?? ' '}${reset}${textSgr}${after}${reset}`;
+        }
+        else {
+            line = `${textSgr}${v.text}${reset}`;
+        }
+        rows.push(`${prefix}${line}`);
+        void absCol;
+    }
+    const isEmpty = state.lines.length === 1 && state.lines[0] === '';
+    if (isEmpty && !streaming) {
+        rows[0] = `${accentSgr}${PROMPT}${reset}${dimSgr}type a message…  ·  /help${reset}`;
+    }
+    else if (streaming) {
+        rows[0] = `${accentSgr}…${reset}${dimSgr} streaming — Esc to stop${reset}`;
+    }
+    // Fill remaining region height with blank rows.
+    while (rows.length < height)
+        rows.push('');
+    return { rows, cursorRow: windowStart === 0 ? cursorVis : Math.min(cursorVis - windowStart, height - 1), cursorCol: cursorX };
+}
+export { renderInputArea as renderInput }; // alias for old call-sites