@ruvnet/open-claude-code 2.0.0 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruvnet/open-claude-code",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Open source Claude Code CLI — based on ruDevolution decompilation of v2.1.91",
   "type": "module",
   "bin": {

package/src/config/env.mjs

@@ -79,6 +79,8 @@ export const ENV_SCHEMA = {
     ANTHROPIC_AUTH_TOKEN: { type: 'string', description: 'Anthropic auth token (OAuth)' },
 
     // Extended: Sandbox & Security
+    CLAUDE_CODE_FORCE_SANDBOX: { type: 'boolean', default: false, description: 'Force sandbox for all commands' },
+    CLAUDE_CODE_BUBBLEWRAP: { type: 'boolean', default: false, description: 'Enable bubblewrap sandbox on Linux' },
     CLAUDE_CODE_SANDBOX_PLATFORM: { type: 'string', description: 'Override sandbox platform (linux/darwin)' },
     CLAUDE_CODE_INJECTION_CHECK: { type: 'boolean', default: true, description: 'Enable command injection checks' },
     CLAUDE_CODE_PATH_CHECK: { type: 'boolean', default: true, description: 'Enable file path validation' },

package/src/config/settings.mjs

@@ -3,6 +3,7 @@
  *
  * Supports all 76 properties from Claude Code's settings schema.
  * Five-layer hierarchy: user > project > local > managed > feature flags.
+ * Deep merge with source tracking and write-back.
  */
 import fs from 'fs';
 import path from 'path';
@@ -60,28 +61,101 @@ export const SETTINGS_SCHEMA = {
     featureFlags: {},
 };
 
-export async function loadSettings() {
+/** Sources in load order (first = lowest priority, last = highest) */
+const SCOPE_NAMES = ['managed', 'user', 'project', 'local'];
+
+/**
+ * Get file paths for each settings scope.
+ * @param {string} [cwd]
+ * @returns {Record<string, string>}
+ */
+export function getSettingsPaths(cwd = process.cwd()) {
+    return {
+        user: path.join(os.homedir(), '.claude', 'settings.json'),
+        project: path.join(cwd, '.claude', 'settings.json'),
+        local: path.join(cwd, '.claude', 'settings.local.json'),
+        managed: path.join(os.homedir(), '.claude', 'settings.managed.json'),
+    };
+}
+
+/**
+ * Load settings with 4-source deep merge and source tracking.
+ * Order: defaults -> managed -> user -> project -> local -> env overrides
+ * @param {string} [cwd]
+ * @returns {Promise<object>} merged settings with _sources metadata
+ */
+export async function loadSettings(cwd) {
+    const paths = getSettingsPaths(cwd);
     const chain = [
-        path.join(os.homedir(), '.claude', 'settings.json'),
-        path.join(process.cwd(), '.claude', 'settings.json'),
-        path.join(process.cwd(), '.claude', 'settings.local.json'),
+        { scope: 'managed', file: paths.managed },
+        { scope: 'user', file: paths.user },
+        { scope: 'project', file: paths.project },
+        { scope: 'local', file: paths.local },
     ];
 
     let merged = deepClone(SETTINGS_SCHEMA);
+    const sources = {};
 
-    for (const file of chain) {
+    // Track defaults
+    trackSources(sources, SETTINGS_SCHEMA, 'default', '');
+
+    for (const { scope, file } of chain) {
         try {
             const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
             merged = deepMerge(merged, data);
+            trackSources(sources, data, scope, '');
         } catch {
-            // File not found or invalid
+            // File not found or invalid — skip
         }
     }
 
-    applyEnvOverrides(merged);
+    applyEnvOverrides(merged, sources);
+
+    // Attach metadata (non-enumerable so it does not interfere with tests)
+    Object.defineProperty(merged, '_sources', { value: sources, enumerable: false, writable: true });
+    Object.defineProperty(merged, '_paths', { value: paths, enumerable: false, writable: true });
+
     return merged;
 }
 
+/**
+ * Save a single setting back to the correct scope file.
+ * @param {'user'|'project'|'local'} scope
+ * @param {string} key — dot-separated path (e.g. "permissions.defaultMode")
+ * @param {*} value
+ * @param {string} [cwd]
+ */
+export function saveSettings(scope, key, value, cwd) {
+    const paths = getSettingsPaths(cwd);
+    const file = paths[scope];
+    if (!file) throw new Error(`Unknown scope: ${scope}`);
+
+    let existing = {};
+    try {
+        existing = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    } catch {
+        // New file
+    }
+
+    setNestedValue(existing, key, value);
+
+    const dir = path.dirname(file);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(existing, null, 2) + '\n');
+}
+
+/**
+ * Get the source scope for a specific setting key.
+ * @param {object} settings — settings object returned by loadSettings
+ * @param {string} key — dot-separated path
+ * @returns {string} scope name ('default', 'user', 'project', 'local', 'managed', 'env')
+ */
+export function getSettingSource(settings, key) {
+    return settings._sources?.[key] || 'default';
+}
+
+// ---------- Helpers ----------
+
 function deepClone(obj) {
     return JSON.parse(JSON.stringify(obj));
 }
@@ -89,7 +163,8 @@ function deepClone(obj) {
 function deepMerge(target, source) {
     const result = { ...target };
     for (const [key, value] of Object.entries(source)) {
-        if (value && typeof value === 'object' && !Array.isArray(value) && typeof result[key] === 'object' && !Array.isArray(result[key])) {
+        if (value && typeof value === 'object' && !Array.isArray(value)
+            && typeof result[key] === 'object' && !Array.isArray(result[key])) {
             result[key] = deepMerge(result[key] || {}, value);
         } else {
             result[key] = value;
@@ -98,22 +173,53 @@ function deepMerge(target, source) {
     return result;
 }
 
-function applyEnvOverrides(settings) {
-    if (process.env.ANTHROPIC_MODEL) settings.model = process.env.ANTHROPIC_MODEL;
-    if (process.env.CLAUDE_CODE_SUBAGENT_MODEL) settings.subagentModel = process.env.CLAUDE_CODE_SUBAGENT_MODEL;
-    if (process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS) {
-        const n = parseInt(process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS, 10);
-        if (!isNaN(n)) { settings.maxOutputTokens = n; settings.maxTokens = n; }
+function trackSources(sources, obj, scope, prefix) {
+    for (const [key, value] of Object.entries(obj)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        sources[fullKey] = scope;
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            trackSources(sources, value, scope, fullKey);
+        }
+    }
+}
+
+function setNestedValue(obj, key, value) {
+    const parts = key.split('.');
+    let cur = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (!cur[parts[i]] || typeof cur[parts[i]] !== 'object') {
+            cur[parts[i]] = {};
+        }
+        cur = cur[parts[i]];
     }
-    if (process.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS) {
-        const n = parseInt(process.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS, 10);
-        if (!isNaN(n)) settings.maxContextTokens = n;
+    cur[parts[parts.length - 1]] = value;
+}
+
+function applyEnvOverrides(settings, sources) {
+    const envMap = [
+        ['ANTHROPIC_MODEL', (v) => { settings.model = v; }, 'model'],
+        ['CLAUDE_CODE_SUBAGENT_MODEL', (v) => { settings.subagentModel = v; }, 'subagentModel'],
+        ['CLAUDE_CODE_MAX_OUTPUT_TOKENS', (v) => {
+            const n = parseInt(v, 10);
+            if (!isNaN(n)) { settings.maxOutputTokens = n; settings.maxTokens = n; }
+        }, 'maxOutputTokens'],
+        ['CLAUDE_CODE_MAX_CONTEXT_TOKENS', (v) => {
+            const n = parseInt(v, 10);
+            if (!isNaN(n)) settings.maxContextTokens = n;
+        }, 'maxContextTokens'],
+        ['CLAUDE_CODE_BRIEF', (v) => { if (v === '1') settings.briefMode = true; }, 'briefMode'],
+        ['CLAUDE_CODE_DEBUG', (v) => { if (v === '1') settings.debugMode = true; }, 'debugMode'],
+        ['CLAUDE_CODE_PERMISSION_MODE', (v) => { settings.permissions.defaultMode = v; }, 'permissions.defaultMode'],
+        ['CLAUDE_CODE_STREAMING', (v) => { if (v === '0') settings.stream = false; }, 'stream'],
+        ['CLAUDE_CODE_THINKING', (v) => { if (v === '1') settings.alwaysThinkingEnabled = true; }, 'alwaysThinkingEnabled'],
+        ['CLAUDE_CODE_DISABLE_CRON', (v) => { if (v === '1') settings.cronEnabled = false; }, 'cronEnabled'],
+        ['CLAUDE_CODE_ENABLE_TASKS', (v) => { if (v === '1') settings.enableTeams = true; }, 'enableTeams'],
+    ];
+
+    for (const [envKey, apply, settingsKey] of envMap) {
+        if (process.env[envKey]) {
+            apply(process.env[envKey]);
+            if (sources) sources[settingsKey] = 'env';
+        }
     }
-    if (process.env.CLAUDE_CODE_BRIEF === '1') settings.briefMode = true;
-    if (process.env.CLAUDE_CODE_DEBUG === '1') settings.debugMode = true;
-    if (process.env.CLAUDE_CODE_PERMISSION_MODE) settings.permissions.defaultMode = process.env.CLAUDE_CODE_PERMISSION_MODE;
-    if (process.env.CLAUDE_CODE_STREAMING === '0') settings.stream = false;
-    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;
 }

package/src/core/session.mjs

@@ -1,8 +1,9 @@
 /**
- * Session Manager — save, resume, and teleport sessions.
+ * Session Manager — save, resume, list, 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';
@@ -31,8 +32,16 @@ export class SessionManager {
     }
 
     /**
-     * Save the current session state.
+     * 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).
      * @param {object} state - agent loop state to save
+     * @returns {string} path to saved session file
      */
     save(state) {
         const dir = this.getSessionDir();
@@ -51,28 +60,101 @@ 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;
     }
 
     /**
-     * Resume a saved session.
+     * 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.
      * @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) {
+    resume(state, sessionId) {
         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;
@@ -84,6 +166,65 @@ 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

package/src/core/system-prompt.mjs

@@ -2,8 +2,9 @@
  * System Prompt Builder — loads and merges CLAUDE.md files.
  *
  * Features:
- * - Loads CLAUDE.md from: ~/.claude/CLAUDE.md, project root, parent dirs
- * - Merges in order (global -> project -> local)
+ * - 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)
  * - Splits at cache boundary (static prefix cached, dynamic suffix not)
  * - Includes tool schemas in the system prompt
  */
@@ -13,42 +14,56 @@ 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
- * @returns {string[]} Array of CLAUDE.md contents in merge order
+ * @param {string[]} [addDirs] - additional directories to search
+ * @returns {Array<{source: string, content: string, path?: string}>}
  */
-export function loadClaudeMdFiles(cwd = process.cwd()) {
+export function loadClaudeMdFiles(cwd = process.cwd(), addDirs = []) {
     const files = [];
-
-    // 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 */ }
+    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 */ }
+        }
     }
 
-    // 2. Walk from cwd up to root, collecting CLAUDE.md files
-    const projectFiles = [];
+    // 1. Global: ~/.claude/CLAUDE.md (lowest priority in the project chain)
+    tryAdd(path.join(os.homedir(), '.claude', 'CLAUDE.md'), 'global');
+
+    // 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 = [];
     let dir = path.resolve(cwd);
     const root = path.parse(dir).root;
+
     while (dir !== root) {
-        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 */ }
-            }
-        }
+        parentPaths.push(dir);
         dir = path.dirname(dir);
     }
 
-    // Reverse so parent dirs come first (global -> project -> local)
-    projectFiles.reverse();
-    files.push(...projectFiles);
+    // 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}`);
+    }
 
     return files;
 }
@@ -60,29 +75,17 @@ export function loadClaudeMdFiles(cwd = process.cwd()) {
  * @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 }}
+ * @returns {{ staticPrefix: string, dynamicSuffix: string, full: string, mdFiles: Array }}
  */
 export function buildSystemPrompt({ cwd, tools, override, addDirs } = {}) {
     if (override) {
-        return { staticPrefix: override, dynamicSuffix: '', full: override };
+        return { staticPrefix: override, dynamicSuffix: '', full: override, mdFiles: [] };
     }
 
     const parts = ['You are an AI coding assistant.'];
 
-    // 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 */ }
-            }
-        }
-    }
+    // Load CLAUDE.md files (multi-directory merge)
+    const mdFiles = loadClaudeMdFiles(cwd, addDirs || []);
 
     for (const f of mdFiles) {
         parts.push(f.content);
@@ -104,6 +107,7 @@ export function buildSystemPrompt({ cwd, tools, override, addDirs } = {}) {
         staticPrefix,
         dynamicSuffix,
         full: staticPrefix + dynamicSuffix,
+        mdFiles,
     };
 }
 

package/src/index.mjs

@@ -12,12 +12,14 @@
  * - 6 permission modes + sandbox
  * - Context compaction + auto-compaction
  * - Hooks system (7 events)
- * - Settings chain (5 layers, 76 properties)
+ * - Settings chain (4 sources, 76 properties, deep merge, write-back)
  * - Multi-provider support (Anthropic, OpenAI, Google)
  * - Custom agents and skills
- * - Session management and checkpoints
+ * - Session management with save/resume/list
+ * - File checkpoints with undo
  * - Prompt caching
- * - 39 slash commands
+ * - 39+ slash commands (all functional)
+ * - Rich TUI with cost display
  * - Telemetry stub
  */
 
@@ -34,6 +36,7 @@ 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() {
@@ -41,7 +44,7 @@ async function main() {
 
     // Handle --version
     if (args.showVersion) {
-        console.log('open-claude-code v2.0.0-alpha.1');
+        console.log('open-claude-code v2.0.1');
         process.exit(0);
     }
 
@@ -63,7 +66,12 @@ async function main() {
     if (args.debug) settings.debug = true;
 
     const tools = createToolRegistry();
-    const permissions = createPermissionChecker(settings.permissions);
+
+    // 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 hooks = new HookEngine(settings.hooks);
 
     // Apply tool allow/deny lists
@@ -127,8 +135,14 @@ async function main() {
 
     telemetry.track('session.start', { model: loop.state.model });
 
-    // Graceful shutdown
+    // Graceful shutdown — save session before exit
     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,
@@ -142,6 +156,7 @@ async function main() {
 
     if (args.prompt) {
         // Non-interactive: run prompt and exit
+        // In print mode, permissions auto-deny (no rl passed)
         const outputFormat = args.outputFormat || 'text';
         const results = [];
 
@@ -172,9 +187,16 @@ async function main() {
 
         await cleanup();
     } else {
-        // Interactive REPL
+        // 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`);
+        }
+
         const { startRepl } = await import('./ui/repl.mjs');
-        await startRepl(loop, settings);
+        await startRepl(loop, settings, permissions);
         await cleanup();
     }
 }