omniharness-cli 0.1.77 → 0.1.79

package/dist/agent/mastraEngine.js

@@ -5,7 +5,8 @@ import { attachmentBlock, kindFromName } from '../attachments.js';
 import { OmniRouteClient } from '../config/omniRoute.js';
 import { saveActiveCombo } from '../config/settings.js';
 import { createSystemTools } from '../tools/systemTools.js';
-import { loadSkills, renderSkillCommand, skillSchema } from '../skills.js';
+import { loadSkills, renderSkillCommand, skillKind, skillSchema } from '../skills.js';
+import { loadPluginSkills, renderCommandBody } from '../plugins.js';
 import { chunkText, cosineSimilarity } from '../search.js';
 import { loadSemanticIndex, saveSemanticIndex } from '../semanticStore.js';
 import { loadSession, saveSession, clearSession } from '../sessionStore.js';
@@ -122,7 +123,14 @@ export async function createMastraEngine(config) {
     };
     const emit = (event) => { for (const listener of listeners)
         listener(event); };
-    const skills = await loadSkills(config.workspaceRoot);
+    // OMNIHARNESS.md skills first: a workspace's own definition wins a name
+    // collision with a plugin's.
+    const ownSkills = await loadSkills(config.workspaceRoot);
+    const taken = new Set(ownSkills.map((skill) => skill.name));
+    const skills = [
+        ...ownSkills,
+        ...(await loadPluginSkills(config.workspaceRoot)).filter((skill) => !taken.has(skill.name)),
+    ];
     const systemTools = {
         read_file: {
             name: 'read_file', description: tools.readFile.description, highRisk: false, parameters: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
@@ -228,9 +236,19 @@ export async function createMastraEngine(config) {
         }
     };
     for (const skill of skills) {
+        const prompt = skillKind(skill) === 'prompt';
         systemTools[skill.name] = {
-            name: skill.name, description: skill.description, highRisk: true, parameters: skillSchema(skill).parameters ?? { type: 'object', properties: {} },
+            name: skill.name,
+            description: skill.description,
+            // A prompt skill returns instructions. It runs nothing itself, so it
+            // does not need the shell and does not carry the shell's risk — the
+            // tools it then asks for are gated on their own terms.
+            highRisk: !prompt,
+            parameters: skillSchema(skill).parameters ?? { type: 'object', properties: {} },
             execute: async (input) => {
+                if (prompt) {
+                    return renderCommandBody(skill.prompt ?? '', String(input.arguments ?? ''));
+                }
                 if (!config.shellAllowed)
                     throw new Error('shell execution is disabled; custom skills need shell access');
                 const script = renderSkillCommand(skill.command, skill.parameters, input);

package/dist/plugins.js

@@ -0,0 +1,235 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * Split leading `---` delimited frontmatter from a markdown body.
+ *
+ * Deliberately a small key/value reader rather than a YAML parser: command
+ * frontmatter in practice is flat scalars, and a dependency that can evaluate
+ * arbitrary YAML is a poor thing to point at files the user downloaded. A file
+ * with no frontmatter is not an error — it is a prompt with no metadata.
+ */
+export function parseFrontmatter(text) {
+    const normalized = text.replace(/^/, '');
+    const match = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/.exec(normalized);
+    if (!match)
+        return { fields: {}, body: normalized.trim() };
+    const fields = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const kv = /^([A-Za-z0-9_-]+)[ \t]*:[ \t]*(.*)$/.exec(line);
+        if (!kv)
+            continue;
+        let value = kv[2].trim();
+        // Strip one layer of matching quotes, the only quoting seen in practice.
+        if ((value.startsWith('"') && value.endsWith('"') && value.length > 1)
+            || (value.startsWith("'") && value.endsWith("'") && value.length > 1)) {
+            value = value.slice(1, -1);
+        }
+        fields[kv[1].toLowerCase()] = value;
+    }
+    return { fields, body: normalized.slice(match[0].length).trim() };
+}
+function splitList(value) {
+    if (!value)
+        return [];
+    const inner = value.trim().replace(/^\[/, '').replace(/\]$/, '');
+    // Split on commas that are not inside the parentheses of Bash(gh pr view:*).
+    const out = [];
+    let depth = 0;
+    let current = '';
+    for (const ch of inner) {
+        if (ch === '(')
+            depth += 1;
+        if (ch === ')')
+            depth = Math.max(0, depth - 1);
+        if (ch === ',' && depth === 0) {
+            out.push(current);
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    out.push(current);
+    return out.map((entry) => entry.trim().replace(/^["']|["']$/g, '')).filter((entry) => entry !== '');
+}
+async function readJSON(file) {
+    try {
+        return JSON.parse(await fs.readFile(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function readCommands(root, pluginName, dir) {
+    const base = path.join(root, dir);
+    let entries;
+    try {
+        entries = await fs.readdir(base);
+    }
+    catch {
+        return [];
+    }
+    const commands = [];
+    for (const entry of entries.sort()) {
+        if (!entry.toLowerCase().endsWith('.md'))
+            continue;
+        const file = path.join(base, entry);
+        let raw;
+        try {
+            raw = await fs.readFile(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const { fields, body } = parseFrontmatter(raw);
+        if (body === '')
+            continue; // nothing to instruct with
+        commands.push({
+            name: entry.replace(/\.md$/i, ''),
+            description: fields.description ?? `${dir.replace(/s$/, '')} from ${pluginName}`,
+            body,
+            allowedTools: splitList(fields['allowed-tools']),
+            plugin: pluginName,
+            path: file,
+        });
+    }
+    return commands;
+}
+/** Read one plugin directory. Returns null if it is not a plugin. */
+export async function loadPlugin(root) {
+    const manifest = await readJSON(path.join(root, '.claude-plugin', 'plugin.json'));
+    if (!manifest || typeof manifest.name !== 'string' || manifest.name === '')
+        return null;
+    const name = manifest.name;
+    const author = manifest.author;
+    const commands = [
+        ...await readCommands(root, name, 'commands'),
+        ...await readCommands(root, name, 'agents'),
+    ];
+    return {
+        name,
+        description: typeof manifest.description === 'string' ? manifest.description : '',
+        version: typeof manifest.version === 'string' ? manifest.version : '0.0.0',
+        author: typeof author === 'string' ? author : (author?.name ?? ''),
+        root,
+        commands,
+    };
+}
+async function subdirectories(dir) {
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        return entries.filter((e) => e.isDirectory()).map((e) => path.join(dir, e.name)).sort();
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Read a directory as either a single plugin or a marketplace of them. A
+ * marketplace's `source` entries are relative to the marketplace root; a
+ * source pointing outside it is ignored rather than followed.
+ */
+export async function loadFrom(dir, depth = 2) {
+    const single = await loadPlugin(dir);
+    if (single)
+        return [single];
+    const market = await readJSON(path.join(dir, '.claude-plugin', 'marketplace.json'));
+    const out = [];
+    if (market && Array.isArray(market.plugins)) {
+        for (const entry of market.plugins) {
+            const source = typeof entry.source === 'string' ? entry.source : '';
+            if (source === '')
+                continue;
+            const resolved = path.resolve(dir, source);
+            const rel = path.relative(dir, resolved);
+            if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel))
+                continue;
+            const plugin = await loadPlugin(resolved);
+            if (plugin)
+                out.push(plugin);
+        }
+        return out;
+    }
+    // A directory of plugin directories — and a child may itself be a
+    // marketplace rather than a plugin, which is what cloning a plugin
+    // repository into the plugins directory gives you. Descending only one
+    // level found nothing in that very ordinary case. Bounded, so a plugins
+    // directory holding a deep source tree is not walked to the bottom.
+    if (depth <= 0)
+        return out;
+    for (const child of await subdirectories(dir)) {
+        out.push(...await loadFrom(child, depth - 1));
+    }
+    return out;
+}
+/**
+ * The directories searched for plugins, nearest first.
+ *
+ * OMNIHARNESS_PLUGIN_PATH replaces the list entirely, delimited like PATH.
+ * Setting it empty disables discovery. It exists because the default reaches
+ * into the user's home directory: without an override, what the agent can do
+ * depends on what happens to be installed on the machine, which makes a test
+ * or a CI run read differently from one box to the next.
+ */
+export function pluginSearchPath(workspaceRoot) {
+    const override = process.env.OMNIHARNESS_PLUGIN_PATH;
+    if (override !== undefined) {
+        return override.split(path.delimiter).map((entry) => entry.trim()).filter((entry) => entry !== '');
+    }
+    const home = os.homedir();
+    return [
+        path.join(workspaceRoot, '.claude', 'plugins'),
+        path.join(workspaceRoot, '.omniharness', 'plugins'),
+        ...(home ? [path.join(home, '.claude', 'plugins')] : []),
+    ];
+}
+/**
+ * Discover every plugin on the search path. A workspace plugin wins a name
+ * collision with a user-level one, because the nearer definition is the more
+ * specific.
+ */
+export async function discoverPlugins(workspaceRoot, roots = pluginSearchPath(workspaceRoot)) {
+    const seen = new Set();
+    const out = [];
+    for (const root of roots) {
+        for (const plugin of await loadFrom(root)) {
+            if (seen.has(plugin.name))
+                continue;
+            seen.add(plugin.name);
+            out.push(plugin);
+        }
+    }
+    return out;
+}
+/** Substitute the argument tokens a command body may use. */
+export function renderCommandBody(body, args) {
+    const words = args.trim() === '' ? [] : args.trim().split(/\s+/);
+    let out = body.split('$ARGUMENTS').join(args.trim());
+    // $1..$9 take one word each, matching the shell convention the format borrows.
+    out = out.replace(/\$([1-9])/g, (_, digit) => words[Number(digit) - 1] ?? '');
+    return out;
+}
+const ARGUMENTS_PARAM = [{ name: 'arguments', type: 'string' }];
+/**
+ * Present a plugin command as a Skill so the rest of the engine does not have
+ * to know where it came from. Names are prefixed with the plugin so two
+ * plugins can both ship a "review" command.
+ */
+export function commandToSkill(command) {
+    return {
+        name: `${command.plugin}:${command.name}`.replace(/[^A-Za-z0-9_:.-]/g, '-'),
+        description: command.description,
+        command: '',
+        parameters: ARGUMENTS_PARAM,
+        kind: 'prompt',
+        prompt: command.body,
+        source: command.plugin,
+        allowedTools: command.allowedTools,
+    };
+}
+/** Every command from every discovered plugin, as Skills. */
+export async function loadPluginSkills(workspaceRoot) {
+    const plugins = await discoverPlugins(workspaceRoot);
+    return plugins.flatMap((plugin) => plugin.commands.map(commandToSkill));
+}
+//# sourceMappingURL=plugins.js.map

package/dist/skills.js

@@ -1,5 +1,9 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
+/** Whether a skill runs a command or supplies instructions. */
+export function skillKind(skill) {
+    return skill.kind ?? 'shell';
+}
 /**
  * Parse an OMNIHARNESS.md skills definition. Blocks start with `## <name>`
  * and contain `description:`, `command:`, and `param: <name> <type>` fields.

package/dist/ui/home.js

@@ -0,0 +1,83 @@
+/**
+ * Data shaping for the home screen — the layout itself lives in the Ink
+ * component, but everything it has to decide is pure and lives here so it can
+ * be tested without rendering a terminal.
+ */
+/**
+ * Render an age the way someone reads it at a glance: the largest unit that
+ * still says something useful, never more than one unit deep.
+ *
+ * Anything not yet a minute old is "now" rather than "0m ago", because a
+ * session saved seconds ago reading as zero looks like a bug.
+ */
+export function relativeTime(savedAt, now = Date.now()) {
+    const then = Date.parse(savedAt);
+    if (!Number.isFinite(then))
+        return '';
+    const seconds = Math.max(0, Math.round((now - then) / 1000));
+    if (seconds < 60)
+        return 'now';
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 7)
+        return `${days}d ago`;
+    const weeks = Math.floor(days / 7);
+    if (weeks < 52)
+        return `${weeks}w ago`;
+    return `${Math.floor(days / 365)}y ago`;
+}
+/**
+ * The recent-session rows to show, newest first and capped. Names are clipped
+ * rather than wrapped: a single line per session keeps the block a predictable
+ * height, which matters because the home screen shares the window with the
+ * input.
+ */
+export function recentRows(sessions, limit, nameWidth, now = Date.now()) {
+    return sessions.slice(0, Math.max(0, limit)).map((session) => ({
+        name: clipName(session.name, nameWidth),
+        age: relativeTime(session.savedAt, now),
+    }));
+}
+function clipName(name, width) {
+    const runes = [...name];
+    if (width <= 1 || runes.length <= width)
+        return name;
+    return `${runes.slice(0, width - 1).join('')}…`;
+}
+/**
+ * Whether there is room for the two-column home. Below this the columns would
+ * be too narrow to hold a session name or a path, so the blocks stack instead.
+ */
+export const TWO_COLUMN_MIN_WIDTH = 76;
+export function twoColumn(width) {
+    return width >= TWO_COLUMN_MIN_WIDTH;
+}
+/**
+ * Shorten a workspace path from the left, keeping the end. The tail is the
+ * part that identifies the project; the head is usually /Users/someone.
+ */
+export function shortenPath(p, width) {
+    if (p.length <= width)
+        return p;
+    if (width <= 1)
+        return p.slice(-width);
+    return `…${p.slice(-(width - 1))}`;
+}
+/**
+ * A one-line summary of what the agent can reach beyond its built-in tools.
+ * Says nothing at all when there is nothing to say, rather than "0 skills".
+ */
+export function capabilityLine(skills, plugins, mcpTools) {
+    const parts = [];
+    if (skills > 0)
+        parts.push(`${skills} skill${skills === 1 ? '' : 's'}${plugins > 0 ? ` from ${plugins} plugin${plugins === 1 ? '' : 's'}` : ''}`);
+    if (mcpTools > 0)
+        parts.push(`${mcpTools} mcp tool${mcpTools === 1 ? '' : 's'}`);
+    return parts.join(' · ');
+}
+//# sourceMappingURL=home.js.map

package/dist/ui/terminalInterface.js

@@ -8,6 +8,7 @@ import { deleteAt, deleteBefore, insertAt, layoutEditor, lineEndAt, lineStartAt,
 import { renderMarkdown } from './markdown.js';
 import { looksLikeDiff, diffSegments } from './diff.js';
 import { palette } from './palette.js';
+import { capabilityLine, recentRows, shortenPath, twoColumn } from './home.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';
@@ -173,9 +174,39 @@ function TranscriptEntry({ line, width, fallbackModel }) {
     const bullet = line.role === 'user' ? '>' : line.role === 'error' ? '!' : '-';
     return _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { bold: true, color: colorFor(line.role), children: [bullet, " ", label] }), rows.map((segments, index) => _jsx(SegmentText, { segments: segments, role: line.role }, index)), line.saved ? _jsxs(Text, { dimColor: true, children: ["  ", line.saved] }) : null] });
 }
-/** Shown until the first prompt: what the harness is pointed at, and how to drive it. */
-function Hero({ width, endpoint, model, mode, perm }) {
-    return _jsxs(Box, { flexDirection: "column", marginBottom: 1, width: Math.min(width, 76), children: [_jsxs(Text, { bold: true, color: PALETTE.accent, children: ["omniharness ", ownVersion()] }), _jsx(Text, { dimColor: true, children: "the OmniRoute-native agent harness" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "gateway  " }), endpoint] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "model    " }), model] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "mode     " }), _jsx(Text, { color: MODE_ACCENT[mode], children: mode }), _jsx(Text, { dimColor: true, children: "  \u00B7  Ctrl+E cycles plan \u00B7 build \u00B7 research \u00B7 crazy" })] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "perms    " }), _jsx(Text, { color: mode === 'crazy' ? PALETTE.error : PERM_COLOR(perm), children: mode === 'crazy' ? 'bypass' : PERM_LABEL[perm] }), _jsx(Text, { dimColor: true, children: "  \u00B7  Shift+Tab cycles manual \u00B7 accept edits \u00B7 bypass" })] })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "describe the work and press enter \u00B7 /help for commands" }) })] });
+/**
+ * Width of the dim label column on the home screen. The value gets whatever is
+ * left, and every caller has to subtract this: a value sized to the whole box
+ * wraps onto a second line and the block stops being a fixed height.
+ */
+const LABEL_WIDTH = 10;
+/** One labelled line: a dim fixed-width label, then the value. */
+function Field({ label, children }) {
+    return _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: label.padEnd(LABEL_WIDTH) }), children] });
+}
+/**
+ * The home screen, shown while the transcript is empty.
+ *
+ * Two columns when the terminal is wide enough — what this session is on the
+ * left, what you can pick up and what you can press on the right — stacking
+ * below that rather than squeezing. Everything on it is read from the running
+ * session: there is no placeholder copy and no invented "what's new" feed,
+ * because a home screen that shows things which are not true is worse than a
+ * plain one.
+ */
+export function Hero(props) {
+    const { width, endpoint, model, mode, perm, workspace, sessions, skills, plugins, mcpTools } = props;
+    const wide = twoColumn(width);
+    const outer = Math.min(width - 2, 84);
+    const column = wide ? Math.floor((outer - 3) / 2) : outer;
+    const inner = Math.max(12, column - 4);
+    // Values sit to the right of the label, so that is the room they actually get.
+    const value = Math.max(8, inner - LABEL_WIDTH);
+    const capability = capabilityLine(skills, plugins, mcpTools);
+    const recent = recentRows(sessions, 4, Math.max(8, inner - 9));
+    const session = _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: PALETTE.accent, paddingX: 1, width: column, children: [_jsxs(Text, { bold: true, color: PALETTE.accent, children: ["omniharness ", ownVersion()] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Field, { label: "workspace", children: shortenPath(workspace, value) }), _jsx(Field, { label: "gateway", children: shortenPath(endpoint, value) }), _jsx(Field, { label: "model", children: clip(model, value) }), _jsx(Field, { label: "mode", children: _jsx(Text, { color: MODE_ACCENT[mode], children: mode }) }), _jsx(Field, { label: "perms", children: _jsx(Text, { color: mode === 'crazy' ? PALETTE.error : PERM_COLOR(perm), children: mode === 'crazy' ? 'bypass' : PERM_LABEL[perm] }) }), capability !== '' && _jsx(Field, { label: "loaded", children: clip(capability, value) })] })] });
+    const aside = _jsxs(Box, { flexDirection: "column", width: column, marginLeft: wide ? 1 : 0, marginTop: wide ? 0 : 1, children: [recent.length > 0 && _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: PALETTE.muted, paddingX: 1, marginBottom: 1, children: [_jsx(Text, { bold: true, dimColor: true, children: "recent" }), recent.map((row) => _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: row.age.padEnd(8) }), row.name] }, row.name)), _jsx(Text, { dimColor: true, children: "/sessions for all" })] }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: PALETTE.muted, paddingX: 1, children: [_jsx(Text, { bold: true, dimColor: true, children: "keys" }), _jsxs(Text, { children: [_jsx(Text, { color: PALETTE.accent, children: 'Ctrl+E'.padEnd(LABEL_WIDTH) }), _jsx(Text, { dimColor: true, children: "cycle mode" })] }), _jsxs(Text, { children: [_jsx(Text, { color: PALETTE.accent, children: 'Shift+Tab'.padEnd(LABEL_WIDTH) }), _jsx(Text, { dimColor: true, children: "cycle perms" })] }), _jsxs(Text, { children: [_jsx(Text, { color: PALETTE.accent, children: 'Ctrl+O'.padEnd(LABEL_WIDTH) }), _jsx(Text, { dimColor: true, children: "pick a model" })] }), _jsx(Text, { dimColor: true, children: "/help for the rest" })] })] });
+    return _jsxs(Box, { flexDirection: "column", marginBottom: 1, width: outer, children: [_jsxs(Box, { flexDirection: wide ? 'row' : 'column', alignItems: "flex-start", children: [session, aside] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "describe the work and press enter" }) })] });
 }
 export function TerminalInterface({ engine }) {
     const { exit } = useApp();
@@ -216,6 +247,9 @@ export function TerminalInterface({ engine }) {
     const [now, setNow] = useState(() => Date.now());
     const queuedRef = useRef(null);
     const [queued, setQueued] = useState();
+    // Recent snapshots for the home screen. Read once on mount and left
+    // alone: the home screen is only on screen before the first turn.
+    const [recentSessions, setRecentSessions] = useState([]);
     const [layoutDebug, setLayoutDebug] = useState(false);
     const syncRestoreRef = useRef(null);
     const pushLine = (line) => setLines((current) => [...current, line]);
@@ -226,6 +260,10 @@ export function TerminalInterface({ engine }) {
             if (alive && promptHistoryRef.current.length === 0)
                 syncPromptHistory(history);
         }).catch(() => { });
+        void listSessions(engine.state.workspace.root).then((found) => {
+            if (alive)
+                setRecentSessions(found);
+        }).catch(() => { });
         return () => { alive = false; };
     }, []);
     useEffect(() => {
@@ -895,7 +933,7 @@ export function TerminalInterface({ engine }) {
     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;
-    return _jsxs(Box, { flexDirection: "column", width: width, paddingX: 2, children: [_jsx(Static, { items: lines, children: (line, index) => _jsx(TranscriptEntry, { line: line, width: contentWidth, fallbackModel: engine.state.activeModel }, index) }, staticKey), _jsxs(Box, { flexDirection: "column", children: [lines.length === 0 && !busy && _jsx(Hero, { width: width, endpoint: engine.client.endpoint ?? 'omniroute', model: engine.state.activeModel, mode: mode, perm: permMode }), 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, paddingX: 2, children: [_jsx(Static, { items: lines, children: (line, index) => _jsx(TranscriptEntry, { line: line, width: contentWidth, fallbackModel: engine.state.activeModel }, index) }, staticKey), _jsxs(Box, { flexDirection: "column", children: [lines.length === 0 && !busy && _jsx(Hero, { width: width, 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 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'

package/package.json

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