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

package/src/core/session.mjs

@@ -1,9 +1,8 @@
 /**
- * Session Manager — save, resume, list, and teleport sessions.
+ * Session Manager — save, resume, and teleport sessions.
  *
  * Sessions are stored at ~/.claude/projects/<hash>/session.json
  * and contain conversation history, token usage, and metadata.
- * Supports listing recent sessions and resuming by ID.
  */
 
 import fs from 'fs';
@@ -32,16 +31,8 @@ export class SessionManager {
     }
 
     /**
-     * Get the base projects directory (for listing all sessions).
-     */
-    static getProjectsDir() {
-        return path.join(os.homedir(), '.claude', 'projects');
-    }
-
-    /**
-     * Save the current session state (messages + full state).
+     * Save the current session state.
      * @param {object} state - agent loop state to save
-     * @returns {string} path to saved session file
      */
     save(state) {
         const dir = this.getSessionDir();
@@ -60,101 +51,28 @@ export class SessionManager {
             systemPrompt: state.systemPrompt,
         };
 
-        // Save current session
         const filePath = path.join(dir, 'session.json');
         fs.writeFileSync(filePath, JSON.stringify(session, null, 2));
-
-        // Also save to sessions history for listing
-        this._saveToHistory(dir, session);
-
         return filePath;
     }
 
     /**
-     * Save a minimal entry to sessions history for listing.
-     */
-    _saveToHistory(dir, session) {
-        const historyFile = path.join(dir, 'sessions-history.json');
-        let history = [];
-        try {
-            history = JSON.parse(fs.readFileSync(historyFile, 'utf-8'));
-        } catch { /* new file */ }
-
-        // Remove old entry with same ID
-        history = history.filter(h => h.id !== session.id);
-
-        history.push({
-            id: session.id,
-            projectDir: session.projectDir,
-            startedAt: session.startedAt,
-            savedAt: session.savedAt,
-            model: session.model,
-            turnCount: session.turnCount,
-            tokenUsage: session.tokenUsage,
-            messageCount: (session.messages || []).length,
-        });
-
-        // Keep last 50
-        if (history.length > 50) history = history.slice(-50);
-        fs.writeFileSync(historyFile, JSON.stringify(history, null, 2));
-    }
-
-    /**
-     * Load and restore a saved session into agent loop state.
-     * Fully restores messages so conversation can continue.
+     * Resume a saved session.
      * @param {object} state - agent loop state to restore into
-     * @param {string} [sessionId] - optional specific session ID to load
      * @returns {boolean} true if session was restored
      */
-    resume(state, sessionId) {
+    resume(state) {
         const dir = this.getSessionDir();
-
-        if (sessionId) {
-            // Look up specific session from history
-            return this._resumeById(state, dir, sessionId);
-        }
-
-        // Load most recent session
         const filePath = path.join(dir, 'session.json');
-        return this._loadSessionFile(state, filePath);
-    }
-
-    /**
-     * Resume a specific session by ID.
-     */
-    _resumeById(state, dir, sessionId) {
-        // Check if it is the current session.json
-        const mainFile = path.join(dir, 'session.json');
-        try {
-            const data = JSON.parse(fs.readFileSync(mainFile, 'utf-8'));
-            if (data.id === sessionId) {
-                return this._loadSessionFile(state, mainFile);
-            }
-        } catch { /* continue searching */ }
 
-        // Check archived sessions
-        const archiveFile = path.join(dir, `session-${sessionId}.json`);
-        try {
-            return this._loadSessionFile(state, archiveFile);
-        } catch {
-            return false;
-        }
-    }
-
-    /**
-     * Load a session from a file path.
-     */
-    _loadSessionFile(state, filePath) {
         try {
             const raw = fs.readFileSync(filePath, 'utf-8');
             const session = JSON.parse(raw);
 
-            // Restore all messages so the conversation continues
             state.messages = session.messages || [];
             state.turnCount = session.turnCount || 0;
             state.tokenUsage = session.tokenUsage || { input: 0, output: 0 };
             if (session.model) state.model = session.model;
-            if (session.systemPrompt) state.systemPrompt = session.systemPrompt;
 
             this.sessionId = session.id;
             this.conversationId = session.conversationId;
@@ -166,65 +84,6 @@ export class SessionManager {
         }
     }
 
-    /**
-     * List recent sessions for the current project.
-     * @param {number} [limit=10]
-     * @returns {Array<{id, projectDir, startedAt, savedAt, model, turnCount, messageCount}>}
-     */
-    listSessions(limit = 10) {
-        const dir = this.getSessionDir();
-        const historyFile = path.join(dir, 'sessions-history.json');
-        try {
-            const history = JSON.parse(fs.readFileSync(historyFile, 'utf-8'));
-            return history.slice(-limit).reverse();
-        } catch {
-            // Try loading the single session.json as fallback
-            const mainFile = path.join(dir, 'session.json');
-            try {
-                const data = JSON.parse(fs.readFileSync(mainFile, 'utf-8'));
-                return [{
-                    id: data.id,
-                    projectDir: data.projectDir,
-                    startedAt: data.startedAt,
-                    savedAt: data.savedAt,
-                    model: data.model,
-                    turnCount: data.turnCount,
-                    messageCount: (data.messages || []).length,
-                }];
-            } catch {
-                return [];
-            }
-        }
-    }
-
-    /**
-     * Check if there is a resumable session for the current project.
-     * @returns {{ resumable: boolean, session?: object }}
-     */
-    checkResumable() {
-        const dir = this.getSessionDir();
-        const filePath = path.join(dir, 'session.json');
-        try {
-            const raw = fs.readFileSync(filePath, 'utf-8');
-            const session = JSON.parse(raw);
-            const age = Date.now() - new Date(session.savedAt).getTime();
-            // Only resumable if saved within 24h
-            if (age < 86400000) {
-                return {
-                    resumable: true,
-                    session: {
-                        id: session.id,
-                        savedAt: session.savedAt,
-                        turnCount: session.turnCount,
-                        messageCount: (session.messages || []).length,
-                        model: session.model,
-                    },
-                };
-            }
-        } catch { /* no session */ }
-        return { resumable: false };
-    }
-
     /**
      * Export session for teleport (transfer between machines).
      * @param {object} state - agent loop state
@@ -249,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/core/system-prompt.mjs

@@ -2,9 +2,8 @@
  * System Prompt Builder — loads and merges CLAUDE.md files.
  *
  * Features:
- * - Loads CLAUDE.md from: ~/.claude/CLAUDE.md -> parent dirs -> project root -> .claude/CLAUDE.md
- * - Supports --add-dir for extra directories
- * - Merges in order (global -> parents -> project -> local)
+ * - Loads CLAUDE.md from: ~/.claude/CLAUDE.md, project root, parent dirs
+ * - Merges in order (global -> project -> local)
  * - Splits at cache boundary (static prefix cached, dynamic suffix not)
  * - Includes tool schemas in the system prompt
  */
@@ -14,56 +13,42 @@ import os from 'os';
 
 /**
  * Load all CLAUDE.md files and merge them in order.
- * Walk up parent directories to find all relevant files.
  * @param {string} [cwd] - current working directory
- * @param {string[]} [addDirs] - additional directories to search
- * @returns {Array<{source: string, content: string, path?: string}>}
+ * @returns {string[]} Array of CLAUDE.md contents in merge order
  */
-export function loadClaudeMdFiles(cwd = process.cwd(), addDirs = []) {
+export function loadClaudeMdFiles(cwd = process.cwd()) {
     const files = [];
-    const seen = new Set();
-
-    // Helper to add a file if it exists and hasn't been seen
-    function tryAdd(filePath, source) {
-        const resolved = path.resolve(filePath);
-        if (seen.has(resolved)) return;
-        if (fs.existsSync(resolved)) {
-            try {
-                const content = fs.readFileSync(resolved, 'utf-8');
-                files.push({ source, content, path: resolved });
-                seen.add(resolved);
-            } catch { /* skip unreadable */ }
-        }
-    }
 
-    // 1. Global: ~/.claude/CLAUDE.md (lowest priority in the project chain)
-    tryAdd(path.join(os.homedir(), '.claude', 'CLAUDE.md'), 'global');
+    // 1. Global: ~/.claude/CLAUDE.md
+    const globalPath = path.join(os.homedir(), '.claude', 'CLAUDE.md');
+    if (fs.existsSync(globalPath)) {
+        try {
+            files.push({ source: 'global', content: fs.readFileSync(globalPath, 'utf-8') });
+        } catch { /* skip */ }
+    }
 
-    // 2. Walk from root down to cwd collecting CLAUDE.md files
-    //    We walk up first to collect paths, then reverse for parent-first order
-    const parentPaths = [];
+    // 2. Walk from cwd up to root, collecting CLAUDE.md files
+    const projectFiles = [];
     let dir = path.resolve(cwd);
     const root = path.parse(dir).root;
-
     while (dir !== root) {
-        parentPaths.push(dir);
+        const candidates = [
+            path.join(dir, 'CLAUDE.md'),
+            path.join(dir, '.claude', 'CLAUDE.md'),
+        ];
+        for (const f of candidates) {
+            if (fs.existsSync(f)) {
+                try {
+                    projectFiles.push({ source: dir, content: fs.readFileSync(f, 'utf-8'), path: f });
+                } catch { /* skip */ }
+            }
+        }
         dir = path.dirname(dir);
     }
 
-    // Reverse: parent dirs first, project root last (so project overrides parents)
-    parentPaths.reverse();
-
-    for (const d of parentPaths) {
-        tryAdd(path.join(d, 'CLAUDE.md'), d);
-        tryAdd(path.join(d, '.claude', 'CLAUDE.md'), d);
-    }
-
-    // 3. Additional directories from --add-dir
-    for (const addDir of addDirs) {
-        const resolved = path.resolve(addDir);
-        tryAdd(path.join(resolved, 'CLAUDE.md'), `add-dir:${resolved}`);
-        tryAdd(path.join(resolved, '.claude', 'CLAUDE.md'), `add-dir:${resolved}`);
-    }
+    // Reverse so parent dirs come first (global -> project -> local)
+    projectFiles.reverse();
+    files.push(...projectFiles);
 
     return files;
 }
@@ -75,17 +60,29 @@ export function loadClaudeMdFiles(cwd = process.cwd(), addDirs = []) {
  * @param {Array} [options.tools] - tool definitions for schema inclusion
  * @param {string} [options.override] - override system prompt entirely
  * @param {string[]} [options.addDirs] - additional directories to search for CLAUDE.md
- * @returns {{ staticPrefix: string, dynamicSuffix: string, full: string, mdFiles: Array }}
+ * @returns {{ staticPrefix: string, dynamicSuffix: string, full: string }}
  */
 export function buildSystemPrompt({ cwd, tools, override, addDirs } = {}) {
     if (override) {
-        return { staticPrefix: override, dynamicSuffix: '', full: override, mdFiles: [] };
+        return { staticPrefix: override, dynamicSuffix: '', full: override };
     }
 
     const parts = ['You are an AI coding assistant.'];
 
-    // Load CLAUDE.md files (multi-directory merge)
-    const mdFiles = loadClaudeMdFiles(cwd, addDirs || []);
+    // Load CLAUDE.md files
+    const mdFiles = loadClaudeMdFiles(cwd);
+
+    // Add additional directories
+    if (addDirs) {
+        for (const dir of addDirs) {
+            const p = path.join(dir, 'CLAUDE.md');
+            if (fs.existsSync(p)) {
+                try {
+                    mdFiles.push({ source: dir, content: fs.readFileSync(p, 'utf-8') });
+                } catch { /* skip */ }
+            }
+        }
+    }
 
     for (const f of mdFiles) {
         parts.push(f.content);
@@ -107,7 +104,6 @@ export function buildSystemPrompt({ cwd, tools, override, addDirs } = {}) {
         staticPrefix,
         dynamicSuffix,
         full: staticPrefix + dynamicSuffix,
-        mdFiles,
     };
 }
 

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

@@ -12,17 +12,16 @@
  * - 6 permission modes + sandbox
  * - Context compaction + auto-compaction
  * - Hooks system (7 events)
- * - Settings chain (4 sources, 76 properties, deep merge, write-back)
+ * - Settings chain (5 layers, 76 properties)
  * - Multi-provider support (Anthropic, OpenAI, Google)
  * - Custom agents and skills
- * - Session management with save/resume/list
- * - File checkpoints with undo
+ * - Session management and checkpoints
  * - Prompt caching
- * - 39+ slash commands (all functional)
- * - Rich TUI with cost display
+ * - 39 slash commands
  * - 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';
@@ -36,15 +35,33 @@ import { SessionManager } from './core/session.mjs';
 import { CheckpointManager } from './core/checkpoints.mjs';
 import { PromptCache } from './core/cache.mjs';
 import { readEnv } from './config/env.mjs';
-import { renderCostInline } from './ui/ink-app.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.1');
+        console.log('open-claude-code v' + JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version);
         process.exit(0);
     }
 
@@ -66,12 +83,7 @@ async function main() {
     if (args.debug) settings.debug = true;
 
     const tools = createToolRegistry();
-
-    // In print mode (-p), auto-deny by not passing rl (fail-safe)
-    const permConfig = { ...settings.permissions };
-    // rl will be set below for REPL mode
-
-    const permissions = createPermissionChecker(permConfig);
+    const permissions = createPermissionChecker(settings.permissions);
     const hooks = new HookEngine(settings.hooks);
 
     // Apply tool allow/deny lists
@@ -115,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
@@ -135,14 +164,8 @@ async function main() {
 
     telemetry.track('session.start', { model: loop.state.model });
 
-    // Graceful shutdown — save session before exit
+    // Graceful shutdown
     const cleanup = async () => {
-        // Auto-save session if there are messages
-        if (loop.state.messages.length > 0) {
-            try {
-                sessionManager.save(loop.state);
-            } catch { /* best effort */ }
-        }
         telemetry.track('session.end', {
             turns: loop.state.turnCount,
             tokens: loop.state.tokenUsage,
@@ -155,12 +178,12 @@ async function main() {
     process.on('SIGTERM', async () => { await cleanup(); process.exit(0); });
 
     if (args.prompt) {
-        // Non-interactive: run prompt and exit
-        // In print mode, permissions auto-deny (no rl passed)
+        // Non-interactive: run prompt and exit (no Ink — plain stdout)
         const outputFormat = args.outputFormat || 'text';
         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') {
@@ -187,16 +210,21 @@ async function main() {
 
         await cleanup();
     } else {
-        // Interactive REPL — check for resumable session
-        const resumable = sessionManager.checkResumable();
-        if (resumable.resumable) {
-            const s = resumable.session;
-            console.log(`\x1b[2mResumable session found: ${s.id} (${s.messageCount} messages, ${s.turnCount} turns)\x1b[0m`);
-            console.log(`\x1b[2mType /resume to restore, or start fresh.\x1b[0m`);
-        }
+        // Interactive: use Ink React TUI
+        try {
+            const { startInkApp } = await import('./ui/app.mjs');
+            const inkInstance = startInkApp(loop, settings);
 
-        const { startRepl } = await import('./ui/repl.mjs');
-        await startRepl(loop, settings, permissions);
+            // Wait for Ink to exit (user pressed Ctrl+C or /quit)
+            await inkInstance.waitUntilExit();
+        } catch (err) {
+            // Fallback to readline REPL if Ink fails (e.g. no TTY, missing deps)
+            if (settings.debug) {
+                console.error(`Ink UI unavailable (${err.message}), falling back to readline REPL`);
+            }
+            const { startRepl } = await import('./ui/repl.mjs');
+            await startRepl(loop, settings);
+        }
         await cleanup();
     }
 }