omniharness-cli 0.1.82 → 0.1.83

package/dist/ui/terminalInterface.js

@@ -10,6 +10,8 @@ import { looksLikeDiff, diffSegments } from './diff.js';
 import { palette } from './palette.js';
 import { capabilityLine, recentRows, shortenPath, twoColumn } from './home.js';
 import { conversationWidth, overflowCount, sidebarMode, SIDEBAR_WIDTH, todoRows, usageRows, clip as clipRow } from './sidebar.js';
+import { planViewport } from './viewport.js';
+import { statusMarker, toolHead } from './toolrow.js';
 import { contextMeter, meterBar } from './modelWindows.js';
 import { BEL, SYNC_QUERY, isSyncOutputReply, osc9Notify, osc52Copy, shouldNudgeOnFinish, wrapSynchronizedOutput } from './termcaps.js';
 import { KITTY_POP, KITTY_PUSH, KITTY_QUERY, isEncodedKey, isKittyQueryResponse, parseRawKey } from './keys.js';
@@ -87,8 +89,12 @@ const PERM_COLOR = (p) => (p === 'bypass' ? PALETTE.error : p === 'acceptEdits'
  * the end of it, and the chrome ends up further from what it describes.
  */
 const MAX_MEASURE = 100;
+/** Shown after an expanded tool head; the head reserves room for it. */
+const COLLAPSE_HINT = '   Ctrl+T collapse';
 const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
 const widthOf = (stdout) => Math.max(48, stdout.columns ?? 80);
+/** Terminal height, floored so the layout maths never goes negative. */
+const rowsOf = (stdout) => Math.max(8, stdout.rows ?? 24);
 const clip = (text, width) => text.length <= width ? text : `${text.slice(0, Math.max(0, width - 1))}…`;
 /** Word-wrap text to width, honoring existing newlines and hard-breaking long words. */
 function wrap(text, width) {
@@ -244,6 +250,12 @@ export function TerminalInterface({ engine }) {
     const { stdout } = useStdout();
     const { stdin } = useStdin();
     const [width, setWidth] = useState(() => widthOf(stdout));
+    // Height has to be state for the same reason width is. Maximising and
+    // then floating a window changes rows without necessarily changing
+    // columns, and setting width to the value it already had re-renders
+    // nothing — so the live region kept the height budget of the old
+    // terminal and overran the viewport.
+    const [rows, setRows] = useState(() => rowsOf(stdout));
     const [edit, setEdit] = useState({ value: '', cursor: 0 });
     const inputWidth = Math.max(16, Math.min(width, MAX_MEASURE) - 12); // recomputed below once the split is known
     // Settled transcript. Rendered once each into <Static> — the terminal's own
@@ -301,7 +313,10 @@ export function TerminalInterface({ engine }) {
         return () => { alive = false; };
     }, []);
     useEffect(() => {
-        const onResize = () => setWidth(widthOf(stdout));
+        const onResize = () => {
+            setWidth(widthOf(stdout));
+            setRows(rowsOf(stdout));
+        };
         stdout.on('resize', onResize);
         stdout.write(KITTY_PUSH);
         let kittyTimer;
@@ -964,7 +979,7 @@ export function TerminalInterface({ engine }) {
     const gutter = Math.max(2, Math.floor((width - measure) / 2));
     const convoWidth = conversationWidth(measure, sideMode);
     const contentWidth = Math.max(20, convoWidth - 6);
-    const terminalRows = stdout.rows ?? 24;
+    const terminalRows = rows;
     const metrics = engine.client.snapshotMetrics();
     const meter = contextMeter(metrics.compression.inputTokens, engine.state.activeModel, metrics.fallback.activeProvider);
     const meterColor = meter.zone === 'danger' ? PALETTE.error : meter.zone === 'warn' ? PALETTE.warn : PALETTE.muted;
@@ -980,18 +995,27 @@ export function TerminalInterface({ engine }) {
     const liveAnswerLines = useMemo(() => renderMarkdown(liveAnswer, contentWidth), [liveAnswer, contentWidth]);
     // Cap the streaming region so a long think/answer can't crowd out the chrome;
     // the complete text lands in <Static> once the event fires.
-    const liveBudget = Math.max(3, terminalRows - 14 - Math.min(6, taskQueue.length) - Math.min(4, agents.length) - editorLayout.lines.length);
+    // What fits. The old budget subtracted a fixed 14 rows of guesswork and
+    // never bounded the sections it was competing with, so a short terminal
+    // still produced a frame taller than itself.
+    const view = planViewport({
+        rows: terminalRows,
+        editorLines: editorLayout.lines.length,
+        toolCards: toolCards.length,
+        todos: taskQueue.length,
+        wantHero: lines.length === 0 && !busy,
+    });
+    const liveBudget = view.liveLines;
     const liveThinkView = liveThinkLines.slice(-Math.max(2, Math.floor(liveBudget / 2)));
     const liveAnswerView = liveAnswerLines.slice(-liveBudget);
     const doneAgents = agents.filter((lane) => lane.status === 'done').length;
     const panel = _jsx(SidebarPanel, { width: SIDEBAR_WIDTH, model: engine.state.activeModel, mode: mode, perm: permMode, workspace: engine.state.workspace.root, usage: { tokensIn: metrics.compression.inputTokens, requests: metrics.requestCount }, agents: agents, todos: taskQueue, skills: engine.skills.length, plugins: new Set(engine.skills.map((skill) => skill.source).filter((source) => source !== undefined)).size });
-    return _jsxs(Box, { flexDirection: "column", width: width, paddingLeft: gutter, paddingRight: gutter, children: [_jsx(Static, { items: lines, children: (line, index) => _jsx(TranscriptEntry, { line: line, width: contentWidth, fallbackModel: engine.state.activeModel }, index) }, staticKey), sideMode === 'replace' && _jsx(Box, { marginBottom: 1, children: panel }), _jsxs(Box, { flexDirection: "row", alignItems: "flex-start", children: [_jsxs(Box, { flexDirection: "column", width: sideMode === 'split' ? convoWidth : undefined, flexGrow: sideMode === 'split' ? 0 : 1, children: [lines.length === 0 && !busy && _jsx(Hero, { width: contentWidth + 2, endpoint: engine.client.endpoint ?? 'omniroute', model: engine.state.activeModel, mode: mode, perm: permMode, workspace: engine.state.workspace.root, sessions: recentSessions, skills: engine.skills.length, plugins: new Set(engine.skills.map((skill) => skill.source).filter((source) => source !== undefined)).size, mcpTools: engine.mcpTools.length }), liveThink !== '' && _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: PALETTE.warn, children: "\u00B7 thinking" }), liveThinkView.map((segments, index) => _jsx(SegmentText, { segments: segments, role: "thinking" }, index))] }), liveAnswer !== '' && _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: PALETTE.accent, children: engine.state.activeModel }), liveAnswerView.map((segments, index) => _jsx(SegmentText, { segments: segments, role: "assistant" }, index))] }), toolCards.slice(-5).map((card) => {
+    return _jsxs(Box, { flexDirection: "column", width: width, paddingLeft: gutter, paddingRight: gutter, children: [_jsx(Static, { items: lines, children: (line, index) => _jsx(TranscriptEntry, { line: line, width: contentWidth, fallbackModel: engine.state.activeModel }, index) }, staticKey), sideMode === 'replace' && _jsx(Box, { marginBottom: 1, children: panel }), _jsxs(Box, { flexDirection: "row", alignItems: "flex-start", children: [_jsxs(Box, { flexDirection: "column", width: sideMode === 'split' ? convoWidth : undefined, flexGrow: sideMode === 'split' ? 0 : 1, children: [view.showHero && _jsx(Hero, { width: contentWidth + 2, endpoint: engine.client.endpoint ?? 'omniroute', model: engine.state.activeModel, mode: mode, perm: permMode, workspace: engine.state.workspace.root, sessions: recentSessions, skills: engine.skills.length, plugins: new Set(engine.skills.map((skill) => skill.source).filter((source) => source !== undefined)).size, mcpTools: engine.mcpTools.length }), liveThink !== '' && _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: PALETTE.warn, children: "\u00B7 thinking" }), liveThinkView.map((segments, index) => _jsx(SegmentText, { segments: segments, role: "thinking" }, index))] }), liveAnswer !== '' && _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: PALETTE.accent, children: engine.state.activeModel }), liveAnswerView.map((segments, index) => _jsx(SegmentText, { segments: segments, role: "assistant" }, index))] }), (view.toolCards > 0 ? toolCards.slice(-view.toolCards) : []).map((card) => {
                                 const expanded = expandedTool === card.id;
-                                const dot = card.status === 'running' ? _jsx(Text, { color: PALETTE.warn, children: ".." }) : card.status === 'error' ? _jsx(Text, { color: PALETTE.error, children: "FAIL" }) : _jsx(Text, { color: PALETTE.success, children: "ok" });
-                                const head = card.name === 'run_command'
-                                    ? `$ ${clip(card.target || '…', Math.max(10, contentWidth - 20))}`
-                                    : `${toolVerb(card.name)}${card.target ? ` ${clip(card.target, Math.max(10, contentWidth - 24))}` : ''}`;
-                                return _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [dot, " ", head, expanded ? '   Ctrl+T collapse' : ''] }), expanded && renderToolBody(card, contentWidth, PALETTE)] }, card.id);
+                                const status = card.status === 'running' ? 'running' : card.status === 'error' ? 'error' : 'done';
+                                const statusColor = status === 'running' ? PALETTE.warn : status === 'error' ? PALETTE.error : PALETTE.success;
+                                const head = toolHead(card.name === 'run_command' ? '$' : toolVerb(card.name), card.name === 'run_command' ? (card.target || '…') : card.target, contentWidth, expanded ? COLLAPSE_HINT.length : 0);
+                                return _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: statusColor, children: statusMarker(status) }), _jsx(Text, { dimColor: true, children: head }), expanded ? _jsx(Text, { dimColor: true, children: COLLAPSE_HINT }) : null] }), expanded && _jsx(Box, { borderStyle: "round", borderColor: statusColor, borderTop: false, borderBottom: false, borderRight: false, paddingLeft: 1, marginLeft: 1, flexDirection: "column", children: renderToolBody(card, Math.max(10, contentWidth - 4), PALETTE) })] }, card.id);
                             }), sideMode === 'hidden' && agents.length > 0 && _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: PALETTE.error, paddingX: 2, marginTop: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, color: PALETTE.error, children: "swarm" }), _jsxs(Text, { dimColor: true, children: [doneAgents, "/", agents.length, " lanes done"] })] }), agents.map((lane, index) => {
                                         const color = AGENT_COLORS[index % AGENT_COLORS.length];
                                         const glyph = lane.status === 'done' ? 'ok' : lane.status === 'error' ? 'FAIL' : lane.status === 'working' ? '..' : '--';

package/dist/ui/toolrow.js

@@ -0,0 +1,53 @@
+/**
+ * Tool row composition.
+ *
+ * Follows the two shapes OpenCode uses (MIT, anomalyco/opencode): a one-line
+ * inline row with a fixed-width status column so descriptions align down the
+ * page, and a block form for output, marked with a rule down its left edge
+ * rather than boxed on all four sides — a full border around every tool
+ * result turns a transcript into a stack of crates.
+ */
+/**
+ * Width of the status column. Every marker is padded to it, so the tool
+ * descriptions start at the same column whatever happened to the call. The
+ * markers were 'ok' (2), 'FAIL' (4) and '..' (2), which meant every failure
+ * shunted its own description two columns right.
+ */
+// Five, not four: the longest marker is 'FAIL', and padding to its own
+// length leaves no gap, so a failed call rendered as "FAIL$ go test ...".
+// The extra column is the separator, which is why the head is not padded
+// again on the other side.
+export const STATUS_WIDTH = 5;
+/** Plain-word status marker, padded to a fixed column. No glyphs. */
+export function statusMarker(status) {
+    switch (status) {
+        case 'running': return '..'.padEnd(STATUS_WIDTH);
+        case 'error': return 'FAIL'.padEnd(STATUS_WIDTH);
+        case 'denied': return 'no'.padEnd(STATUS_WIDTH);
+        default: return 'ok'.padEnd(STATUS_WIDTH);
+    }
+}
+/**
+ * The text beside the marker: a verb and its target, clipped to the room
+ * actually left once the status column and the indent are accounted for.
+ * Sizing this to the full width is what makes rows wrap and the column
+ * collapse.
+ */
+export function toolHead(verb, target, width, reserve = 0) {
+    // `reserve` is room kept for something drawn after the head on the same
+    // row — the collapse hint, today. Without it the hint pushed itself onto a
+    // line of its own, which is worse than not showing it.
+    const room = Math.max(8, width - STATUS_WIDTH - 2 - Math.max(0, reserve));
+    if (target === '')
+        return clip(verb, room);
+    const head = `${verb} ${target}`;
+    return clip(head, room);
+}
+export function clip(text, width) {
+    const flat = text.replace(/\s+/g, ' ');
+    const runes = [...flat];
+    if (runes.length <= width)
+        return flat;
+    return `${runes.slice(0, Math.max(0, width - 1)).join('')}…`;
+}
+//# sourceMappingURL=toolrow.js.map

package/dist/ui/viewport.js

@@ -0,0 +1,62 @@
+/**
+ * How much of the live region fits in the terminal.
+ *
+ * Ink redraws its live region by walking the cursor up over the lines it
+ * wrote last time and erasing them. That accounting only holds while the
+ * frame fits on screen: once it is taller than the viewport the terminal
+ * scrolls it, the cursor no longer lands where Ink expects, and the redraw
+ * eats the transcript above or leaves a trail of half-erased frames. It shows
+ * up as the display "going weird" after a resize, because maximising and then
+ * floating a window is the ordinary way to make the viewport smaller than the
+ * frame that was drawn for it.
+ *
+ * So the sections that can grow are given a budget rather than a fixed cap.
+ */
+/** Rows the input frame, status line and key hints always need. */
+const CHROME_ROWS = 6;
+/** Rows the home screen occupies when it is drawn. */
+const HERO_ROWS = 12;
+/** Streaming never drops below this, or a running turn looks like a hang. */
+const LIVE_MIN = 2;
+const MAX_TOOL_CARDS = 5;
+const MAX_TODO_ROWS = 6;
+/**
+ * Decide what fits. Order of sacrifice, least useful first: the home screen
+ * goes before tool cards, tool cards before the queue, and streaming text
+ * keeps a floor because a turn with nothing visible reads as a hang.
+ */
+export function planViewport(input) {
+    const rows = Math.max(8, Math.floor(input.rows));
+    const editor = Math.max(1, Math.floor(input.editorLines));
+    let free = rows - CHROME_ROWS - editor;
+    // The home screen only appears before the first turn, and only when there
+    // is genuinely room: half a home screen is worse than none.
+    const showHero = input.wantHero && free >= HERO_ROWS + LIVE_MIN;
+    if (showHero)
+        free -= HERO_ROWS;
+    // The bounded sections are allocated first and streaming absorbs the rest.
+    // Taking a share of the remainder for streaming up front looks fair and is
+    // not: on a tall terminal it starved the queue of rows there was plenty of
+    // room for.
+    let budget = free - LIVE_MIN;
+    const toolCards = clamp(input.toolCards, 0, Math.max(0, Math.min(MAX_TOOL_CARDS, budget)));
+    budget -= toolCards;
+    const todoRows = clamp(input.todos, 0, Math.max(0, Math.min(MAX_TODO_ROWS, budget)));
+    budget -= todoRows;
+    // Whatever is left goes to the running turn, never below the floor — a turn
+    // with nothing visible reads as a hang.
+    const liveLines = LIVE_MIN + Math.max(0, budget);
+    return { toolCards, todoRows, liveLines, showHero };
+}
+/**
+ * The smallest frame this can produce: the input and the chrome around it,
+ * plus the streaming floor. Below this the terminal is simply too short and
+ * nothing can be given up to fix it.
+ */
+export function minimumHeight(editorLines) {
+    return CHROME_ROWS + Math.max(1, Math.floor(editorLines)) + LIVE_MIN;
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, Math.floor(value)));
+}
+//# sourceMappingURL=viewport.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omniharness-cli",
-  "version": "0.1.82",
+  "version": "0.1.83",
   "description": "OmniHarness — local-first agent orchestration harness for OmniRoute.",
   "license": "MIT",
   "type": "module",