omniharness-cli 0.1.82 → 0.1.84

package/dist/config/omniRoute.js

@@ -32,6 +32,7 @@ export class OmniRouteClient {
     metrics = {
         compression: { inputTokens: 0, compressedTokens: 0, ratio: 1, strategy: 'none', updatedAt: new Date().toISOString() },
         fallback: { attempts: 0 },
+        usage: { contextTokens: 0, tokensIn: 0, tokensOut: 0, costUsd: 0 },
         requestCount: 0,
     };
     constructor(config = {}) {
@@ -186,7 +187,19 @@ export class OmniRouteClient {
         let lineBuffer = '';
         // Partially-accumulated tool calls keyed by stream index.
         const toolStreams = new Map();
+        // OmniRoute's response headers are sent at stream start, before the
+        // latency, usage and cost are known, so on a stream they carry zeros. With
+        // OMNIROUTE_SSE_COMMENTS on, the gateway ends the stream with the same
+        // fields as `: x-omniroute-<name>=<value>` comment lines — the values that
+        // were final. They are collected here and read like a second header set.
+        const trailer = new Headers();
         const flushData = (line) => {
+            if (line.startsWith(':')) {
+                const meta = /^:\s*(x-omniroute-[a-z0-9-]+)=(.*)$/i.exec(line);
+                if (meta)
+                    trailer.set(meta[1].toLowerCase(), meta[2].trim());
+                return;
+            }
             const sep = line.indexOf(':');
             if (sep === -1)
                 return;
@@ -274,6 +287,10 @@ export class OmniRouteClient {
         const toolCalls = [...toolStreams.values()]
             .filter((entry) => entry.id !== '' && entry.name !== '')
             .map((entry) => ({ id: entry.id, type: 'function', function: { name: entry.name, arguments: entry.argsFragments.join('') } }));
+        // The trailer names the provider and model that finished the stream, so it
+        // supersedes the routing picture taken from the initial headers.
+        this.updateMetrics(trailer);
+        this.recordCompletion(response.headers, usage, trailer);
         return { content, model: answered, finishReason, reasoning: reasoning || undefined, toolCalls, usage, headers: response.headers, compression: this.compressionFrom(response.headers) };
     }
     async chat(model, messages, options = {}) {
@@ -294,6 +311,11 @@ export class OmniRouteClient {
         // (the combo may have routed anywhere); fall back to the requested id.
         const answered = typeof payload.model === 'string' && payload.model.trim() !== '' ? payload.model : model;
         const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls.map((call) => this.asToolCall(call)).filter((call) => call !== null) : undefined;
+        this.recordCompletion(response.headers, usage ? {
+            inputTokens: this.number(usage.prompt_tokens),
+            outputTokens: this.number(usage.completion_tokens),
+            totalTokens: this.number(usage.total_tokens),
+        } : undefined);
         return {
             content: typeof message.content === 'string' ? message.content : '',
             model: answered,
@@ -309,6 +331,50 @@ export class OmniRouteClient {
             compression: this.compressionFrom(response.headers),
         };
     }
+    /**
+     * OmniRoute's cost-telemetry set for one completion, or undefined when the
+     * headers carry no token counts. A stream's initial headers hold zeros for
+     * every field the gateway could not know yet, and zeros are treated as
+     * absent so they never overwrite a count read elsewhere.
+     */
+    usageFromHeaders(headers) {
+        const inputTokens = this.headerNumber(headers, 'x-omniroute-tokens-in') ?? 0;
+        const outputTokens = this.headerNumber(headers, 'x-omniroute-tokens-out') ?? 0;
+        if (inputTokens <= 0 && outputTokens <= 0)
+            return undefined;
+        const costUsd = this.headerNumber(headers, 'x-omniroute-response-cost');
+        const latencyMs = this.headerNumber(headers, 'x-omniroute-latency-ms');
+        return {
+            inputTokens: Math.max(0, inputTokens),
+            outputTokens: Math.max(0, outputTokens),
+            costUsd: costUsd !== undefined && costUsd > 0 ? costUsd : undefined,
+            latencyMs: latencyMs !== undefined && latencyMs > 0 ? latencyMs : undefined,
+        };
+    }
+    /**
+     * Fold one completion into the session's usage. Sources, most authoritative
+     * first: the SSE metadata trailer (final values of a stream), the response
+     * headers (final on a non-streaming reply, zeros on a stream), then the
+     * `usage` object in the body. Token counts come from one source only, so a
+     * reply that reports itself twice is still counted once.
+     */
+    recordCompletion(headers, body, trailer) {
+        const usage = this.metrics.usage;
+        const measured = (trailer && this.usageFromHeaders(trailer))
+            ?? this.usageFromHeaders(headers)
+            ?? (body && (body.inputTokens > 0 || body.outputTokens > 0) ? { inputTokens: body.inputTokens, outputTokens: body.outputTokens } : undefined);
+        if (!measured)
+            return;
+        if (measured.inputTokens > 0)
+            usage.contextTokens = measured.inputTokens;
+        usage.tokensIn += measured.inputTokens;
+        usage.tokensOut += measured.outputTokens;
+        if (measured.costUsd !== undefined)
+            usage.costUsd += measured.costUsd;
+        if (measured.latencyMs !== undefined)
+            usage.latencyMs = measured.latencyMs;
+        usage.updatedAt = new Date().toISOString();
+    }
     compressionFrom(headers) {
         const input = this.headerNumber(headers, 'x-omniroute-input-tokens');
         const compressed = this.headerNumber(headers, 'x-omniroute-compressed-tokens');

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,11 +979,14 @@ 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);
+    // The prompt tokens of the last completion, as the gateway counted them,
+    // are the size of the context the next turn will carry.
+    const contextTokens = metrics.usage?.contextTokens ?? 0;
+    const meter = contextMeter(contextTokens, engine.state.activeModel, metrics.fallback.activeProvider);
     const meterColor = meter.zone === 'danger' ? PALETTE.error : meter.zone === 'warn' ? PALETTE.warn : PALETTE.muted;
-    const contextLabel = metrics.compression.inputTokens > 0 ? `ctx ${meterBar(meter.fraction, 8)} ${Math.round(meter.fraction * 100)}%` : '';
+    const contextLabel = contextTokens > 0 ? `ctx ${meterBar(meter.fraction, 8)} ${Math.round(meter.fraction * 100)}%` : '';
     const compression = metrics.compression.inputTokens > 0 ? `${Math.round((1 - metrics.compression.ratio) * 100)}% ${metrics.compression.strategy.toUpperCase()}` : '';
     const phase = busy && currentTool ? phaseFor(currentTool) : (busy ? 'working' : 'ready');
     const elapsedMs = busy && runStartedAt.current !== null ? Math.max(0, now - runStartedAt.current) : 0;
@@ -980,18 +998,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) => {
+    const panel = _jsx(SidebarPanel, { width: SIDEBAR_WIDTH, model: engine.state.activeModel, mode: mode, perm: permMode, workspace: engine.state.workspace.root, usage: { tokensIn: metrics.usage?.tokensIn, tokensOut: metrics.usage?.tokensOut, costUSD: metrics.usage?.costUsd, 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: [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.84",
   "description": "OmniHarness — local-first agent orchestration harness for OmniRoute.",
   "license": "MIT",
   "type": "module",