@ruvnet/open-claude-code 2.0.1 → 2.1.1

package/src/ui/commands.mjs

@@ -1,22 +1,30 @@
-/** Slash Commands — all 39+ commands. Fully functional (no stubs). */
-import fs from 'fs';
-import path from 'path';
-import { execSync } from 'child_process';
+/**
+ * Slash Commands — all 39 commands from Claude Code.
+ *
+ * Each command is a function(args, state) that returns a string response.
+ * Commands are invoked via /command-name in the REPL.
+ */
+
 import { SessionManager } from '../core/session.mjs';
 import { CheckpointManager } from '../core/checkpoints.mjs';
 import { PromptCache } from '../core/cache.mjs';
 import { readEnv, listEnvVars } from '../config/env.mjs';
-import { cronStore as _cronStore } from '../tools/cron-create.mjs';
+import { readApiKey } from '../core/providers.mjs';
 import * as telemetry from '../telemetry/index.mjs';
+import { OutcomeStore } from '../optimize/store.mjs';
 
 const checkpoints = new CheckpointManager();
 const promptCache = new PromptCache();
 let sessionManager = null;
+
 function getSession() {
     if (!sessionManager) sessionManager = new SessionManager();
     return sessionManager;
 }
 
+/**
+ * All slash commands.
+ */
 export const COMMANDS = {
     '/help': {
         description: 'Show available commands',
@@ -25,6 +33,7 @@ export const COMMANDS = {
             for (const [name, cmd] of Object.entries(COMMANDS)) {
                 lines.push(`  ${name.padEnd(20)} ${cmd.description}`);
             }
+            lines.push('');
             return lines.join('\n');
         },
     },
@@ -67,13 +76,11 @@ export const COMMANDS = {
         description: 'Show token usage and estimated cost',
         handler(args, state) {
             const { input, output } = state.tokenUsage;
+            // Use model-appropriate pricing
             const model = state.model || '';
             let priceIn = 3, priceOut = 15; // Sonnet default
             if (model.includes('haiku')) { priceIn = 0.25; priceOut = 1.25; }
             if (model.includes('opus')) { priceIn = 15; priceOut = 75; }
-            if (model.includes('gpt-4o-mini')) { priceIn = 0.15; priceOut = 0.6; }
-            else if (model.includes('gpt-4o')) { priceIn = 2.5; priceOut = 10; }
-            if (model.includes('gemini')) { priceIn = 0.075; priceOut = 0.3; }
 
             const costIn = (input / 1_000_000) * priceIn;
             const costOut = (output / 1_000_000) * priceOut;
@@ -91,30 +98,25 @@ export const COMMANDS = {
         description: 'Check system health and configuration',
         handler(args, state) {
             const checks = [];
+            const anthropicKey = readApiKey('ANTHROPIC_API_KEY');
             checks.push(`Node.js: ${process.version}`);
-            checks.push(`ANTHROPIC_API_KEY: ${process.env.ANTHROPIC_API_KEY ? 'set' : 'NOT SET'}`);
-            checks.push(`OPENAI_API_KEY: ${process.env.OPENAI_API_KEY ? 'set' : 'NOT SET'}`);
-            checks.push(`GOOGLE_API_KEY: ${process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY ? 'set' : 'NOT SET'}`);
+            checks.push(`ANTHROPIC_API_KEY: ${anthropicKey ? 'set' : 'NOT SET'}`);
             checks.push(`Model: ${state.model || 'default'}`);
             checks.push(`Tools: ${state.tools?.list?.()?.length || 0}`);
             checks.push(`Messages: ${state.messages.length}`);
             checks.push(`CWD: ${process.cwd()}`);
             checks.push(`Platform: ${process.platform}`);
 
-            // API connectivity check (synchronous status)
-            let apiStatus = 'no key';
-            if (process.env.ANTHROPIC_API_KEY) apiStatus = 'key present';
-            if (process.env.OPENAI_API_KEY) checks.push(`OpenAI API: key present`);
-            if (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY) checks.push(`Google API: key present`);
+            // Check API connectivity
+            let apiStatus = 'unchecked';
+            if (anthropicKey) {
+                apiStatus = 'key present';
+            }
             checks.push(`API: ${apiStatus}`);
 
             // Check MCP servers
-            const mcpClients = state._mcpClients || [];
-            checks.push(`MCP servers: ${mcpClients.length}`);
-            for (const client of mcpClients) {
-                const status = client.connected ? 'connected' : 'disconnected';
-                checks.push(`  - ${client.config?.command || 'unknown'}: ${status}`);
-            }
+            const mcpCount = state._mcpClients?.length || 0;
+            checks.push(`MCP servers: ${mcpCount}`);
 
             return `System check:\n${checks.map(c => `  ${c}`).join('\n')}`;
         },
@@ -136,9 +138,8 @@ export const COMMANDS = {
         description: 'Show or switch model',
         handler(args, state) {
             if (args) {
-                const old = state.model;
                 state.model = args;
-                return `Model switched: ${old} -> ${args}`;
+                return `Model switched to: ${args}`;
             }
             return `Current model: ${state.model || 'default'}`;
         },
@@ -168,14 +169,28 @@ export const COMMANDS = {
         },
     },
 
-    '/quit': { description: 'Exit the REPL', handler() { return 'EXIT'; } },
-    '/exit': { description: 'Exit the REPL', handler() { return 'EXIT'; } },
-    '/bug': { description: 'Report a bug', handler() { return 'Report bugs at: https://github.com/ruvnet/open-claude-code/issues'; } },
+    '/quit': {
+        description: 'Exit the REPL',
+        handler() { return 'EXIT'; },
+    },
+
+    '/exit': {
+        description: 'Exit the REPL',
+        handler() { return 'EXIT'; },
+    },
+
+    '/bug': {
+        description: 'Report a bug',
+        handler() {
+            return 'Report bugs at: https://github.com/ruvnet/open-claude-code/issues';
+        },
+    },
 
     '/review': {
         description: 'Review recent changes',
         handler(args, state) {
             try {
+                const { execSync } = require('child_process');
                 const diff = execSync('git diff --stat HEAD~1 2>/dev/null || echo "No git history"', { encoding: 'utf-8' });
                 return `Recent changes:\n${diff}`;
             } catch {
@@ -187,6 +202,8 @@ export const COMMANDS = {
     '/init': {
         description: 'Initialize Claude Code in current directory',
         handler() {
+            const fs = require('fs');
+            const path = require('path');
             const claudeDir = path.join(process.cwd(), '.claude');
             fs.mkdirSync(claudeDir, { recursive: true });
             const settingsFile = path.join(claudeDir, 'settings.json');
@@ -197,11 +214,25 @@ export const COMMANDS = {
         },
     },
 
-    '/login': { description: 'Set API key', handler(args) {
-        if (args) { process.env.ANTHROPIC_API_KEY = args; return 'API key set.'; }
-        return 'Usage: /login <api-key>';
-    }},
-    '/logout': { description: 'Clear API key', handler() { delete process.env.ANTHROPIC_API_KEY; return 'API key cleared.'; } },
+    '/login': {
+        description: 'Set API key',
+        handler(args) {
+            const key = (args || '').trim();
+            if (key) {
+                process.env.ANTHROPIC_API_KEY = key;
+                return 'API key set.';
+            }
+            return 'Usage: /login <api-key>';
+        },
+    },
+
+    '/logout': {
+        description: 'Clear API key',
+        handler() {
+            delete process.env.ANTHROPIC_API_KEY;
+            return 'API key cleared.';
+        },
+    },
 
     '/status': {
         description: 'Show session status',
@@ -359,9 +390,10 @@ export const COMMANDS = {
     '/schedule': {
         description: 'List scheduled tasks',
         handler() {
-            if (!_cronStore || _cronStore.size === 0) return 'No scheduled tasks.';
+            const { cronStore } = require('../tools/cron-create.mjs');
+            if (!cronStore || cronStore.size === 0) return 'No scheduled tasks.';
             const lines = [];
-            for (const [, job] of _cronStore) {
+            for (const [, job] of cronStore) {
                 lines.push(`  ${job.id}: ${job.name} (${job.schedule})`);
             }
             return `Scheduled:\n${lines.join('\n')}`;
@@ -395,9 +427,8 @@ export const COMMANDS = {
         description: 'Show git diff',
         handler() {
             try {
-                // execSync imported at top
-                const d = execSync('git diff --stat 2>/dev/null || echo "Not in a git repo"', { encoding: 'utf-8' });
-                return d.trim() || 'No changes.';
+                const { execSync } = require('child_process');
+                return execSync('git diff --stat 2>/dev/null || echo "Not in a git repo"', { encoding: 'utf-8' });
             } catch {
                 return 'Unable to show diff.';
             }
@@ -416,10 +447,13 @@ export const COMMANDS = {
         description: 'Create a git commit with AI message',
         handler(args) {
             try {
-                // execSync imported at top
+                // Security: use execFileSync with discrete args so the commit
+                // message is never shell-interpolated (prevents injection via
+                // crafted message strings containing shell metacharacters).
+                const { execFileSync } = require('child_process');
                 const msg = args || 'Update from open-claude-code';
-                execSync('git add -A', { encoding: 'utf-8' });
-                execSync(`git commit -m "${msg}"`, { encoding: 'utf-8' });
+                execFileSync('git', ['add', '-A'], { encoding: 'utf-8' });
+                execFileSync('git', ['commit', '-m', msg], { encoding: 'utf-8' });
                 return `Committed: ${msg}`;
             } catch (err) {
                 return `Commit failed: ${err.message}`;
@@ -427,45 +461,57 @@ export const COMMANDS = {
         },
     },
 
-    '/pr': { description: 'Create a pull request', handler() { return 'PR creation requires gh CLI. Run: gh pr create --fill'; } },
-    '/release': { description: 'Create a release', handler() { return 'Release creation requires gh CLI. Run: gh release create <tag>'; } },
+    '/pr': {
+        description: 'Create a pull request (stub)',
+        handler() {
+            return 'PR creation requires gh CLI. Run: gh pr create --fill';
+        },
+    },
 
-    '/resume': {
-        description: 'Resume a saved session',
-        handler(args, state) {
-            const session = getSession();
-            if (args) {
-                // Resume specific session by ID
-                const ok = session.resume(state, args.trim());
-                if (ok) {
-                    return `Resumed session: ${session.sessionId} (${state.messages.length} messages, ${state.turnCount} turns)`;
-                }
-                return `Could not find session: ${args.trim()}`;
-            }
-            // Resume most recent
-            const ok = session.resume(state);
-            if (ok) {
-                return `Resumed session: ${session.sessionId} (${state.messages.length} messages, ${state.turnCount} turns)`;
-            }
-            return 'No resumable session found.';
+    '/release': {
+        description: 'Create a release (stub)',
+        handler() {
+            return 'Release creation requires gh CLI. Run: gh release create <tag>';
         },
     },
 
-    '/sessions': {
-        description: 'List recent sessions',
+    '/optimize': {
+        description: 'Self-optimization router status / report (metaharness)',
         handler(args, state) {
-            const session = getSession();
-            const list = session.listSessions(10);
-            if (list.length === 0) return 'No saved sessions.';
-            const lines = list.map(s =>
-                `  ${s.id} | ${s.savedAt || '?'} | ${s.turnCount || 0} turns | ${s.messageCount || 0} msgs`
-            );
-            return `Recent sessions:\n${lines.join('\n')}`;
+            const sub = (args || '').trim().split(/\s+/)[0] || 'status';
+            const store = new OutcomeStore();
+            if (sub === 'report') {
+                const summary = store.summary();
+                if (summary.total === 0) return 'No recorded outcomes yet. Start occ with --self-optimize to collect real data.';
+                const lines = [`Optimization report — ${summary.total} outcomes`];
+                for (const [m, b] of Object.entries(summary.byModel)) {
+                    lines.push(`  ${m}: ${b.attempts} runs, ${(b.successRate * 100).toFixed(0)}% ok, ~$${b.costUsd.toFixed(4)}`);
+                }
+                lines.push(`  total est cost: $${summary.totalCostUsd.toFixed(4)}`);
+                return lines.join('\n');
+            }
+            if (sub === 'reset') {
+                return store.reset() ? 'Outcome store cleared.' : 'Nothing to reset.';
+            }
+            // status (default)
+            const enabled = !!(state && state._cascade);
+            const summary = store.summary();
+            return [
+                'MetaHarness self-optimization',
+                `  live router this session: ${enabled ? 'ON' : 'OFF (start with --self-optimize)'}`,
+                `  recorded outcomes:        ${summary.total}`,
+                `  store:                    ${store.filePath}`,
+            ].join('\n');
         },
     },
 };
 
-/** Execute a slash command. */
+/**
+ * Execute a slash command.
+ * @param {string} input - full command string (e.g., "/model claude-sonnet-4-6")
+ * @param {object} state - agent loop state
+ * @returns {{ response: string, exit: boolean }}
+ */
 export function executeCommand(input, state) {
     const parts = input.split(/\s+/);
     const cmd = parts[0].toLowerCase();
@@ -480,7 +526,11 @@ export function executeCommand(input, state) {
     return { response, exit: response === 'EXIT' };
 }
 
-/** Get command completions for tab-complete. */
+/**
+ * Get command completions for tab-complete.
+ * @param {string} partial
+ * @returns {string[]}
+ */
 export function getCompletions(partial) {
     return Object.keys(COMMANDS).filter(c => c.startsWith(partial));
 }

package/src/ui/components.mjs

@@ -0,0 +1,219 @@
+/**
+ * Ink UI Components — React components for the terminal interface.
+ *
+ * Uses React.createElement (no JSX transpiler needed).
+ *
+ * Components:
+ * - StatusBar: persistent bottom bar (model, context%, cost, time, mode)
+ * - Message: renders different message types
+ * - AssistantMessage: markdown-formatted assistant output
+ * - UserMessage: user input display
+ * - ToolMessage: tool execution with spinner
+ * - ThinkingMessage: dim italic thinking blocks
+ * - CodeBlock: bordered code display
+ * - PermissionPrompt: interactive y/n/a prompt
+ * - LoadingIndicator: spinner during API calls
+ * - WelcomeBanner: startup banner
+ */
+
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { renderMarkdown } from './markdown.mjs';
+
+const h = React.createElement;
+
+/**
+ * Format duration in seconds to human-readable string.
+ */
+function formatDuration(seconds) {
+    if (seconds < 60) return `${Math.floor(seconds)}s`;
+    const mins = Math.floor(seconds / 60);
+    const secs = Math.floor(seconds % 60);
+    return `${mins}m${secs}s`;
+}
+
+/**
+ * Truncate text to a maximum length.
+ */
+function truncate(text, max) {
+    if (!text) return '';
+    if (text.length <= max) return text;
+    return text.slice(0, max) + '...';
+}
+
+/**
+ * Format cost to display string.
+ */
+function formatCost(cost) {
+    if (cost < 0.01) return `$${cost.toFixed(4)}`;
+    return `$${cost.toFixed(2)}`;
+}
+
+// ---- Status Bar ----
+
+export function StatusBar({ model, tokens, cost, mode, startTime, contextMax }) {
+    const [elapsed, setElapsed] = useState(0);
+
+    useEffect(() => {
+        const interval = setInterval(() => {
+            setElapsed(Math.floor((Date.now() - (startTime || Date.now())) / 1000));
+        }, 1000);
+        return () => clearInterval(interval);
+    }, [startTime]);
+
+    const totalTokens = (tokens?.input || 0) + (tokens?.output || 0);
+    const maxCtx = contextMax || 200000;
+    const contextPct = Math.min(100, Math.round((totalTokens / maxCtx) * 100));
+    const ctxColor = contextPct > 80 ? 'red' : contextPct > 50 ? 'yellow' : 'green';
+
+    return h(Box, null,
+        h(Text, { color: 'cyan', bold: true }, '\u258A '),
+        h(Text, { color: 'white' }, 'open-claude-code'),
+        h(Text, { color: 'gray' }, ' \u2502 '),
+        h(Text, { color: 'green' }, model || 'default'),
+        h(Text, { color: 'gray' }, ' \u2502 '),
+        h(Text, { color: 'yellow' }, '\u23F1 ', formatDuration(elapsed)),
+        h(Text, { color: 'gray' }, ' \u2502 '),
+        h(Text, { color: ctxColor }, '\u25CF ', contextPct, '% ctx'),
+        h(Text, { color: 'gray' }, ' \u2502 '),
+        h(Text, { color: 'white' }, formatCost(cost || 0)),
+        h(Text, { color: 'gray' }, ' \u2502 '),
+        h(Text, { color: 'magenta' }, mode || 'default'),
+    );
+}
+
+// ---- Message Components ----
+
+export function Message({ role, content, toolName, toolResult, toolStatus, thinking }) {
+    if (role === 'assistant') return h(AssistantMessage, { content });
+    if (role === 'tool') return h(ToolMessage, { name: toolName, result: toolResult, status: toolStatus });
+    if (role === 'thinking') return h(ThinkingMessage, { content: thinking });
+    if (role === 'user') return h(UserMessage, { content });
+    if (role === 'error') return h(ErrorMessage, { content });
+    if (role === 'system') return h(SystemMessage, { content });
+    return null;
+}
+
+export function AssistantMessage({ content }) {
+    if (!content) return null;
+    const rendered = renderMarkdown(content);
+    return h(Box, { marginLeft: 0, marginBottom: 0 },
+        h(Text, null, rendered),
+    );
+}
+
+export function UserMessage({ content }) {
+    if (!content) return null;
+    return h(Box, { marginBottom: 0 },
+        h(Text, { color: 'blue', bold: true }, 'You: '),
+        h(Text, null, content),
+    );
+}
+
+export function ToolMessage({ name, result, status }) {
+    const children = [
+        h(Text, { color: 'yellow', key: 'label' }, '[', name, '] '),
+    ];
+
+    if (status === 'running') {
+        children.push(
+            h(Text, { color: 'cyan', key: 'spinner' },
+                h(Spinner, { type: 'dots' }),
+                ' running...',
+            ),
+        );
+    }
+    if (status === 'done' && result) {
+        children.push(
+            h(Text, { color: 'gray', key: 'result' }, ' ', truncate(String(result), 200)),
+        );
+    }
+    if (status === 'error' && result) {
+        children.push(
+            h(Text, { color: 'red', key: 'error' }, ' ', truncate(String(result), 200)),
+        );
+    }
+
+    return h(Box, null, ...children);
+}
+
+export function ThinkingMessage({ content }) {
+    if (!content) return null;
+    return h(Box, null,
+        h(Text, { dimColor: true, italic: true }, '\uD83D\uDCAD ', truncate(content, 500)),
+    );
+}
+
+export function ErrorMessage({ content }) {
+    return h(Box, null,
+        h(Text, { color: 'red', bold: true }, 'Error: '),
+        h(Text, { color: 'red' }, content),
+    );
+}
+
+export function SystemMessage({ content }) {
+    return h(Box, null,
+        h(Text, { dimColor: true }, content),
+    );
+}
+
+// ---- Code Block ----
+
+export function CodeBlock({ code, language }) {
+    if (!code) return null;
+    const children = [];
+    if (language) {
+        children.push(h(Text, { dimColor: true, key: 'lang' }, language));
+    }
+    children.push(h(Text, { key: 'code' }, code));
+
+    return h(Box, {
+        borderStyle: 'single',
+        borderColor: 'gray',
+        paddingX: 1,
+        marginLeft: 2,
+    }, ...children);
+}
+
+// ---- Permission Prompt ----
+
+export function PermissionPrompt({ toolName, command }) {
+    const children = [
+        h(Text, { color: 'yellow', key: 'allow' }, 'Allow '),
+        h(Text, { bold: true, key: 'tool' }, toolName),
+    ];
+    if (command) {
+        children.push(
+            h(Text, { color: 'gray', key: 'cmd' }, ': ', truncate(command, 60)),
+        );
+    }
+    children.push(h(Text, { key: 'prompt' }, ' [y/n/a] '));
+
+    return h(Box, {
+        borderStyle: 'round',
+        borderColor: 'yellow',
+        paddingX: 1,
+    }, ...children);
+}
+
+// ---- Loading Indicator ----
+
+export function LoadingIndicator({ tool }) {
+    return h(Box, null,
+        h(Text, { color: 'cyan' },
+            h(Spinner, { type: 'dots' }),
+        ),
+        h(Text, { dimColor: true }, ' ', tool ? `Running ${tool}...` : 'Thinking...'),
+    );
+}
+
+// ---- Welcome Banner ----
+
+export function WelcomeBanner({ model, toolCount }) {
+    return h(Box, { flexDirection: 'column', marginBottom: 1 },
+        h(Text, { bold: true }, 'open-claude-code v2'),
+        h(Text, { dimColor: true }, 'Model: ', model || 'default', ' | Tools: ', toolCount || 0),
+        h(Text, { dimColor: true }, 'Type your prompt or /help. Press Ctrl+C to exit.'),
+    );
+}

package/src/ui/ink-app.mjs

@@ -8,7 +8,6 @@
  * - Markdown bold, italic, inline code rendering
  * - Status line showing model, tokens used, cost estimate
  * - Progress for tool execution (show tool name + "running...")
- * - Cost display after each turn: (tokens: X in / Y out | $Z)
  */
 
 // ANSI color codes
@@ -30,7 +29,6 @@ const COLORS = {
     bgGreen: '\x1b[42m',
     bgYellow: '\x1b[43m',
     bgBlue: '\x1b[44m',
-    bgGray: '\x1b[48;5;236m',
 };
 
 const noColor = process.env.NO_COLOR === '1';
@@ -80,7 +78,6 @@ export class Spinner {
 
 /**
  * Highlight code blocks in markdown text.
- * Detects ``` blocks and adds subtle background/syntax coloring.
  * @param {string} text
  * @returns {string}
  */
@@ -91,7 +88,7 @@ export function highlightCode(text) {
         const header = lang ? c('dim', `  ${lang}`) : '';
         const highlighted = code
             .split('\n')
-            .map(line => `${COLORS.bgGray}  ${highlightLine(line, lang)}  ${COLORS.reset}`)
+            .map(line => `  ${highlightLine(line, lang)}`)
             .join('\n');
         return `${c('dim', '```')}${header}\n${highlighted}\n${c('dim', '```')}`;
     });
@@ -141,18 +138,16 @@ export function renderMarkdown(text) {
 
 /**
  * Render a tool progress indicator.
- * Shows [ToolName] running... in yellow.
  * @param {string} toolName
  * @param {string} status
  */
 export function renderToolProgress(toolName, status) {
     const icon = status === 'running' ? c('yellow', '>>') : c('green', '>>');
-    return `${icon} ${c('yellow', `[${toolName}]`)} ${c('dim', status)}`;
+    return `${icon} ${c('yellow', toolName)} ${c('dim', status)}`;
 }
 
 /**
  * Render a status bar with token counts and cost estimate.
- * Shown after each turn: (tokens: X in / Y out | $Z)
  * @param {object} state
  */
 export function renderStatusBar(state) {
@@ -161,59 +156,25 @@ export function renderStatusBar(state) {
     const model = state.model || 'default';
     const inp = state.tokenUsage?.input || 0;
     const out = state.tokenUsage?.output || 0;
+    const tokens = `in:${inp} out:${out}`;
+    const turns = `turn:${state.turnCount || 0}`;
 
-    // Cost estimate based on model
-    let priceIn = 3, priceOut = 15; // Sonnet default
-    if (model.includes('haiku')) { priceIn = 0.25; priceOut = 1.25; }
-    if (model.includes('opus')) { priceIn = 15; priceOut = 75; }
-    if (model.includes('gpt-4o-mini')) { priceIn = 0.15; priceOut = 0.6; }
-    else if (model.includes('gpt-4o')) { priceIn = 2.5; priceOut = 10; }
-    if (model.includes('gemini')) { priceIn = 0.075; priceOut = 0.3; }
-
-    const costIn = (inp / 1_000_000) * priceIn;
-    const costOut = (out / 1_000_000) * priceOut;
+    // Cost estimate (Sonnet pricing by default)
+    const costIn = (inp / 1_000_000) * 3;
+    const costOut = (out / 1_000_000) * 15;
     const cost = `$${(costIn + costOut).toFixed(4)}`;
-    const turns = `turn:${state.turnCount || 0}`;
 
-    const costDisplay = `(tokens: ${formatNum(inp)} in / ${formatNum(out)} out | ${cost})`;
-    const right = `${model} | ${costDisplay} | ${turns}`;
+    const right = `${model} | ${tokens} | ${cost} | ${turns}`;
     const padding = Math.max(0, cols - right.length - 1);
     return c('dim', `${' '.repeat(padding)}${right}`);
 }
 
 /**
- * Format a cost display for inline use.
- * @param {object} state
- * @returns {string}
- */
-export function renderCostInline(state) {
-    const inp = state.tokenUsage?.input || 0;
-    const out = state.tokenUsage?.output || 0;
-    const model = state.model || '';
-    let priceIn = 3, priceOut = 15;
-    if (model.includes('haiku')) { priceIn = 0.25; priceOut = 1.25; }
-    if (model.includes('opus')) { priceIn = 15; priceOut = 75; }
-    const cost = ((inp / 1_000_000) * priceIn) + ((out / 1_000_000) * priceOut);
-    return c('dim', `(tokens: ${formatNum(inp)} in / ${formatNum(out)} out | $${cost.toFixed(4)})`);
-}
-
-function formatNum(n) {
-    if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
-    if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
-    return String(n);
-}
-
-/**
- * Render an error message with context.
+ * Render an error message.
  * @param {string} message
- * @param {string} [context]
  */
-export function renderError(message, context) {
-    let result = `${c('red', 'Error:')} ${message}`;
-    if (context) {
-        result += `\n${c('dim', `  Context: ${context}`)}`;
-    }
-    return result;
+export function renderError(message) {
+    return `${c('red', 'Error:')} ${message}`;
 }
 
 /**
@@ -233,11 +194,11 @@ export function renderSuccess(message) {
 }
 
 /**
- * Render thinking output (dim/gray).
+ * Render thinking output (dim).
  * @param {string} text
  */
 export function renderThinking(text) {
-    return c('gray', text);
+    return c('dim', text);
 }
 
 /**