@ruvnet/open-claude-code 2.1.0 → 2.1.1-nightly.20261011.202

package/src/config/settings.mjs

@@ -58,6 +58,10 @@ export const SETTINGS_SCHEMA = {
     agentId: null,
     cronEnabled: true,
     featureFlags: {},
+    // Metaharness self-optimization (opt-in; default OFF — behavior unchanged).
+    selfOptimize: false,
+    selfOptimizeQualityBar: 0.7,
+    selfOptimizeLadder: null,
 };
 
 export async function loadSettings() {
@@ -116,4 +120,6 @@ function applyEnvOverrides(settings) {
     if (process.env.CLAUDE_CODE_THINKING === '1') settings.alwaysThinkingEnabled = true;
     if (process.env.CLAUDE_CODE_DISABLE_CRON === '1') settings.cronEnabled = false;
     if (process.env.CLAUDE_CODE_ENABLE_TASKS === '1') settings.enableTeams = true;
+    if (process.env.CLAUDE_CODE_SELF_OPTIMIZE === '1') settings.selfOptimize = true;
+    if (process.env.CLAUDE_CODE_SELF_OPTIMIZE === '0') settings.selfOptimize = false;
 }

package/src/core/agent-loop.mjs

@@ -5,9 +5,12 @@
 import { streamResponse, accumulateStream } from './streaming.mjs';
 import { ContextManager } from './context-manager.mjs';
 import { buildSystemPrompt } from './system-prompt.mjs';
-import fs from 'fs';
-import path from 'path';
-export function createAgentLoop({ model, tools, permissions, settings, hooks }) {
+import { readApiKey } from './providers.mjs';
+
+/** Maximum number of consecutive tool-use continuation turns before aborting. */
+const MAX_TOOL_RECURSION_DEPTH = 50;
+
+export function createAgentLoop({ model, tools, permissions, settings, hooks, cascade = null }) {
     const contextManager = new ContextManager(settings.maxContextTokens || 180000);
 
     // Build system prompt using the new builder
@@ -26,9 +29,41 @@ export function createAgentLoop({ model, tools, permissions, settings, hooks })
         model,
         tools,
         _contextManager: contextManager,
+        _cascade: cascade,
     };
 
+    // Self-optimization bookkeeping for the current top-level task (opt-in).
+    let _optTask = null; // { model, complexity, startedAt, tokensAtStart }
+
+    /** Record the outcome of the current task, if self-optimization is on. */
+    function recordOptOutcome(success) {
+        if (!cascade || !_optTask) return;
+        const inputDelta = state.tokenUsage.input - _optTask.tokensAtStart.input;
+        const outputDelta = state.tokenUsage.output - _optTask.tokensAtStart.output;
+        try {
+            cascade.recordOutcome({
+                model: _optTask.model,
+                success,
+                latencyMs: Date.now() - _optTask.startedAt,
+                inputTokens: inputDelta >= 0 ? inputDelta : 0,
+                outputTokens: outputDelta >= 0 ? outputDelta : 0,
+                complexity: _optTask.complexity,
+                task: _optTask.task,
+            });
+        } catch { /* best-effort */ }
+        _optTask = null;
+    }
+
     async function* run(userMessage, options = {}) {
+        const depth = (options._depth || 0);
+
+        // Guard against runaway tool-call recursion
+        if (depth >= MAX_TOOL_RECURSION_DEPTH) {
+            yield { type: 'error', message: `Max tool recursion depth (${MAX_TOOL_RECURSION_DEPTH}) reached. Stopping to prevent infinite loop.` };
+            yield { type: 'stop', reason: 'max_recursion' };
+            return;
+        }
+
         // Add user message (skip for continuation turns)
         if (userMessage && !options.continuation) {
             state.messages = contextManager.addMessage(state.messages, {
@@ -36,6 +71,22 @@ export function createAgentLoop({ model, tools, permissions, settings, hooks })
                 content: userMessage,
             });
             state.turnCount++;
+
+            // Opt-in cost-cascade routing: pick the cheapest good-enough model
+            // for this task and record outcome bookkeeping. Default path (no
+            // cascade) leaves state.model exactly as constructed.
+            if (cascade) {
+                const route = cascade.decide(userMessage);
+                state.model = route.model;
+                state._lastRoute = route;
+                _optTask = {
+                    model: route.model,
+                    complexity: route.complexity,
+                    startedAt: Date.now(),
+                    tokensAtStart: { input: state.tokenUsage.input, output: state.tokenUsage.output },
+                    task: String(userMessage).slice(0, 120),
+                };
+            }
         }
 
         // Check max turns
@@ -53,14 +104,16 @@ export function createAgentLoop({ model, tools, permissions, settings, hooks })
 
         yield { type: 'stream_request_start', turn: state.turnCount };
 
-        // Detect provider and call API
-        const provider = detectProvider(model);
+        // Detect provider and call API. Use state.model so an opt-in cascade
+        // pick takes effect; defaults to the constructed model otherwise.
+        const activeModel = state.model || model;
+        const provider = detectProvider(activeModel);
         let response;
 
         try {
-            if (settings.stream !== false) {
+            if (settings.stream !== false && provider === 'anthropic') {
                 // Streaming mode
-                response = await callApiStreaming(provider, model, state, tools.list(), settings);
+                response = await callApiStreaming(provider, activeModel, state, tools.list(), settings);
                 const collectedContent = [];
                 let currentText = '';
                 let currentThinking = '';
@@ -87,9 +140,10 @@ export function createAgentLoop({ model, tools, permissions, settings, hooks })
                 response = response.accumulated;
             } else {
                 // Non-streaming mode
-                response = await callApi(provider, model, state, tools.list(), settings);
+                response = await callApi(provider, activeModel, state, tools.list(), settings);
             }
         } catch (err) {
+            recordOptOutcome(false);
             yield { type: 'error', message: err.message };
             return;
         }
@@ -180,7 +234,7 @@ export function createAgentLoop({ model, tools, permissions, settings, hooks })
             state.messages.push({ role: 'user', content: toolResults });
 
             // Recursive: continue the loop after tool execution
-            yield* run(null, { continuation: true });
+            yield* run(null, { continuation: true, _depth: depth + 1 });
             return;
         }
 
@@ -193,11 +247,14 @@ export function createAgentLoop({ model, tools, permissions, settings, hooks })
                     role: 'user',
                     content: '[System: A hook prevented stopping. Please continue with the task.]',
                 });
-                yield* run(null, { continuation: true });
+                yield* run(null, { continuation: true, _depth: depth + 1 });
                 return;
             }
         }
 
+        // Task completed normally — record a successful outcome (opt-in).
+        recordOptOutcome(true);
+
         yield { type: 'stop', reason: response.stop_reason || 'end_turn' };
     }
 
@@ -223,8 +280,8 @@ async function callApiStreaming(provider, model, state, toolDefs, settings) {
 }
 
 async function callAnthropic(model, state, toolDefs, settings, stream) {
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) throw new Error('ANTHROPIC_API_KEY not set');
+    const apiKey = readApiKey('ANTHROPIC_API_KEY');
+    if (!apiKey) throw new Error('ANTHROPIC_API_KEY is not set. Export it in your environment before running.');
 
     const body = {
         model,
@@ -240,7 +297,8 @@ async function callAnthropic(model, state, toolDefs, settings, stream) {
         body.thinking = { type: 'enabled', budget_tokens: settings.thinkingBudget || 10000 };
     }
 
-    const res = await fetch('https://api.anthropic.com/v1/messages', {
+    const res = await fetch((process.env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com').replace(/\/$/, '') + '/v1/messages', {
+        redirect: 'error',
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
@@ -252,7 +310,7 @@ async function callAnthropic(model, state, toolDefs, settings, stream) {
 
     if (!res.ok) {
         const err = await res.text();
-        throw new Error(`Anthropic API error ${res.status}: ${err}`);
+        throw new Error(`Anthropic API error ${res.status}`);
     }
 
     if (stream) {
@@ -275,24 +333,29 @@ async function callAnthropic(model, state, toolDefs, settings, stream) {
 }
 
 async function callOpenAI(model, state, toolDefs, settings, stream) {
-    const apiKey = process.env.OPENAI_API_KEY;
-    if (!apiKey) throw new Error('OPENAI_API_KEY not set');
+    const apiKey = readApiKey('OPENAI_API_KEY');
+    if (!apiKey) throw new Error('OPENAI_API_KEY is not set. Export it in your environment before running.');
 
     const messages = [];
-    if (state.systemPrompt) {
-        messages.push({ role: 'system', content: state.systemPrompt });
-    }
+    if (state.systemPrompt) messages.push({ role: 'system', content: state.systemPrompt });
     for (const msg of state.messages) {
         if (typeof msg.content === 'string') {
             messages.push({ role: msg.role, content: msg.content });
         } else if (Array.isArray(msg.content)) {
-            for (const block of msg.content) {
-                if (block.type === 'tool_result') {
-                    messages.push({
-                        role: 'tool',
+            if (msg.role === 'assistant') {
+                const calls = msg.content.filter(b => b.type === 'tool_use').map(b => ({
+                    id: b.id, type: 'function',
+                    function: { name: b.name, arguments: JSON.stringify(b.input || {}) }
+                }));
+                messages.push({ role: 'assistant',
+                    content: msg.content.filter(b => b.type === 'text').map(b => b.text).join('') || null,
+                    ...(calls.length && { tool_calls: calls }) });
+            } else {
+                for (const block of msg.content) {
+                    if (block.type === 'tool_result') messages.push({ role: 'tool',
                         tool_call_id: block.tool_use_id,
-                        content: block.content,
-                    });
+                        content: typeof block.content === 'string' ? block.content : JSON.stringify(block.content) });
+                    else if (block.type === 'text') messages.push({ role: msg.role, content: block.text });
                 }
             }
         }
@@ -311,6 +374,7 @@ async function callOpenAI(model, state, toolDefs, settings, stream) {
 
     const baseUrl = process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1';
     const res = await fetch(`${baseUrl}/chat/completions`, {
+        redirect: 'error',
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
@@ -321,7 +385,7 @@ async function callOpenAI(model, state, toolDefs, settings, stream) {
 
     if (!res.ok) {
         const err = await res.text();
-        throw new Error(`OpenAI API error ${res.status}: ${err}`);
+        throw new Error(`OpenAI API error ${res.status}`);
     }
 
     const data = await res.json();
@@ -329,8 +393,8 @@ async function callOpenAI(model, state, toolDefs, settings, stream) {
 }
 
 async function callGoogle(model, state, toolDefs, settings, stream) {
-    const apiKey = process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY;
-    if (!apiKey) throw new Error('GOOGLE_API_KEY or GEMINI_API_KEY not set');
+    const apiKey = readApiKey('GOOGLE_API_KEY', 'GEMINI_API_KEY');
+    if (!apiKey) throw new Error('GOOGLE_API_KEY or GEMINI_API_KEY is not set. Export one in your environment before running.');
 
     const contents = [];
     for (const msg of state.messages) {

package/src/core/providers.mjs

@@ -204,6 +204,24 @@ export function listProviders() {
     }));
 }
 
+/**
+ * Read an API key from the environment, in order of preference.
+ *
+ * Surrounding whitespace is trimmed — keys routinely arrive from .env files or
+ * command substitution with a trailing newline — and a whitespace-only value is
+ * treated as unset, so the next name is tried. No format validation: the
+ * provider is what authenticates the key.
+ * @param {...string} envKeys - env var names to try, most preferred first
+ * @returns {string} the trimmed key, or '' if none is configured
+ */
+export function readApiKey(...envKeys) {
+    for (const envKey of envKeys) {
+        const value = (process.env[envKey] || '').trim();
+        if (value) return value;
+    }
+    return '';
+}
+
 /**
  * Check which providers have API keys configured.
  * @returns {Array<{ id: string, name: string, configured: boolean }>}
@@ -212,7 +230,7 @@ export function checkProviderKeys() {
     return Object.entries(PROVIDERS).map(([key, p]) => ({
         id: key,
         name: p.name,
-        configured: !!(process.env[p.envKey] || (p.altEnvKey && process.env[p.altEnvKey])),
+        configured: !!readApiKey(p.envKey, ...(p.altEnvKey ? [p.altEnvKey] : [])),
     }));
 }
 

package/src/core/session.mjs

@@ -108,10 +108,36 @@ export class SessionManager {
      * @param {object} state - agent loop state to restore into
      */
     importFromTeleport(data, state) {
-        const session = JSON.parse(Buffer.from(data, 'base64').toString());
-        state.messages = session.messages || [];
-        state.turnCount = session.turnCount || 0;
-        if (session.model) state.model = session.model;
+        if (typeof data !== 'string' || data.length === 0) {
+            throw new Error('Invalid teleport data: must be a non-empty string');
+        }
+
+        let session;
+        try {
+            session = JSON.parse(Buffer.from(data, 'base64').toString());
+        } catch {
+            throw new Error('Invalid teleport data: failed to decode or parse');
+        }
+
+        if (typeof session !== 'object' || session === null) {
+            throw new Error('Invalid teleport data: expected an object');
+        }
+
+        // Validate and sanitize messages — must be an array of {role, content}
+        const rawMessages = Array.isArray(session.messages) ? session.messages : [];
+        state.messages = rawMessages.filter(
+            (m) => m && typeof m.role === 'string' && (typeof m.content === 'string' || Array.isArray(m.content))
+        );
+
+        // Validate turn count
+        const turnCount = parseInt(session.turnCount, 10);
+        state.turnCount = isNaN(turnCount) || turnCount < 0 ? 0 : turnCount;
+
+        // Only allow known model strings (non-empty string, no shell injection)
+        if (typeof session.model === 'string' && /^[\w.:/-]{3,80}$/.test(session.model)) {
+            state.model = session.model;
+        }
+
         this.sessionId = `sess_teleport_${Date.now()}`;
     }
 

package/src/hooks/engine.mjs

@@ -121,6 +121,12 @@ export class HookEngine {
     /**
      * Execute a single hook. Supports command (shell) and function hooks.
      *
+     * Note: hook.command is an operator-configured shell string (defined in
+     * settings.json by the user who controls this machine) — it is intentionally
+     * executed as a shell command.  The tool input/context is passed ONLY via
+     * environment variables (never interpolated into the command string) to
+     * prevent escalation from tool input into the hook command itself.
+     *
      * @param {object} hook - hook definition
      * @param {object} context - execution context
      * @returns {Promise<object|null>}
@@ -128,10 +134,12 @@ export class HookEngine {
     async _executeHook(hook, context) {
         try {
             if (hook.command) {
+                // Ensure env values are strings (guards against prototype pollution
+                // or non-string values from context objects breaking child_process).
                 const env = {
                     ...process.env,
-                    HOOK_EVENT: context.event,
-                    HOOK_TOOL: context.toolName || '',
+                    HOOK_EVENT: String(context.event || ''),
+                    HOOK_TOOL: String(context.toolName || ''),
                     HOOK_INPUT: JSON.stringify(context.input || {}),
                 };
                 const output = execSync(hook.command, {

package/src/index.mjs

@@ -21,6 +21,7 @@
  * - Telemetry stub
  */
 
+import { readFileSync } from 'node:fs';
 import { createAgentLoop } from './core/agent-loop.mjs';
 import { createToolRegistry } from './tools/registry.mjs';
 import { createPermissionChecker } from './permissions/checker.mjs';
@@ -37,11 +38,30 @@ import { readEnv } from './config/env.mjs';
 import * as telemetry from './telemetry/index.mjs';
 
 async function main() {
-    const args = parseArgs(process.argv.slice(2));
+    const rawArgv = process.argv.slice(2);
+
+    // ── Metaharness subcommand dispatch (opt-in; runs before normal flow) ──
+    // `occ optimize|redblue|darwin ...` are handled here and exit. A normal
+    // `occ "prompt"` never reaches this branch, so default behavior is intact.
+    const subcommand = rawArgv[0];
+    if (subcommand === 'optimize' || subcommand === 'redblue' || subcommand === 'darwin') {
+        const settings = await loadSettings();
+        const { runOptimize, delegateToCli } = await import('./optimize/commands.mjs');
+        if (subcommand === 'optimize') {
+            const { output, code } = await runOptimize(rawArgv.slice(1), settings);
+            console.log(output);
+            process.exit(code);
+        }
+        const pkg = subcommand === 'redblue' ? '@metaharness/redblue' : '@metaharness/darwin';
+        const { code } = await delegateToCli(pkg, rawArgv.slice(1));
+        process.exit(code);
+    }
+
+    const args = parseArgs(rawArgv);
 
     // Handle --version
     if (args.showVersion) {
-        console.log('open-claude-code v2.0.0-alpha.1');
+        console.log('open-claude-code v' + JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version);
         process.exit(0);
     }
 
@@ -107,12 +127,29 @@ async function main() {
     const mcpResourceTool = tools.get('ReadMcpResource');
     if (mcpResourceTool) mcpResourceTool._mcpClients = mcpClients;
 
+    // ── Opt-in self-optimization cascade ──
+    // Only constructed when enabled (flag > env > setting). When null, the agent
+    // loop behaves exactly as before — same model, no outcome recording.
+    let cascade = null;
+    const { isSelfOptimizeEnabled } = await import('./optimize/cascade.mjs');
+    if (isSelfOptimizeEnabled(args, settings, process.env)) {
+        const { SelfOptimizeCascade } = await import('./optimize/cascade.mjs');
+        cascade = new SelfOptimizeCascade({
+            settings,
+            fallbackModel: args.model || settings.model || 'claude-sonnet-4-6',
+        });
+        if (args.verbose || settings.verbose) {
+            console.error('\x1b[2m[self-optimize] cost-cascade router enabled\x1b[0m');
+        }
+    }
+
     const loop = createAgentLoop({
         model: args.model || settings.model || 'claude-sonnet-4-6',
         tools,
         permissions,
         settings,
         hooks,
+        cascade,
     });
 
     // Attach extra state for commands to access
@@ -146,6 +183,7 @@ async function main() {
         const results = [];
 
         for await (const event of loop.run(args.prompt)) {
+            if (event.type === 'error') process.exitCode = 1;
             if (outputFormat === 'json') {
                 results.push(event);
             } else if (outputFormat === 'stream-json') {

package/src/optimize/cascade.mjs

@@ -0,0 +1,128 @@
+/**
+ * Self-optimization cascade controller.
+ *
+ * Glue between {@link MetaHarnessRouter} and {@link OutcomeStore}. Given a task,
+ * it decides which model to use (cost-cascade), and after the task completes it
+ * records the real outcome so future routing self-tunes.
+ *
+ * This is OPT-IN. It is only constructed when the user enables self-optimization
+ * via `--self-optimize`, the `selfOptimize` setting, or CLAUDE_CODE_SELF_OPTIMIZE.
+ * When disabled, the agent loop never imports or runs any of this, so default
+ * behavior is byte-identical.
+ */
+import { MetaHarnessRouter, DEFAULT_LADDER } from './router.mjs';
+import { OutcomeStore, estimateCostUsd } from './store.mjs';
+
+/**
+ * Build a model ladder from settings, falling back to the default. Honors an
+ * explicit `selfOptimizeLadder` setting (array of {id,costPerMTok}) and keeps
+ * the configured base/fast/frontier models if present.
+ *
+ * @param {object} [settings]
+ * @returns {Array<{id:string,costPerMTok:number,tier?:number}>}
+ */
+export function buildLadder(settings = {}) {
+    if (Array.isArray(settings.selfOptimizeLadder) && settings.selfOptimizeLadder.length) {
+        return settings.selfOptimizeLadder
+            .filter(m => m && m.id && typeof m.costPerMTok === 'number')
+            .map((m, i) => ({ tier: i + 1, ...m }));
+    }
+    return DEFAULT_LADDER;
+}
+
+/**
+ * Cascade controller. Holds a router + outcome store and exposes a small API the
+ * agent loop calls.
+ */
+export class SelfOptimizeCascade {
+    /**
+     * @param {object} [opts]
+     * @param {object} [opts.settings] CLI settings (ladder, qualityBar)
+     * @param {OutcomeStore} [opts.store] outcome store (defaults to a fresh one)
+     * @param {string} [opts.fallbackModel] model to use if routing yields nothing
+     */
+    constructor(opts = {}) {
+        const settings = opts.settings || {};
+        this.store = opts.store || new OutcomeStore();
+        this.fallbackModel = opts.fallbackModel || settings.model || 'claude-sonnet-4-6';
+        const ladder = buildLadder(settings);
+        this.ladder = ladder;
+        this.router = new MetaHarnessRouter({
+            ladder,
+            qualityBar: typeof settings.selfOptimizeQualityBar === 'number' ? settings.selfOptimizeQualityBar : 0.7,
+            statsFor: (id) => this.store.statsFor(id),
+        });
+        /** @type {Array<{task:string, route:object}>} last routing decisions (in-memory, for inspection) */
+        this.lastRoutes = [];
+    }
+
+    /**
+     * Decide which model to use for a task without making any model call.
+     * @param {string} taskText
+     * @returns {{ model: string, predictedQuality: number, costPerMTok: number, metBar: boolean, complexity: number, ladder: string[] }}
+     */
+    decide(taskText) {
+        const route = this.router.route(taskText || '');
+        this.lastRoutes.push({ task: (taskText || '').slice(0, 80), route });
+        if (this.lastRoutes.length > 50) this.lastRoutes.shift();
+        return route;
+    }
+
+    /**
+     * Record a completed task's real outcome.
+     * @param {object} o
+     * @param {string} o.model
+     * @param {boolean} o.success
+     * @param {number} [o.latencyMs]
+     * @param {number} [o.inputTokens]
+     * @param {number} [o.outputTokens]
+     * @param {number} [o.complexity]
+     * @param {string} [o.task]
+     */
+    recordOutcome(o) {
+        const entry = this.ladder.find(m => m.id === o.model);
+        const costUsd = estimateCostUsd(o.inputTokens, o.outputTokens, entry ? entry.costPerMTok : 0);
+        return this.store.record({
+            model: o.model,
+            success: !!o.success,
+            latencyMs: o.latencyMs,
+            inputTokens: o.inputTokens,
+            outputTokens: o.outputTokens,
+            costUsd,
+            complexity: o.complexity,
+            task: o.task,
+        });
+    }
+
+    /** Get the next model to escalate to after a failure, or null. */
+    escalate(failedModelId) {
+        return this.router.escalate(failedModelId);
+    }
+
+    /** Human-readable status for `occ optimize status`. */
+    status() {
+        return {
+            ladder: this.ladder.map(m => ({ id: m.id, costPerMTok: m.costPerMTok })),
+            qualityBar: this.router.qualityBar,
+            store: this.store.filePath,
+            summary: this.store.summary(),
+        };
+    }
+}
+
+/**
+ * Decide whether self-optimization is enabled, from the precedence:
+ * CLI flag > env var > setting. Default OFF.
+ *
+ * @param {object} [args] parsed CLI args (may have selfOptimize)
+ * @param {object} [settings]
+ * @param {object} [env] process.env-like
+ * @returns {boolean}
+ */
+export function isSelfOptimizeEnabled(args = {}, settings = {}, env = process.env) {
+    if (args.selfOptimize === true) return true;
+    if (args.selfOptimize === false) return false; // explicit --no-self-optimize would set this
+    if (env && env.CLAUDE_CODE_SELF_OPTIMIZE === '1') return true;
+    if (env && env.CLAUDE_CODE_SELF_OPTIMIZE === '0') return false;
+    return settings.selfOptimize === true;
+}