@zhijiewang/openharness 1.4.0 → 2.1.0

package/dist/commands/index.js

@@ -28,8 +28,8 @@ register("help", "Show available commands", () => {
         'Session': ['clear', 'compact', 'export', 'history', 'browse', 'resume', 'fork', 'pin', 'unpin'],
         'Git': ['diff', 'undo', 'rewind', 'commit', 'log'],
         'Info': ['help', 'cost', 'status', 'config', 'files', 'model', 'memory', 'doctor', 'context', 'mcp', 'mcp-registry'],
-        'Settings': ['theme', 'vim', 'companion', 'fast', 'keys'],
-        'AI': ['plan', 'review', 'roles', 'agents', 'plugins'],
+        'Settings': ['theme', 'vim', 'companion', 'fast', 'keys', 'effort', 'sandbox'],
+        'AI': ['plan', 'review', 'roles', 'agents', 'plugins', 'btw'],
         'Pet': ['cybergotchi'],
     };
     const lines = [];
@@ -269,9 +269,37 @@ register("model", "Switch model (e.g., /model llama3.2 or /model ollama/llama3.2
     const modelName = model.includes("/") ? model.split("/").slice(1).join("/") : model;
     return { output: `Switched to ${modelName}.`, handled: true, newModel: modelName };
 });
-register("compact", "Compress conversation history", (_args, ctx) => {
+register("compact", "Compress conversation history (optional: focus keyword or message number)", (args, ctx) => {
+    const focus = args.trim();
     const before = ctx.messages.length;
     const targetTokens = Math.floor(getContextWindow(ctx.model) * 0.6);
+    if (focus && /^\d+$/.test(focus)) {
+        // Numeric: compact messages 1-N, keep N+1 onwards
+        const cutoff = parseInt(focus);
+        if (cutoff < 1 || cutoff >= before) {
+            return { output: `Invalid: use 1-${before - 1}`, handled: true };
+        }
+        const kept = ctx.messages.slice(cutoff);
+        return {
+            output: `Compacted: removed first ${cutoff} messages, kept ${kept.length}.`,
+            handled: true,
+            compactedMessages: kept,
+        };
+    }
+    if (focus) {
+        // Keyword focus: compress but preserve messages containing the keyword
+        const focusLower = focus.toLowerCase();
+        const preserved = ctx.messages.filter(m => m.content.toLowerCase().includes(focusLower) || m.meta?.pinned);
+        const others = ctx.messages.filter(m => !m.content.toLowerCase().includes(focusLower) && !m.meta?.pinned);
+        const compactedOthers = compressMessages(others, targetTokens);
+        const merged = [...compactedOthers, ...preserved].sort((a, b) => a.timestamp - b.timestamp);
+        return {
+            output: `Compacted with focus "${focus}": ${before} → ${merged.length} messages (preserved ${preserved.length} matching).`,
+            handled: true,
+            compactedMessages: merged,
+        };
+    }
+    // Default: compress everything
     const compacted = compressMessages(ctx.messages, targetTokens);
     const dropped = before - compacted.length;
     return {
@@ -447,6 +475,30 @@ register("keys", "Show keyboard shortcuts", () => {
     shortcuts.push("", "  Session:", "    /vim              Toggle Vim mode", "    /browse           Interactive session browser", "    /theme dark|light Switch theme");
     return { output: shortcuts.join("\n"), handled: true };
 });
+register("sandbox", "Show sandbox status and restrictions", () => {
+    const { sandboxStatus } = require('../harness/sandbox.js');
+    return { output: sandboxStatus() + '\n\nConfigure in .oh/config.yaml under sandbox:', handled: true };
+});
+register("effort", "Set reasoning effort level (low/medium/high/max)", (args) => {
+    const level = args.trim().toLowerCase();
+    const valid = ['low', 'medium', 'high', 'max'];
+    if (!valid.includes(level)) {
+        return { output: `Usage: /effort <${valid.join('|')}>\n\nlow    — fast, minimal reasoning\nmedium — balanced (default)\nhigh   — thorough reasoning\nmax    — maximum depth (Opus only)`, handled: true };
+    }
+    return { output: `Effort level set to: ${level}`, handled: true };
+});
+register("btw", "Ask a side question (ephemeral, no tools, not saved to history)", (args) => {
+    if (!args.trim()) {
+        return { output: "Usage: /btw <your question>", handled: true };
+    }
+    // Side questions are answered directly without tools or history
+    // The output is shown but NOT added to conversation history
+    return {
+        output: `[btw] ${args.trim()}`,
+        handled: false,
+        prependToPrompt: `[Side question — answer briefly without using any tools. This is ephemeral and not part of the main conversation.]\n\n${args.trim()}`,
+    };
+});
 register("plan", "Enter plan mode", (_args, _ctx) => {
     const task = _args.trim();
     if (!task) {
@@ -604,20 +656,50 @@ register("doctor", "Run diagnostic health checks", (_args, ctx) => {
 });
 register("context", "Show context window usage breakdown", (_args, ctx) => {
     const ctxWindow = getContextWindow(ctx.model);
-    const totalTokens = estimateMessageTokens(ctx.messages);
-    const breakdown = [`Context window: ${ctxWindow.toLocaleString()} tokens\n`];
-    for (let i = 0; i < ctx.messages.length; i++) {
-        const msg = ctx.messages[i];
-        const tokens = Math.round((msg.content?.length ?? 0) / 3.5); // rough per-message estimate
-        const role = msg.role.padEnd(9);
-        const pinned = msg.meta?.pinned ? " 📌" : "";
-        breakdown.push(`  #${(i + 1).toString().padStart(3)} ${role} ~${tokens.toLocaleString().padStart(6)} tokens${pinned}`);
+    // Categorize messages by type
+    let userTokens = 0, assistantTokens = 0, toolTokens = 0, systemTokens = 0;
+    for (const msg of ctx.messages) {
+        const tokens = Math.ceil((msg.content?.length ?? 0) / 4);
+        switch (msg.role) {
+            case 'user':
+                userTokens += tokens;
+                break;
+            case 'assistant':
+                assistantTokens += tokens;
+                break;
+            case 'tool':
+                toolTokens += tokens;
+                break;
+            case 'system':
+                systemTokens += tokens;
+                break;
+        }
     }
+    const totalTokens = userTokens + assistantTokens + toolTokens + systemTokens;
+    const freeTokens = ctxWindow - totalTokens;
     const usage = totalTokens / ctxWindow;
-    breakdown.push("");
-    breakdown.push(`Total:    ~${totalTokens.toLocaleString()} tokens (${Math.round(usage * 100)}% of ${ctxWindow.toLocaleString()})`);
-    breakdown.push(`Compress: at ${Math.round(ctxWindow * 0.8).toLocaleString()} tokens (80%)`);
-    return { output: breakdown.join("\n"), handled: true };
+    // Visual bar (30 chars wide)
+    const barWidth = 30;
+    const filled = Math.round(usage * barWidth);
+    const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(barWidth - filled);
+    const pct = (n) => `${((n / ctxWindow) * 100).toFixed(1)}%`;
+    const pad = (s, n) => s.padEnd(n);
+    const lines = [
+        `Context Window (${ctxWindow.toLocaleString()} tokens):`,
+        '',
+        `  ${pad('User messages:', 20)} ${userTokens.toLocaleString().padStart(8)} tokens  (${pct(userTokens)})`,
+        `  ${pad('Assistant:', 20)} ${assistantTokens.toLocaleString().padStart(8)} tokens  (${pct(assistantTokens)})`,
+        `  ${pad('Tool results:', 20)} ${toolTokens.toLocaleString().padStart(8)} tokens  (${pct(toolTokens)})`,
+        `  ${pad('System/info:', 20)} ${systemTokens.toLocaleString().padStart(8)} tokens  (${pct(systemTokens)})`,
+        '',
+        `  ${pad('Total used:', 20)} ${totalTokens.toLocaleString().padStart(8)} tokens  (${pct(totalTokens)})`,
+        `  ${pad('Free:', 20)} ${freeTokens.toLocaleString().padStart(8)} tokens  (${pct(freeTokens)})`,
+        '',
+        `  ${bar}  ${Math.round(usage * 100)}%`,
+        '',
+        `  Messages: ${ctx.messages.length}  |  Compress at: ${Math.round(ctxWindow * 0.8).toLocaleString()} (80%)`,
+    ];
+    return { output: lines.join('\n'), handled: true };
 });
 register("mcp", "Show MCP server status", () => {
     const mcp = connectedMcpServers();

package/dist/harness/config.d.ts

@@ -68,11 +68,21 @@ export type OhConfig = {
         balanced?: string;
         powerful?: string;
     };
+    /** Effort level for LLM reasoning depth */
+    effortLevel?: 'low' | 'medium' | 'high' | 'max';
     /** Opt-in telemetry (default: off) */
     telemetry?: {
         enabled?: boolean;
         endpoint?: string;
     };
+    /** Sandbox — filesystem and network restrictions */
+    sandbox?: {
+        enabled?: boolean;
+        allowedPaths?: string[];
+        allowedDomains?: string[];
+        blockNetwork?: boolean;
+        blockedCommands?: string[];
+    };
     /** Remote server security settings */
     remote?: {
         tokens?: string[];

package/dist/harness/sandbox.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Sandbox — filesystem and network restrictions for tool execution.
+ *
+ * Limits what tools can access:
+ * - File tools: only write to allowed paths
+ * - Web tools: only access allowed domains
+ * - Bash: restricted commands (no curl/wget by default)
+ *
+ * Reduces permission prompts while maintaining security.
+ */
+export type SandboxConfig = {
+    enabled: boolean;
+    /** Paths tools can write to (glob-style, relative to cwd) */
+    allowedPaths: string[];
+    /** Domains WebFetch/WebSearch can access */
+    allowedDomains: string[];
+    /** Block all network access */
+    blockNetwork: boolean;
+    /** Commands blocked in Bash (default: curl, wget) */
+    blockedCommands: string[];
+};
+/** Get the current sandbox config */
+export declare function getSandboxConfig(): SandboxConfig;
+/** Reset cached config */
+export declare function invalidateSandboxCache(): void;
+/** Check if a file path is allowed for writing */
+export declare function isPathAllowed(filePath: string): boolean;
+/** Check if a domain is allowed for network access */
+export declare function isDomainAllowed(url: string): boolean;
+/** Check if a bash command is allowed */
+export declare function isCommandAllowed(command: string): boolean;
+/** Get a human-readable sandbox status */
+export declare function sandboxStatus(): string;
+//# sourceMappingURL=sandbox.d.ts.map

package/dist/harness/sandbox.js

@@ -0,0 +1,104 @@
+/**
+ * Sandbox — filesystem and network restrictions for tool execution.
+ *
+ * Limits what tools can access:
+ * - File tools: only write to allowed paths
+ * - Web tools: only access allowed domains
+ * - Bash: restricted commands (no curl/wget by default)
+ *
+ * Reduces permission prompts while maintaining security.
+ */
+import { resolve, relative } from 'node:path';
+import { readOhConfig } from './config.js';
+const DEFAULT_SANDBOX = {
+    enabled: false,
+    allowedPaths: ['.'], // current directory
+    allowedDomains: [], // empty = all allowed
+    blockNetwork: false,
+    blockedCommands: ['curl', 'wget'],
+};
+// ── Sandbox Manager ──
+let _config = null;
+/** Get the current sandbox config */
+export function getSandboxConfig() {
+    if (_config)
+        return _config;
+    const ohConfig = readOhConfig();
+    if (ohConfig?.sandbox) {
+        _config = {
+            ...DEFAULT_SANDBOX,
+            ...ohConfig.sandbox,
+        };
+    }
+    else {
+        _config = DEFAULT_SANDBOX;
+    }
+    return _config;
+}
+/** Reset cached config */
+export function invalidateSandboxCache() {
+    _config = null;
+}
+/** Check if a file path is allowed for writing */
+export function isPathAllowed(filePath) {
+    const config = getSandboxConfig();
+    if (!config.enabled)
+        return true;
+    const resolved = resolve(filePath);
+    const cwd = process.cwd();
+    for (const allowed of config.allowedPaths) {
+        const allowedResolved = resolve(cwd, allowed);
+        // Check if the file is within the allowed directory
+        const rel = relative(allowedResolved, resolved);
+        if (!rel.startsWith('..') && !rel.startsWith('/'))
+            return true;
+    }
+    return false;
+}
+/** Check if a domain is allowed for network access */
+export function isDomainAllowed(url) {
+    const config = getSandboxConfig();
+    if (!config.enabled)
+        return true;
+    if (config.blockNetwork)
+        return false;
+    if (config.allowedDomains.length === 0)
+        return true;
+    try {
+        const hostname = new URL(url).hostname.toLowerCase();
+        return config.allowedDomains.some(d => hostname === d.toLowerCase() || hostname.endsWith('.' + d.toLowerCase()));
+    }
+    catch {
+        return false;
+    }
+}
+/** Check if a bash command is allowed */
+export function isCommandAllowed(command) {
+    const config = getSandboxConfig();
+    if (!config.enabled)
+        return true;
+    const firstWord = command.trim().split(/\s+/)[0]?.toLowerCase() ?? '';
+    return !config.blockedCommands.includes(firstWord);
+}
+/** Get a human-readable sandbox status */
+export function sandboxStatus() {
+    const config = getSandboxConfig();
+    if (!config.enabled)
+        return 'Sandbox: disabled';
+    const lines = ['Sandbox: enabled'];
+    lines.push(`  Allowed paths: ${config.allowedPaths.join(', ') || 'none'}`);
+    if (config.blockNetwork) {
+        lines.push('  Network: blocked');
+    }
+    else if (config.allowedDomains.length > 0) {
+        lines.push(`  Allowed domains: ${config.allowedDomains.join(', ')}`);
+    }
+    else {
+        lines.push('  Network: unrestricted');
+    }
+    if (config.blockedCommands.length > 0) {
+        lines.push(`  Blocked commands: ${config.blockedCommands.join(', ')}`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=sandbox.js.map

package/dist/harness/submit-handler.js

@@ -22,6 +22,26 @@ export async function handleUserInput(input, ctx) {
             return { handled: true, messages };
         }
     }
+    // ! Bash mode — direct shell execution, output added to context
+    if (trimmed.startsWith('!') && trimmed.length > 1) {
+        const command = trimmed.slice(1).trim();
+        try {
+            const { execSync } = await import('node:child_process');
+            const output = execSync(command, {
+                encoding: 'utf-8',
+                cwd: process.cwd(),
+                timeout: 30_000,
+                maxBuffer: 1024 * 1024,
+                windowsHide: true,
+            });
+            messages = [...messages, createInfoMessage(`$ ${command}\n${output.trimEnd()}`)];
+        }
+        catch (err) {
+            const output = String(err.stdout ?? err.stderr ?? err.message ?? 'Command failed');
+            messages = [...messages, createInfoMessage(`$ ${command}\n${output.trimEnd()}`)];
+        }
+        return { handled: true, messages };
+    }
     // Vim toggle
     if (trimmed === '/vim') {
         return { handled: true, messages, vimToggled: true };
@@ -69,25 +89,39 @@ export async function handleUserInput(input, ctx) {
     }
     // Normal prompt — add user message
     messages = [...messages, createUserMessage(input)];
-    // Resolve @mentions — local files first, then MCP resources
+    // Resolve @mentions — supports @file, @file#L5-10, @file#5-10, MCP resources
     let resolvedInput = input;
-    const mentionPattern = /@([\w][\w./-]*)/g;
-    const mentions = [...input.matchAll(mentionPattern)].map(m => m[1]);
+    const mentionPattern = /@([\w][\w./-]*)(?:#L?(\d+)(?:-(\d+))?)?/g;
+    const mentions = [...input.matchAll(mentionPattern)];
     const companionName = ctx.companionConfig?.soul?.name?.toLowerCase();
-    for (const mention of mentions) {
+    for (const match of mentions) {
+        const mention = match[1];
+        const startLine = match[2] ? parseInt(match[2]) : undefined;
+        const endLine = match[3] ? parseInt(match[3]) : startLine;
+        const fullRef = match[0];
         if (companionName && mention.toLowerCase() === companionName)
             continue;
-        // Try local file first (supports paths like @src/main.ts, @README.md)
+        // Try local file first (supports paths like @src/main.ts, @README.md#L5-10)
         try {
             const { existsSync, readFileSync } = await import('node:fs');
             const { resolve } = await import('node:path');
             const filePath = resolve(process.cwd(), mention);
             if (existsSync(filePath)) {
-                const content = readFileSync(filePath, 'utf-8');
-                const truncated = content.length > 10_000
-                    ? content.slice(0, 10_000) + '\n[...truncated]'
-                    : content;
-                resolvedInput += `\n\n[File @${mention}]:\n${truncated}`;
+                let content = readFileSync(filePath, 'utf-8');
+                // Apply line range if specified
+                if (startLine !== undefined) {
+                    const lines = content.split('\n');
+                    const start = Math.max(0, startLine - 1); // 1-indexed to 0-indexed
+                    const end = endLine !== undefined ? endLine : start + 1;
+                    content = lines.slice(start, end).join('\n');
+                    resolvedInput += `\n\n[File ${fullRef} (lines ${startLine}-${endLine ?? startLine})]:\n${content}`;
+                }
+                else {
+                    const truncated = content.length > 10_000
+                        ? content.slice(0, 10_000) + '\n[...truncated]'
+                        : content;
+                    resolvedInput += `\n\n[File @${mention}]:\n${truncated}`;
+                }
                 continue;
             }
         }

package/dist/harness/traces.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Session Traces — structured observability for agent sessions.
+ *
+ * Every query turn, tool call, LLM stream, and compression event
+ * generates a trace span. Traces enable debugging, replay, and
+ * performance analysis.
+ *
+ * Compatible with OpenTelemetry export format.
+ */
+export type TraceSpan = {
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    startTime: number;
+    endTime: number;
+    durationMs: number;
+    attributes: Record<string, unknown>;
+    status: 'ok' | 'error';
+};
+export type TraceEvent = {
+    name: string;
+    timestamp: number;
+    attributes?: Record<string, unknown>;
+};
+export declare class SessionTracer {
+    private sessionId;
+    private spans;
+    private activeSpans;
+    private spanCounter;
+    constructor(sessionId: string);
+    /** Start a new span. Returns the span ID. */
+    startSpan(name: string, attributes?: Record<string, unknown>, parentSpanId?: string): string;
+    /** End a span and record it. */
+    endSpan(spanId: string, status?: 'ok' | 'error', extraAttributes?: Record<string, unknown>): TraceSpan | null;
+    /** Get all completed spans */
+    getSpans(): TraceSpan[];
+    /** Get a summary of the trace */
+    getSummary(): {
+        totalSpans: number;
+        totalDurationMs: number;
+        spansByName: Record<string, {
+            count: number;
+            totalMs: number;
+        }>;
+        errors: number;
+    };
+    /** Persist a span to the trace file */
+    private persistSpan;
+}
+/** Load trace spans for a session */
+export declare function loadTrace(sessionId: string): TraceSpan[];
+/** List all sessions with traces */
+export declare function listTracedSessions(): string[];
+/** Format trace for display */
+export declare function formatTrace(spans: TraceSpan[]): string;
+/** Export trace in OpenTelemetry-compatible format */
+export declare function exportTraceOTLP(sessionId: string, spans: TraceSpan[]): object;
+//# sourceMappingURL=traces.d.ts.map

package/dist/harness/traces.js

@@ -0,0 +1,183 @@
+/**
+ * Session Traces — structured observability for agent sessions.
+ *
+ * Every query turn, tool call, LLM stream, and compression event
+ * generates a trace span. Traces enable debugging, replay, and
+ * performance analysis.
+ *
+ * Compatible with OpenTelemetry export format.
+ */
+import { appendFileSync, mkdirSync, existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const TRACE_DIR = join(homedir(), '.oh', 'traces');
+// ── Tracer ──
+const MAX_IN_MEMORY_SPANS = 1000;
+export class SessionTracer {
+    sessionId;
+    spans = [];
+    activeSpans = new Map();
+    spanCounter = 0;
+    constructor(sessionId) {
+        this.sessionId = sessionId;
+    }
+    /** Start a new span. Returns the span ID. */
+    startSpan(name, attributes = {}, parentSpanId) {
+        const spanId = `span-${++this.spanCounter}`;
+        this.activeSpans.set(spanId, { name, startTime: Date.now(), parentSpanId, attributes });
+        return spanId;
+    }
+    /** End a span and record it. */
+    endSpan(spanId, status = 'ok', extraAttributes) {
+        const active = this.activeSpans.get(spanId);
+        if (!active)
+            return null;
+        this.activeSpans.delete(spanId);
+        const endTime = Date.now();
+        const span = {
+            spanId,
+            parentSpanId: active.parentSpanId,
+            name: active.name,
+            startTime: active.startTime,
+            endTime,
+            durationMs: endTime - active.startTime,
+            attributes: { ...active.attributes, ...extraAttributes },
+            status,
+        };
+        this.spans.push(span);
+        // Cap in-memory spans (durable source is on disk)
+        if (this.spans.length > MAX_IN_MEMORY_SPANS) {
+            this.spans = this.spans.slice(-MAX_IN_MEMORY_SPANS);
+        }
+        this.persistSpan(span);
+        return span;
+    }
+    /** Get all completed spans */
+    getSpans() {
+        return [...this.spans];
+    }
+    /** Get a summary of the trace */
+    getSummary() {
+        const spansByName = {};
+        let errors = 0;
+        let minStart = Infinity;
+        let maxEnd = 0;
+        for (const span of this.spans) {
+            const entry = spansByName[span.name] ?? { count: 0, totalMs: 0 };
+            entry.count++;
+            entry.totalMs += span.durationMs;
+            spansByName[span.name] = entry;
+            if (span.status === 'error')
+                errors++;
+            if (span.startTime < minStart)
+                minStart = span.startTime;
+            if (span.endTime > maxEnd)
+                maxEnd = span.endTime;
+        }
+        return {
+            totalSpans: this.spans.length,
+            totalDurationMs: maxEnd > minStart ? maxEnd - minStart : 0,
+            spansByName,
+            errors,
+        };
+    }
+    /** Persist a span to the trace file */
+    persistSpan(span) {
+        try {
+            mkdirSync(TRACE_DIR, { recursive: true });
+            const file = join(TRACE_DIR, `${this.sessionId}.jsonl`);
+            appendFileSync(file, JSON.stringify(span) + '\n');
+        }
+        catch { /* never crash on tracing failure */ }
+    }
+}
+// ── Trace Loading ──
+/** Load trace spans for a session */
+export function loadTrace(sessionId) {
+    const file = join(TRACE_DIR, `${sessionId}.jsonl`);
+    if (!existsSync(file))
+        return [];
+    try {
+        return readFileSync(file, 'utf-8')
+            .split('\n')
+            .filter(Boolean)
+            .map(line => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}
+/** List all sessions with traces */
+export function listTracedSessions() {
+    if (!existsSync(TRACE_DIR))
+        return [];
+    return readdirSync(TRACE_DIR)
+        .filter(f => f.endsWith('.jsonl'))
+        .map(f => f.replace('.jsonl', ''));
+}
+/** Format trace for display */
+export function formatTrace(spans) {
+    if (spans.length === 0)
+        return 'No trace spans recorded.';
+    const lines = [`Trace (${spans.length} spans):\n`];
+    // Group by parent for tree display
+    const roots = spans.filter(s => !s.parentSpanId);
+    const children = new Map();
+    for (const s of spans) {
+        if (s.parentSpanId) {
+            const list = children.get(s.parentSpanId) ?? [];
+            list.push(s);
+            children.set(s.parentSpanId, list);
+        }
+    }
+    function renderSpan(span, indent) {
+        const status = span.status === 'error' ? '✗' : '✓';
+        const pad = '  '.repeat(indent);
+        const attrs = Object.entries(span.attributes)
+            .filter(([, v]) => v !== undefined)
+            .map(([k, v]) => `${k}=${String(v).slice(0, 30)}`)
+            .join(' ');
+        lines.push(`${pad}${status} ${span.name} (${span.durationMs}ms) ${attrs}`);
+        const kids = children.get(span.spanId) ?? [];
+        for (const kid of kids)
+            renderSpan(kid, indent + 1);
+    }
+    for (const root of roots)
+        renderSpan(root, 0);
+    // Summary
+    const totalMs = spans.reduce((sum, s) => sum + s.durationMs, 0);
+    const errors = spans.filter(s => s.status === 'error').length;
+    lines.push('');
+    lines.push(`Total: ${spans.length} spans, ${totalMs}ms, ${errors} errors`);
+    return lines.join('\n');
+}
+/** Export trace in OpenTelemetry-compatible format */
+export function exportTraceOTLP(sessionId, spans) {
+    return {
+        resourceSpans: [{
+                resource: {
+                    attributes: [
+                        { key: 'service.name', value: { stringValue: 'openharness' } },
+                        { key: 'session.id', value: { stringValue: sessionId } },
+                    ],
+                },
+                scopeSpans: [{
+                        scope: { name: 'openharness.agent' },
+                        spans: spans.map(s => ({
+                            traceId: sessionId.padEnd(32, '0').slice(0, 32),
+                            spanId: s.spanId.padEnd(16, '0').slice(0, 16),
+                            parentSpanId: s.parentSpanId?.padEnd(16, '0').slice(0, 16),
+                            name: s.name,
+                            startTimeUnixNano: s.startTime * 1_000_000,
+                            endTimeUnixNano: s.endTime * 1_000_000,
+                            attributes: Object.entries(s.attributes).map(([k, v]) => ({
+                                key: k,
+                                value: { stringValue: String(v) },
+                            })),
+                            status: { code: s.status === 'ok' ? 1 : 2 },
+                        })),
+                    }],
+            }],
+    };
+}
+//# sourceMappingURL=traces.js.map

package/dist/main.js

@@ -234,6 +234,8 @@ program
     .option("--light", "Use light theme")
     .option("--output-format <format>", "Output format for -p mode (text, json, stream-json)", "text")
     .option("--json-schema <schema>", "Constrain output to match a JSON schema (headless mode)")
+    .option("--input-format <format>", "Input format: text (default) or stream-json (NDJSON on stdin)")
+    .option("--replay-user-messages", "Re-emit user messages on stdout (requires stream-json output)")
     .action(async (opts) => {
     // Load saved config as defaults (env vars + CLI flags override)
     const savedConfig = readOhConfig();