@blockrun/runcode 2.0.0 → 2.2.0

package/dist/agent/commands.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Slash command registry for runcode.
+ * Extracted from loop.ts for maintainability.
+ *
+ * Two types of commands:
+ * 1. "Handled" — execute directly, emit events, return { handled: true }
+ * 2. "Rewrite" — transform input into a prompt for the agent, return { handled: false, rewritten }
+ */
+import type { ModelClient } from './llm.js';
+import type { AgentConfig, Dialogue, StreamEvent } from './types.js';
+type EventEmitter = (event: StreamEvent) => void;
+interface CommandContext {
+    history: Dialogue[];
+    config: AgentConfig;
+    client: ModelClient;
+    sessionId: string;
+    onEvent: EventEmitter;
+}
+interface CommandResult {
+    handled: boolean;
+    rewritten?: string;
+}
+/**
+ * Handle a slash command. Returns result indicating what happened.
+ */
+export declare function handleSlashCommand(input: string, ctx: CommandContext): Promise<CommandResult>;
+export {};

package/dist/agent/commands.js

@@ -0,0 +1,276 @@
+/**
+ * Slash command registry for runcode.
+ * Extracted from loop.ts for maintainability.
+ *
+ * Two types of commands:
+ * 1. "Handled" — execute directly, emit events, return { handled: true }
+ * 2. "Rewrite" — transform input into a prompt for the agent, return { handled: false, rewritten }
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { BLOCKRUN_DIR, VERSION } from '../config.js';
+import { estimateHistoryTokens, getAnchoredTokenCount, getContextWindow, resetTokenAnchor } from './tokens.js';
+import { forceCompact } from './compact.js';
+import { listSessions, loadSessionHistory, } from '../session/storage.js';
+// ─── Git helpers ──────────────────────────────────────────────────────────
+function gitExec(cmd, cwd, timeout = 5000, maxBuffer) {
+    return execSync(cmd, {
+        cwd,
+        encoding: 'utf-8',
+        timeout,
+        maxBuffer: maxBuffer || 1024 * 1024,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+}
+function gitCmd(ctx, cmd, timeout, maxBuffer) {
+    try {
+        return gitExec(cmd, ctx.config.workingDir || process.cwd(), timeout, maxBuffer);
+    }
+    catch (e) {
+        ctx.onEvent({ kind: 'text_delta', text: `Git error: ${e.message?.split('\n')[0] || 'unknown'}\n` });
+        return null;
+    }
+}
+function emitDone(ctx) {
+    ctx.onEvent({ kind: 'turn_done', reason: 'completed' });
+}
+// ─── Command Definitions ──────────────────────────────────────────────────
+// Direct-handled commands (don't go to agent)
+const DIRECT_COMMANDS = {
+    '/stash': (ctx) => {
+        const r = gitCmd(ctx, 'git stash push -m "runcode auto-stash"', 10000);
+        if (r !== null)
+            ctx.onEvent({ kind: 'text_delta', text: r || 'No changes to stash.\n' });
+        emitDone(ctx);
+    },
+    '/unstash': (ctx) => {
+        const r = gitCmd(ctx, 'git stash pop', 10000);
+        if (r !== null)
+            ctx.onEvent({ kind: 'text_delta', text: r || 'Stash applied.\n' });
+        emitDone(ctx);
+    },
+    '/log': (ctx) => {
+        const r = gitCmd(ctx, 'git log --oneline -15 --no-color');
+        ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`\n${r}\n\`\`\`\n` : 'No commits or not a git repo.\n' });
+        emitDone(ctx);
+    },
+    '/status': (ctx) => {
+        const r = gitCmd(ctx, 'git status --short --branch');
+        ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`\n${r}\n\`\`\`\n` : 'Not a git repo.\n' });
+        emitDone(ctx);
+    },
+    '/diff': (ctx) => {
+        const r = gitCmd(ctx, 'git diff --stat && echo "---" && git diff', 10000, 512 * 1024);
+        ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`diff\n${r}\n\`\`\`\n` : 'No changes.\n' });
+        emitDone(ctx);
+    },
+    '/undo': (ctx) => {
+        const r = gitCmd(ctx, 'git reset --soft HEAD~1');
+        if (r !== null)
+            ctx.onEvent({ kind: 'text_delta', text: 'Last commit undone. Changes preserved in staging.\n' });
+        emitDone(ctx);
+    },
+    '/bug': (ctx) => {
+        ctx.onEvent({ kind: 'text_delta', text: 'Report issues at: https://github.com/BlockRunAI/runcode/issues\n' });
+        emitDone(ctx);
+    },
+    '/version': (ctx) => {
+        ctx.onEvent({ kind: 'text_delta', text: `RunCode v${VERSION}\n` });
+        emitDone(ctx);
+    },
+    '/mcp': async (ctx) => {
+        const { listMcpServers } = await import('../mcp/client.js');
+        const servers = listMcpServers();
+        if (servers.length === 0) {
+            ctx.onEvent({ kind: 'text_delta', text: 'No MCP servers connected.\nAdd servers to `~/.blockrun/mcp.json` or `.mcp.json` in your project.\n' });
+        }
+        else {
+            let text = `**${servers.length} MCP server(s) connected:**\n\n`;
+            for (const s of servers) {
+                text += `  **${s.name}** — ${s.toolCount} tools\n`;
+                for (const t of s.tools)
+                    text += `    · ${t}\n`;
+            }
+            ctx.onEvent({ kind: 'text_delta', text });
+        }
+        emitDone(ctx);
+    },
+    '/context': async (ctx) => {
+        const { estimated, apiAnchored } = getAnchoredTokenCount(ctx.history);
+        const contextWindow = getContextWindow(ctx.config.model);
+        const usagePct = ((estimated / contextWindow) * 100).toFixed(1);
+        ctx.onEvent({ kind: 'text_delta', text: `**Session Context**\n` +
+                `  Model:      ${ctx.config.model}\n` +
+                `  Mode:       ${ctx.config.permissionMode || 'default'}\n` +
+                `  Messages:   ${ctx.history.length}\n` +
+                `  Tokens:     ~${estimated.toLocaleString()} / ${(contextWindow / 1000).toFixed(0)}k (${usagePct}%)${apiAnchored ? ' ✓' : ' ~'}\n` +
+                `  Session:    ${ctx.sessionId}\n` +
+                `  Directory:  ${ctx.config.workingDir || process.cwd()}\n`
+        });
+        emitDone(ctx);
+    },
+    '/doctor': (ctx) => {
+        const checks = [];
+        try {
+            execSync('git --version', { stdio: 'pipe' });
+            checks.push('✓ git available');
+        }
+        catch {
+            checks.push('✗ git not found');
+        }
+        try {
+            execSync('rg --version', { stdio: 'pipe' });
+            checks.push('✓ ripgrep available');
+        }
+        catch {
+            checks.push('⚠ ripgrep not found (using native grep fallback)');
+        }
+        checks.push(fs.existsSync(path.join(BLOCKRUN_DIR, 'wallet.json')) ? '✓ wallet configured' : '⚠ no wallet — run: runcode setup');
+        checks.push(fs.existsSync(path.join(BLOCKRUN_DIR, 'runcode-config.json')) ? '✓ config file exists' : '⚠ no config — using defaults');
+        checks.push(`✓ model: ${ctx.config.model}`);
+        checks.push(`✓ history: ${ctx.history.length} messages, ~${estimateHistoryTokens(ctx.history).toLocaleString()} tokens`);
+        checks.push(`✓ session: ${ctx.sessionId}`);
+        checks.push(`✓ version: v${VERSION}`);
+        ctx.onEvent({ kind: 'text_delta', text: `**Health Check**\n${checks.map(c => '  ' + c).join('\n')}\n` });
+        emitDone(ctx);
+    },
+    '/plan': (ctx) => {
+        if (ctx.config.permissionMode === 'plan') {
+            ctx.onEvent({ kind: 'text_delta', text: 'Already in plan mode. Use /execute to exit.\n' });
+        }
+        else {
+            ctx.config.permissionMode = 'plan';
+            ctx.onEvent({ kind: 'text_delta', text: '**Plan mode active.** Tools restricted to read-only. Use /execute when ready to implement.\n' });
+        }
+        emitDone(ctx);
+    },
+    '/execute': (ctx) => {
+        if (ctx.config.permissionMode !== 'plan') {
+            ctx.onEvent({ kind: 'text_delta', text: 'Not in plan mode. Use /plan to enter.\n' });
+        }
+        else {
+            ctx.config.permissionMode = 'default';
+            ctx.onEvent({ kind: 'text_delta', text: '**Execution mode.** All tools enabled with permissions.\n' });
+        }
+        emitDone(ctx);
+    },
+    '/sessions': (ctx) => {
+        const sessions = listSessions();
+        if (sessions.length === 0) {
+            ctx.onEvent({ kind: 'text_delta', text: 'No saved sessions.\n' });
+        }
+        else {
+            let text = `**${sessions.length} saved sessions:**\n\n`;
+            for (const s of sessions.slice(0, 10)) {
+                const date = new Date(s.updatedAt).toLocaleString();
+                const dir = s.workDir ? ` — ${s.workDir.split('/').pop()}` : '';
+                text += `  ${s.id}  ${s.model}  ${s.turnCount} turns  ${date}${dir}\n`;
+            }
+            if (sessions.length > 10)
+                text += `  ... and ${sessions.length - 10} more\n`;
+            text += '\nUse /resume <session-id> to continue a session.\n';
+            ctx.onEvent({ kind: 'text_delta', text });
+        }
+        emitDone(ctx);
+    },
+    '/compact': async (ctx) => {
+        const beforeTokens = estimateHistoryTokens(ctx.history);
+        const { history: compacted, compacted: didCompact } = await forceCompact(ctx.history, ctx.config.model, ctx.client, ctx.config.debug);
+        if (didCompact) {
+            ctx.history.length = 0;
+            ctx.history.push(...compacted);
+            resetTokenAnchor();
+        }
+        const afterTokens = estimateHistoryTokens(ctx.history);
+        ctx.onEvent({ kind: 'text_delta', text: didCompact
+                ? `Compacted: ~${beforeTokens.toLocaleString()} → ~${afterTokens.toLocaleString()} tokens\n`
+                : `History too short to compact (${beforeTokens.toLocaleString()} tokens, ${ctx.history.length} messages).\n`
+        });
+        emitDone(ctx);
+    },
+};
+// Prompt-rewrite commands (transformed into agent prompts)
+const REWRITE_COMMANDS = {
+    '/commit': 'Review the current git diff and staged changes. Stage relevant files with `git add`, then create a commit with a concise message summarizing the changes. Do NOT push to remote.',
+    '/push': 'Push the current branch to the remote repository using `git push`. Show the result.',
+    '/pr': 'Create a pull request for the current branch. First check `git log --oneline main..HEAD` to see commits, then use `gh pr create` with a descriptive title and body summarizing the changes. If gh CLI is not available, show the manual steps.',
+    '/review': 'Review the current git diff. For each changed file, check for: bugs, security issues, missing error handling, performance problems, and style issues. Provide a brief summary of findings.',
+    '/fix': 'Look at the most recent error or issue we discussed and fix it. Check the relevant files, identify the root cause, and apply the fix.',
+    '/test': 'Detect the project test framework (look for package.json scripts, pytest, etc.) and run the test suite. Show a summary of results.',
+    '/debug': 'Look at the most recent error in this session. Read the relevant source files, analyze the root cause, and suggest a fix with specific code changes.',
+    '/init': 'Read the project structure: check package.json (or equivalent), README, and key config files. Summarize: what this project is, main language/framework, entry points, and how to run/test it.',
+    '/todo': 'Search the codebase for TODO, FIXME, HACK, and XXX comments using Grep. Show the results grouped by file.',
+    '/deps': 'Read the project dependency file (package.json, requirements.txt, go.mod, Cargo.toml, etc.) and list key dependencies with their versions.',
+    '/optimize': 'Analyze the codebase for performance issues. Check for: unnecessary re-renders, N+1 queries, missing indexes, unoptimized loops, large bundle sizes, and memory leaks. Provide specific recommendations.',
+    '/security': 'Audit the codebase for security issues. Check for: SQL injection, XSS, command injection, hardcoded secrets, insecure dependencies, OWASP top 10 vulnerabilities. Report findings with severity.',
+    '/lint': 'Check for code quality issues: unused imports, inconsistent naming, missing type annotations, long functions, duplicated code. Suggest improvements.',
+    '/migrate': 'Check for pending database migrations, outdated dependencies, or breaking changes that need addressing. List required migration steps.',
+    '/clean': 'Find and remove dead code: unused imports, unreachable code, commented-out blocks, unused variables and functions. Show what would be removed before making changes.',
+    '/tasks': 'List all current tasks using the Task tool.',
+};
+// Commands with arguments (prefix match → rewrite)
+const ARG_COMMANDS = [
+    { prefix: '/explain ', rewrite: (a) => `Read and explain the code in ${a}. Cover: what it does, key functions/classes, how it connects to the rest of the codebase.` },
+    { prefix: '/search ', rewrite: (a) => `Search the codebase for "${a}" using Grep. Show the matching files and relevant code context.` },
+    { prefix: '/find ', rewrite: (a) => `Find files matching the pattern "${a}" using Glob. Show the results.` },
+    { prefix: '/refactor ', rewrite: (a) => `Refactor: ${a}. Read the relevant code first, then make targeted changes. Explain each change.` },
+    { prefix: '/scaffold ', rewrite: (a) => `Create the scaffolding/boilerplate for: ${a}. Generate the file structure and initial code. Ask me if you need clarification on requirements.` },
+    { prefix: '/doc ', rewrite: (a) => `Generate documentation for ${a}. Include: purpose, API/interface description, usage examples, and important notes.` },
+];
+// ─── Main dispatch ────────────────────────────────────────────────────────
+/**
+ * Handle a slash command. Returns result indicating what happened.
+ */
+export async function handleSlashCommand(input, ctx) {
+    // Direct-handled commands
+    if (input in DIRECT_COMMANDS) {
+        await DIRECT_COMMANDS[input](ctx);
+        return { handled: true };
+    }
+    // /branch has both no-arg and with-arg forms
+    if (input === '/branch' || input.startsWith('/branch ')) {
+        const cwd = ctx.config.workingDir || process.cwd();
+        if (input === '/branch') {
+            const r = gitCmd(ctx, 'git branch -v --no-color');
+            ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`\n${r}\n\`\`\`\n` : 'Not a git repo.\n' });
+        }
+        else {
+            const branchName = input.slice(8).trim();
+            const r = gitCmd(ctx, `git checkout -b ${branchName}`);
+            if (r !== null)
+                ctx.onEvent({ kind: 'text_delta', text: `Created and switched to branch: **${branchName}**\n` });
+        }
+        emitDone(ctx);
+        return { handled: true };
+    }
+    // /resume <id>
+    if (input.startsWith('/resume ')) {
+        const targetId = input.slice(8).trim();
+        const restored = loadSessionHistory(targetId);
+        if (restored.length === 0) {
+            ctx.onEvent({ kind: 'text_delta', text: `Session "${targetId}" not found or empty.\n` });
+        }
+        else {
+            ctx.history.length = 0;
+            ctx.history.push(...restored);
+            resetTokenAnchor();
+            ctx.onEvent({ kind: 'text_delta', text: `Restored ${restored.length} messages from ${targetId}. Continue where you left off.\n` });
+        }
+        emitDone(ctx);
+        return { handled: true };
+    }
+    // Simple rewrite commands (exact match)
+    if (input in REWRITE_COMMANDS) {
+        return { handled: false, rewritten: REWRITE_COMMANDS[input] };
+    }
+    // Argument-based rewrite commands (prefix match)
+    for (const { prefix, rewrite } of ARG_COMMANDS) {
+        if (input.startsWith(prefix)) {
+            const arg = input.slice(prefix.length).trim();
+            return { handled: false, rewritten: rewrite(arg) };
+        }
+    }
+    // Not a recognized command
+    return { handled: false };
+}

package/dist/agent/compact.js

@@ -136,10 +136,11 @@ async function compactHistory(history, model, client, debug) {
  * Keeps the most recent tool exchange + the last few user/assistant turns.
  */
 function findKeepBoundary(history) {
-    // Keep at least the last 6 messages (3 turns), or ~30% of history
-    const minKeep = Math.min(6, history.length);
-    const pctKeep = Math.ceil(history.length * 0.3);
-    let keep = Math.max(minKeep, pctKeep);
+    // Keep the last 8-20 messages (absolute range, not percentage)
+    // Prevents "never compacts" bug when history grows large
+    const minKeep = Math.min(8, history.length);
+    const maxKeep = Math.min(20, history.length - 1);
+    let keep = Math.max(minKeep, Math.min(maxKeep, Math.ceil(history.length * 0.3)));
     // Make sure we don't split in the middle of a tool exchange
     // (assistant with tool_use must be followed by user with tool_result)
     while (keep < history.length) {

package/dist/agent/llm.js

@@ -129,7 +129,12 @@ export class ModelClient {
                         try {
                             parsedInput = JSON.parse(currentToolInput || '{}');
                         }
-                        catch { /* empty */ }
+                        catch (parseErr) {
+                            // Log malformed JSON instead of silently defaulting to {}
+                            if (this.debug) {
+                                console.error(`[runcode] Malformed tool input JSON for ${currentToolName}: ${parseErr.message}`);
+                            }
+                        }
                         const toolInvocation = {
                             type: 'tool_use',
                             id: currentToolId,
@@ -289,8 +294,11 @@ export class ModelClient {
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true });
-                // Safety: if buffer grows too large without newlines, truncate
+                // Safety: if buffer grows too large without newlines, something is wrong
                 if (buffer.length > MAX_BUFFER) {
+                    if (this.debug) {
+                        console.error(`[runcode] SSE buffer overflow (${(buffer.length / 1024).toFixed(0)}KB) — truncating to prevent OOM`);
+                    }
                     buffer = buffer.slice(-MAX_BUFFER / 2);
                 }
                 const lines = buffer.split('\n');

package/dist/agent/loop.js

@@ -4,17 +4,15 @@
  * Original implementation with different architecture from any reference codebase.
  */
 import { ModelClient } from './llm.js';
-import { autoCompactIfNeeded, forceCompact, microCompact } from './compact.js';
+import { autoCompactIfNeeded, microCompact } from './compact.js';
 import { estimateHistoryTokens, updateActualTokens, resetTokenAnchor } from './tokens.js';
+import { handleSlashCommand } from './commands.js';
 import { PermissionManager } from './permissions.js';
 import { StreamingExecutor } from './streaming-executor.js';
 import { optimizeHistory, CAPPED_MAX_TOKENS, ESCALATED_MAX_TOKENS } from './optimize.js';
 import { recordUsage } from '../stats/tracker.js';
 import { estimateCost } from '../pricing.js';
-import fs from 'node:fs';
-import path from 'node:path';
-import { BLOCKRUN_DIR, VERSION } from '../config.js';
-import { createSessionId, appendToSession, updateSessionMeta, pruneOldSessions, listSessions, loadSessionHistory, } from '../session/storage.js';
+import { createSessionId, appendToSession, updateSessionMeta, pruneOldSessions, } from '../session/storage.js';
 // ─── Main Entry Point ──────────────────────────────────────────────────────
 /**
  * Run the agent loop.
@@ -215,385 +213,22 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
     // Session persistence
     const sessionId = createSessionId();
     let turnCount = 0;
-    pruneOldSessions(); // Cleanup old sessions on start
+    pruneOldSessions(sessionId); // Cleanup old sessions on start, protect current
     while (true) {
         let input = await getUserInput();
         if (input === null)
             break; // User wants to exit
         if (input === '')
             continue; // Empty input → re-prompt
-        // Handle /stash and /unstash — git stash management
-        if (input === '/stash') {
-            try {
-                const { execSync } = await import('node:child_process');
-                const result = execSync('git stash push -m "runcode auto-stash"', {
-                    cwd: config.workingDir || process.cwd(), encoding: 'utf-8', timeout: 10000
-                }).trim();
-                onEvent({ kind: 'text_delta', text: result || 'No changes to stash.\n' });
-            }
-            catch (e) {
-                onEvent({ kind: 'text_delta', text: `Stash error: ${e.message?.split('\n')[0]}\n` });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        if (input === '/unstash') {
-            try {
-                const { execSync } = await import('node:child_process');
-                const result = execSync('git stash pop', {
-                    cwd: config.workingDir || process.cwd(), encoding: 'utf-8', timeout: 10000
-                }).trim();
-                onEvent({ kind: 'text_delta', text: result || 'Stash applied.\n' });
-            }
-            catch (e) {
-                onEvent({ kind: 'text_delta', text: `Unstash error: ${e.message?.split('\n')[0]}\n` });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /branch — show current branch or create new
-        if (input === '/branch' || input.startsWith('/branch ')) {
-            try {
-                const { execSync } = await import('node:child_process');
-                const cwd = config.workingDir || process.cwd();
-                if (input === '/branch') {
-                    const branches = execSync('git branch -v --no-color', { cwd, encoding: 'utf-8', timeout: 5000 }).trim();
-                    onEvent({ kind: 'text_delta', text: `\`\`\`\n${branches}\n\`\`\`\n` });
-                }
-                else {
-                    const branchName = input.slice(8).trim();
-                    execSync(`git checkout -b ${branchName}`, { cwd, encoding: 'utf-8', timeout: 5000 });
-                    onEvent({ kind: 'text_delta', text: `Created and switched to branch: **${branchName}**\n` });
-                }
-            }
-            catch (e) {
-                onEvent({ kind: 'text_delta', text: `Git error: ${e.message?.split('\n')[0] || 'unknown'}\n` });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /log — show recent git log
-        if (input === '/log') {
-            try {
-                const { execSync } = await import('node:child_process');
-                const log = execSync('git log --oneline -15 --no-color', {
-                    cwd: config.workingDir || process.cwd(), encoding: 'utf-8', timeout: 5000
-                }).trim();
-                onEvent({ kind: 'text_delta', text: log ? `\`\`\`\n${log}\n\`\`\`\n` : 'No commits.\n' });
-            }
-            catch {
-                onEvent({ kind: 'text_delta', text: 'Not a git repo.\n' });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /mcp — show connected MCP servers
-        if (input === '/mcp') {
-            const { listMcpServers } = await import('../mcp/client.js');
-            const servers = listMcpServers();
-            if (servers.length === 0) {
-                onEvent({ kind: 'text_delta', text: 'No MCP servers connected.\nAdd servers to `~/.blockrun/mcp.json` or `.mcp.json` in your project.\n' });
-            }
-            else {
-                let text = `**${servers.length} MCP server(s) connected:**\n\n`;
-                for (const s of servers) {
-                    text += `  **${s.name}** — ${s.toolCount} tools\n`;
-                    for (const t of s.tools) {
-                        text += `    · ${t}\n`;
-                    }
-                }
-                onEvent({ kind: 'text_delta', text });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /bug — open issue tracker
-        if (input === '/bug') {
-            onEvent({ kind: 'text_delta', text: 'Report issues at: https://github.com/BlockRunAI/runcode/issues\n' });
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /version — show version
-        if (input === '/version') {
-            onEvent({ kind: 'text_delta', text: `RunCode v${VERSION}\n` });
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /tasks — show task list (shortcut for Task list action)
-        if (input === '/tasks') {
-            input = 'List all current tasks using the Task tool.';
-        }
-        // Handle /doctor — diagnose setup issues
-        if (input === '/doctor') {
-            const checks = [];
-            const { execSync } = await import('node:child_process');
-            // Check git
-            try {
-                execSync('git --version', { stdio: 'pipe' });
-                checks.push('✓ git available');
-            }
-            catch {
-                checks.push('✗ git not found');
-            }
-            // Check rg
-            try {
-                execSync('rg --version', { stdio: 'pipe' });
-                checks.push('✓ ripgrep available');
-            }
-            catch {
-                checks.push('⚠ ripgrep not found (using native grep fallback)');
-            }
-            // Check wallet
-            const walletFile = path.join(BLOCKRUN_DIR, 'wallet.json');
-            checks.push(fs.existsSync(walletFile) ? '✓ wallet configured' : '⚠ no wallet — run: runcode setup');
-            // Check config
-            const configFile = path.join(BLOCKRUN_DIR, 'runcode-config.json');
-            checks.push(fs.existsSync(configFile) ? '✓ config file exists' : '⚠ no config — using defaults');
-            // Model & tokens
-            checks.push(`✓ model: ${config.model}`);
-            checks.push(`✓ history: ${history.length} messages, ~${estimateHistoryTokens(history).toLocaleString()} tokens`);
-            checks.push(`✓ session: ${sessionId}`);
-            checks.push(`✓ version: v${VERSION}`);
-            onEvent({ kind: 'text_delta', text: `**Health Check**\n${checks.map(c => '  ' + c).join('\n')}\n` });
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /commit — rewrite as a prompt for the agent
-        if (input === '/commit') {
-            input = 'Review the current git diff and staged changes. Stage relevant files with `git add`, then create a commit with a concise message summarizing the changes. Do NOT push to remote.';
-        }
-        // Handle /undo — undo last commit (keep changes)
-        if (input === '/undo') {
-            try {
-                const { execSync } = await import('node:child_process');
-                const result = execSync('git reset --soft HEAD~1', {
-                    cwd: config.workingDir || process.cwd(), encoding: 'utf-8', timeout: 5000
-                }).trim();
-                onEvent({ kind: 'text_delta', text: result || 'Last commit undone. Changes preserved in staging.\n' });
-            }
-            catch (e) {
-                onEvent({ kind: 'text_delta', text: `Undo error: ${e.message?.split('\n')[0]}\n` });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /push — push to remote
-        if (input === '/push') {
-            input = 'Push the current branch to the remote repository using `git push`. Show the result.';
-        }
-        // Handle /pr — create pull request
-        if (input === '/pr') {
-            input = 'Create a pull request for the current branch. First check `git log --oneline main..HEAD` to see commits, then use `gh pr create` with a descriptive title and body summarizing the changes. If gh CLI is not available, show the manual steps.';
-        }
-        // Handle /review — ask agent to review current changes
-        if (input === '/review') {
-            input = 'Review the current git diff. For each changed file, check for: bugs, security issues, missing error handling, performance problems, and style issues. Provide a brief summary of findings.';
-        }
-        // Handle /fix — ask agent to fix the last error or issue
-        if (input === '/fix') {
-            input = 'Look at the most recent error or issue we discussed and fix it. Check the relevant files, identify the root cause, and apply the fix.';
-        }
-        // Handle /test — run project tests
-        if (input === '/test') {
-            input = 'Detect the project test framework (look for package.json scripts, pytest, etc.) and run the test suite. Show a summary of results.';
-        }
-        // Handle /explain <file> — explain code
-        if (input.startsWith('/explain ')) {
-            const target = input.slice(9).trim();
-            input = `Read and explain the code in ${target}. Cover: what it does, key functions/classes, how it connects to the rest of the codebase.`;
-        }
-        // Handle /search <query> — search codebase
-        if (input.startsWith('/search ')) {
-            const query = input.slice(8).trim();
-            input = `Search the codebase for "${query}" using Grep. Show the matching files and relevant code context.`;
-        }
-        // Handle /find <pattern> — find files
-        if (input.startsWith('/find ')) {
-            const pattern = input.slice(6).trim();
-            input = `Find files matching the pattern "${pattern}" using Glob. Show the results.`;
-        }
-        // Handle /refactor <description> — code refactoring
-        if (input.startsWith('/refactor ')) {
-            const desc = input.slice(10).trim();
-            input = `Refactor: ${desc}. Read the relevant code first, then make targeted changes. Explain each change.`;
-        }
-        // Handle /debug — analyze recent error
-        if (input === '/debug') {
-            input = 'Look at the most recent error in this session. Read the relevant source files, analyze the root cause, and suggest a fix with specific code changes.';
-        }
-        // Handle /init — initialize project context
-        if (input === '/init') {
-            input = 'Read the project structure: check package.json (or equivalent), README, and key config files. Summarize: what this project is, main language/framework, entry points, and how to run/test it.';
-        }
-        // Handle /todo — find TODOs in codebase
-        if (input === '/todo') {
-            input = 'Search the codebase for TODO, FIXME, HACK, and XXX comments using Grep. Show the results grouped by file.';
-        }
-        // Handle /deps — show project dependencies
-        if (input === '/deps') {
-            input = 'Read the project dependency file (package.json, requirements.txt, go.mod, Cargo.toml, etc.) and list key dependencies with their versions.';
-        }
-        // Handle /scaffold <desc> — generate boilerplate
-        if (input.startsWith('/scaffold ')) {
-            const desc = input.slice(10).trim();
-            input = `Create the scaffolding/boilerplate for: ${desc}. Generate the file structure and initial code. Ask me if you need clarification on requirements.`;
-        }
-        // Handle /optimize — performance optimization
-        if (input === '/optimize') {
-            input = 'Analyze the codebase for performance issues. Check for: unnecessary re-renders, N+1 queries, missing indexes, unoptimized loops, large bundle sizes, and memory leaks. Provide specific recommendations.';
-        }
-        // Handle /security — security audit
-        if (input === '/security') {
-            input = 'Audit the codebase for security issues. Check for: SQL injection, XSS, command injection, hardcoded secrets, insecure dependencies, OWASP top 10 vulnerabilities. Report findings with severity.';
-        }
-        // Handle /lint — code quality
-        if (input === '/lint') {
-            input = 'Check for code quality issues: unused imports, inconsistent naming, missing type annotations, long functions, duplicated code. Suggest improvements.';
-        }
-        // Handle /doc <target> — generate documentation
-        if (input.startsWith('/doc ')) {
-            const target = input.slice(5).trim();
-            input = `Generate documentation for ${target}. Include: purpose, API/interface description, usage examples, and important notes.`;
-        }
-        // Handle /migrate — migration helper
-        if (input === '/migrate') {
-            input = 'Check for pending database migrations, outdated dependencies, or breaking changes that need addressing. List required migration steps.';
-        }
-        // Handle /clean — cleanup dead code
-        if (input === '/clean') {
-            input = 'Find and remove dead code: unused imports, unreachable code, commented-out blocks, unused variables and functions. Show what would be removed before making changes.';
-        }
-        // Handle /status — show git status
-        if (input === '/status') {
-            try {
-                const { execSync } = await import('node:child_process');
-                const status = execSync('git status --short --branch', {
-                    cwd: config.workingDir || process.cwd(),
-                    encoding: 'utf-8',
-                    timeout: 5_000,
-                }).trim();
-                onEvent({ kind: 'text_delta', text: status ? `\`\`\`\n${status}\n\`\`\`\n` : 'No git status.\n' });
-            }
-            catch {
-                onEvent({ kind: 'text_delta', text: 'Not a git repo.\n' });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /diff — show git diff of current changes
-        if (input === '/diff') {
-            try {
-                const { execSync } = await import('node:child_process');
-                const diff = execSync('git diff --stat && echo "---" && git diff', {
-                    cwd: config.workingDir || process.cwd(),
-                    encoding: 'utf-8',
-                    timeout: 10_000,
-                    maxBuffer: 512 * 1024,
-                }).trim();
-                onEvent({ kind: 'text_delta', text: diff ? `\`\`\`diff\n${diff}\n\`\`\`\n` : 'No changes.\n' });
-            }
-            catch {
-                onEvent({ kind: 'text_delta', text: 'Not a git repository or git not available.\n' });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /context — show current session context info
-        if (input === '/context') {
-            const { getAnchoredTokenCount, getContextWindow } = await import('./tokens.js');
-            const { estimated, apiAnchored } = getAnchoredTokenCount(history);
-            const contextWindow = getContextWindow(config.model);
-            const usagePct = ((estimated / contextWindow) * 100).toFixed(1);
-            const msgs = history.length;
-            const model = config.model;
-            const dir = config.workingDir || process.cwd();
-            const mode = config.permissionMode || 'default';
-            onEvent({ kind: 'text_delta', text: `**Session Context**\n` +
-                    `  Model:      ${model}\n` +
-                    `  Mode:       ${mode}\n` +
-                    `  Messages:   ${msgs}\n` +
-                    `  Tokens:     ~${estimated.toLocaleString()} / ${(contextWindow / 1000).toFixed(0)}k (${usagePct}%)${apiAnchored ? ' ✓' : ' ~'}\n` +
-                    `  Session:    ${sessionId}\n` +
-                    `  Directory:  ${dir}\n`
+        // ── Slash command dispatch ──
+        if (input.startsWith('/')) {
+            const cmdResult = await handleSlashCommand(input, {
+                history, config, client, sessionId, onEvent,
             });
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /plan — enter plan mode (restrict to read-only tools)
-        if (input === '/plan') {
-            if (config.permissionMode === 'plan') {
-                onEvent({ kind: 'text_delta', text: 'Already in plan mode. Use /execute to exit.\n' });
-            }
-            else {
-                config.permissionMode = 'plan';
-                onEvent({ kind: 'text_delta', text: '**Plan mode active.** Tools restricted to read-only. Use /execute when ready to implement.\n' });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /execute — exit plan mode
-        if (input === '/execute') {
-            if (config.permissionMode !== 'plan') {
-                onEvent({ kind: 'text_delta', text: 'Not in plan mode. Use /plan to enter.\n' });
-            }
-            else {
-                config.permissionMode = 'default';
-                onEvent({ kind: 'text_delta', text: '**Execution mode.** All tools enabled with permissions.\n' });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /sessions — list saved sessions
-        if (input === '/sessions') {
-            const sessions = listSessions();
-            if (sessions.length === 0) {
-                onEvent({ kind: 'text_delta', text: 'No saved sessions.\n' });
-            }
-            else {
-                let text = `**${sessions.length} saved sessions:**\n\n`;
-                for (const s of sessions.slice(0, 10)) {
-                    const date = new Date(s.updatedAt).toLocaleString();
-                    const dir = s.workDir ? ` — ${s.workDir.split('/').pop()}` : '';
-                    text += `  ${s.id}  ${s.model}  ${s.turnCount} turns  ${date}${dir}\n`;
-                }
-                if (sessions.length > 10)
-                    text += `  ... and ${sessions.length - 10} more\n`;
-                text += '\nUse /resume <session-id> to continue a session.\n';
-                onEvent({ kind: 'text_delta', text });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /resume <id> — restore session history
-        if (input.startsWith('/resume ')) {
-            const targetId = input.slice(8).trim();
-            const restored = loadSessionHistory(targetId);
-            if (restored.length === 0) {
-                onEvent({ kind: 'text_delta', text: `Session "${targetId}" not found or empty.\n` });
-            }
-            else {
-                history.length = 0;
-                history.push(...restored);
-                onEvent({ kind: 'text_delta', text: `Restored ${restored.length} messages from ${targetId}. Continue where you left off.\n` });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /compact command — force compaction without sending to model
-        if (input === '/compact') {
-            const beforeTokens = estimateHistoryTokens(history);
-            const { history: compacted, compacted: didCompact } = await forceCompact(history, config.model, client, config.debug);
-            if (didCompact) {
-                history.length = 0;
-                history.push(...compacted);
-            }
-            const afterTokens = estimateHistoryTokens(history);
-            onEvent({ kind: 'text_delta', text: didCompact
-                    ? `Compacted: ~${beforeTokens.toLocaleString()} → ~${afterTokens.toLocaleString()} tokens\n`
-                    : `History too short to compact (${beforeTokens.toLocaleString()} tokens, ${history.length} messages).\n`
-            });
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
+            if (cmdResult.handled)
+                continue;
+            if (cmdResult.rewritten)
+                input = cmdResult.rewritten;
         }
         history.push({ role: 'user', content: input });
         appendToSession(sessionId, { role: 'user', content: input });
@@ -635,7 +270,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             }
             const systemPrompt = config.systemInstructions.join('\n\n');
             let maxTokens = maxTokensOverride ?? CAPPED_MAX_TOKENS;
-            let responseParts;
+            let responseParts = [];
             let usage;
             let stopReason;
             // Create streaming executor for concurrent tool execution
@@ -672,6 +307,11 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             catch (err) {
                 // ── User abort (Esc key) ──
                 if (err.name === 'AbortError' || abort.signal.aborted) {
+                    // Save any partial response that was streamed before abort
+                    if (responseParts && responseParts.length > 0) {
+                        history.push({ role: 'assistant', content: responseParts });
+                        appendToSession(sessionId, { role: 'assistant', content: responseParts });
+                    }
                     onEvent({ kind: 'turn_done', reason: 'aborted' });
                     break;
                 }

package/dist/agent/optimize.js

@@ -49,7 +49,12 @@ export function budgetToolResults(history) {
             // Per-tool cap
             if (size > MAX_TOOL_RESULT_CHARS) {
                 modified = true;
-                const preview = content.slice(0, PREVIEW_CHARS);
+                // Truncate at line boundary for cleaner output
+                let preview = content.slice(0, PREVIEW_CHARS);
+                const lastNewline = preview.lastIndexOf('\n');
+                if (lastNewline > PREVIEW_CHARS * 0.5) {
+                    preview = preview.slice(0, lastNewline);
+                }
                 budgeted.push({
                     type: 'tool_result',
                     tool_use_id: part.tool_use_id,
@@ -59,15 +64,13 @@ export function budgetToolResults(history) {
                 messageTotal += PREVIEW_CHARS + 200;
                 continue;
             }
-            // Per-message aggregate cap
+            // Per-message aggregate cap — once exceeded, truncate remaining results
             if (messageTotal + size > MAX_TOOL_RESULTS_PER_MESSAGE_CHARS) {
                 modified = true;
-                const remaining = Math.max(0, MAX_TOOL_RESULTS_PER_MESSAGE_CHARS - messageTotal);
-                const preview = content.slice(0, Math.min(PREVIEW_CHARS, remaining));
                 budgeted.push({
                     type: 'tool_result',
                     tool_use_id: part.tool_use_id,
-                    content: `[Output omitted: message budget exceeded (${MAX_TOOL_RESULTS_PER_MESSAGE_CHARS / 1000}K chars/msg)]\n\n${preview}`,
+                    content: `[Output omitted: message budget exceeded (${MAX_TOOL_RESULTS_PER_MESSAGE_CHARS / 1000}K chars/msg)]`,
                     is_error: part.is_error,
                 });
                 messageTotal = MAX_TOOL_RESULTS_PER_MESSAGE_CHARS;

package/dist/agent/tokens.js

@@ -23,19 +23,26 @@ export function updateActualTokens(inputTokens, outputTokens, messageCount) {
  * More accurate than pure estimation because it's grounded in actual API counts.
  */
 export function getAnchoredTokenCount(history) {
-    if (lastApiInputTokens > 0 && history.length >= lastApiMessageCount) {
-        // Anchor to API count, estimate only new messages
-        const newMessages = history.slice(lastApiMessageCount);
-        let newTokens = 0;
-        for (const msg of newMessages) {
-            newTokens += estimateDialogueTokens(msg);
+    if (lastApiInputTokens > 0 && lastApiMessageCount > 0 && history.length >= lastApiMessageCount) {
+        // Sanity check: if history was mutated (compaction, micro-compact), anchor may be stale.
+        // Detect by checking if new messages were only appended (length grew), not if content changed.
+        // If history grew by more than expected (e.g., resume injected many messages), fall through to estimation.
+        const growth = history.length - lastApiMessageCount;
+        if (growth <= 20) { // Reasonable growth since last API call
+            const newMessages = history.slice(lastApiMessageCount);
+            let newTokens = 0;
+            for (const msg of newMessages) {
+                newTokens += estimateDialogueTokens(msg);
+            }
+            const total = lastApiInputTokens + newTokens;
+            return {
+                estimated: total,
+                apiAnchored: true,
+                contextUsagePct: 0,
+            };
         }
-        const total = lastApiInputTokens + newTokens;
-        return {
-            estimated: total,
-            apiAnchored: true,
-            contextUsagePct: 0, // Will be calculated by caller with model context window
-        };
+        // Too much growth — anchor is unreliable, fall through to estimation
+        resetTokenAnchor();
     }
     // No anchor — pure estimation
     return {

package/dist/mcp/client.d.ts

@@ -27,6 +27,7 @@ export interface McpConfig {
 }
 /**
  * Connect to all configured MCP servers and return discovered tools.
+ * Each connection has a 5s timeout to avoid blocking startup.
  */
 export declare function connectMcpServers(config: McpConfig, debug?: boolean): Promise<CapabilityHandler[]>;
 /**

package/dist/mcp/client.js

@@ -21,7 +21,17 @@ async function connectStdio(name, config) {
         env: { ...process.env, ...(config.env || {}) },
     });
     const client = new Client({ name: `runcode-mcp-${name}`, version: '1.0.0' }, { capabilities: {} });
-    await client.connect(transport);
+    try {
+        await client.connect(transport);
+    }
+    catch (err) {
+        // Clean up transport if connect fails to prevent resource leak
+        try {
+            await transport.close();
+        }
+        catch { /* ignore */ }
+        throw err;
+    }
     // Discover tools
     const { tools: mcpTools } = await client.listTools();
     const capabilities = [];
@@ -38,11 +48,12 @@ async function connectStdio(name, config) {
                 },
             },
             execute: async (input, _ctx) => {
+                const MCP_TOOL_TIMEOUT = 30_000;
                 try {
-                    const result = await client.callTool({
-                        name: tool.name,
-                        arguments: input,
-                    });
+                    // Timeout protection: if tool hangs, don't block the agent forever
+                    const callPromise = client.callTool({ name: tool.name, arguments: input });
+                    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`MCP tool timeout after ${MCP_TOOL_TIMEOUT / 1000}s`)), MCP_TOOL_TIMEOUT));
+                    const result = await Promise.race([callPromise, timeoutPromise]);
                     // Extract text content from MCP response
                     const output = result.content
                         ?.filter(c => c.type === 'text')
@@ -70,6 +81,11 @@ async function connectStdio(name, config) {
 /**
  * Connect to all configured MCP servers and return discovered tools.
  */
+const MCP_CONNECT_TIMEOUT = 5_000; // 5s per server connection
+/**
+ * Connect to all configured MCP servers and return discovered tools.
+ * Each connection has a 5s timeout to avoid blocking startup.
+ */
 export async function connectMcpServers(config, debug) {
     const allTools = [];
     for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
@@ -79,17 +95,16 @@ export async function connectMcpServers(config, debug) {
             if (debug) {
                 console.error(`[runcode] Connecting to MCP server: ${name}...`);
             }
-            let connected;
-            if (serverConfig.transport === 'stdio') {
-                connected = await connectStdio(name, serverConfig);
-            }
-            else {
-                // HTTP transport — TODO: implement SSE/HTTP transport
+            if (serverConfig.transport !== 'stdio') {
                 if (debug) {
                     console.error(`[runcode] MCP HTTP transport not yet supported for ${name}`);
                 }
                 continue;
             }
+            // Timeout: don't let a slow server block startup
+            const connectPromise = connectStdio(name, serverConfig);
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('connection timeout (5s)')), MCP_CONNECT_TIMEOUT));
+            const connected = await Promise.race([connectPromise, timeoutPromise]);
             allTools.push(...connected.tools);
             if (debug) {
                 console.error(`[runcode] MCP ${name}: ${connected.tools.length} tools discovered`);

package/dist/mcp/config.d.ts

@@ -5,10 +5,6 @@
  * 2. Project: .mcp.json in working directory
  */
 import type { McpConfig, McpServerConfig } from './client.js';
-/**
- * Load MCP server configurations from global + project files.
- * Project config overrides global for same server name.
- */
 export declare function loadMcpConfig(workDir: string): McpConfig;
 /**
  * Save a server config to the global MCP config.
@@ -18,3 +14,7 @@ export declare function saveMcpServer(name: string, config: McpServerConfig): vo
  * Remove a server from the global MCP config.
  */
 export declare function removeMcpServer(name: string): boolean;
+/**
+ * Trust a project directory to load its .mcp.json.
+ */
+export declare function trustProjectDir(workDir: string): void;

package/dist/mcp/config.js

@@ -12,8 +12,18 @@ const GLOBAL_MCP_FILE = path.join(BLOCKRUN_DIR, 'mcp.json');
  * Load MCP server configurations from global + project files.
  * Project config overrides global for same server name.
  */
+// Built-in MCP server: @blockrun/mcp is always available (zero config)
+const BUILTIN_MCP_SERVERS = {
+    blockrun: {
+        transport: 'stdio',
+        command: 'npx',
+        args: ['-y', '@blockrun/mcp'],
+        label: 'BlockRun (built-in)',
+    },
+};
 export function loadMcpConfig(workDir) {
-    const servers = {};
+    // Start with built-in servers
+    const servers = { ...BUILTIN_MCP_SERVERS };
     // 1. Global config
     try {
         if (fs.existsSync(GLOBAL_MCP_FILE)) {
@@ -27,14 +37,28 @@ export function loadMcpConfig(workDir) {
         // Ignore corrupt global config
     }
     // 2. Project config (.mcp.json in working directory)
+    // Security: project configs can execute arbitrary commands via stdio transport.
+    // Only load if a trust marker exists (user has explicitly opted in).
     const projectMcpFile = path.join(workDir, '.mcp.json');
+    const trustMarker = path.join(BLOCKRUN_DIR, 'trusted-projects.json');
     try {
         if (fs.existsSync(projectMcpFile)) {
-            const raw = JSON.parse(fs.readFileSync(projectMcpFile, 'utf-8'));
-            if (raw.mcpServers && typeof raw.mcpServers === 'object') {
-                // Project overrides global for same name
-                Object.assign(servers, raw.mcpServers);
+            // Check if this project directory is trusted
+            let trusted = false;
+            try {
+                if (fs.existsSync(trustMarker)) {
+                    const trustedDirs = JSON.parse(fs.readFileSync(trustMarker, 'utf-8'));
+                    trusted = Array.isArray(trustedDirs) && trustedDirs.includes(workDir);
+                }
+            }
+            catch { /* not trusted */ }
+            if (trusted) {
+                const raw = JSON.parse(fs.readFileSync(projectMcpFile, 'utf-8'));
+                if (raw.mcpServers && typeof raw.mcpServers === 'object') {
+                    Object.assign(servers, raw.mcpServers);
+                }
             }
+            // If not trusted, silently skip project config (user must run /mcp trust)
         }
     }
     catch {
@@ -62,6 +86,24 @@ export function removeMcpServer(name) {
     fs.writeFileSync(GLOBAL_MCP_FILE, JSON.stringify(existing, null, 2) + '\n');
     return true;
 }
+/**
+ * Trust a project directory to load its .mcp.json.
+ */
+export function trustProjectDir(workDir) {
+    const trustMarker = path.join(BLOCKRUN_DIR, 'trusted-projects.json');
+    let trusted = [];
+    try {
+        if (fs.existsSync(trustMarker)) {
+            trusted = JSON.parse(fs.readFileSync(trustMarker, 'utf-8'));
+        }
+    }
+    catch { /* fresh */ }
+    if (!trusted.includes(workDir)) {
+        trusted.push(workDir);
+        fs.mkdirSync(BLOCKRUN_DIR, { recursive: true });
+        fs.writeFileSync(trustMarker, JSON.stringify(trusted, null, 2));
+    }
+}
 function loadGlobalMcpConfig() {
     try {
         if (fs.existsSync(GLOBAL_MCP_FILE)) {

package/dist/session/storage.d.ts

@@ -39,4 +39,8 @@ export declare function listSessions(): SessionMeta[];
 /**
  * Prune old sessions beyond MAX_SESSIONS.
  */
-export declare function pruneOldSessions(): void;
+/**
+ * Prune old sessions beyond MAX_SESSIONS.
+ * Accepts optional activeSessionId to protect from deletion.
+ */
+export declare function pruneOldSessions(activeSessionId?: string): void;

package/dist/session/storage.js

@@ -67,7 +67,17 @@ export function loadSessionHistory(sessionId) {
     try {
         const content = fs.readFileSync(sessionPath(sessionId), 'utf-8');
         const lines = content.trim().split('\n').filter(Boolean);
-        return lines.map(line => JSON.parse(line));
+        const results = [];
+        for (const line of lines) {
+            try {
+                results.push(JSON.parse(line));
+            }
+            catch {
+                // Skip corrupted lines — partial writes from crashes
+                continue;
+            }
+        }
+        return results;
     }
     catch {
         return [];
@@ -98,11 +108,17 @@ export function listSessions() {
 /**
  * Prune old sessions beyond MAX_SESSIONS.
  */
-export function pruneOldSessions() {
+/**
+ * Prune old sessions beyond MAX_SESSIONS.
+ * Accepts optional activeSessionId to protect from deletion.
+ */
+export function pruneOldSessions(activeSessionId) {
     const sessions = listSessions();
     if (sessions.length <= MAX_SESSIONS)
         return;
-    const toDelete = sessions.slice(MAX_SESSIONS);
+    const toDelete = sessions
+        .slice(MAX_SESSIONS)
+        .filter(s => s.id !== activeSessionId); // Never delete active session
     for (const s of toDelete) {
         try {
             fs.unlinkSync(sessionPath(s.id));

package/dist/tools/askuser.js

@@ -32,7 +32,7 @@ async function execute(input, _ctx) {
         });
         rl.on('close', () => {
             if (!answered)
-                resolve({ output: '(user skipped)' });
+                resolve({ output: 'User did not respond (EOF/piped input).', isError: true });
         });
     });
 }

package/dist/tools/glob.js

@@ -21,7 +21,7 @@ function globMatch(pattern, text) {
     return regex.test(text.replace(/\\/g, '/'));
 }
 function walkDirectory(dir, baseDir, pattern, results, depth, visited) {
-    if (depth > 20 || results.length >= MAX_RESULTS)
+    if (depth > 50 || results.length >= MAX_RESULTS)
         return;
     // Symlink loop protection
     const visitedSet = visited ?? new Set();

package/dist/tools/imagegen.js

@@ -70,8 +70,11 @@ async function execute(input, ctx) {
             fs.writeFileSync(outPath, buffer);
         }
         else if (imageData.url) {
-            // Download from URL
-            const imgResp = await fetch(imageData.url);
+            // Download from URL (with 30s timeout)
+            const dlCtrl = new AbortController();
+            const dlTimeout = setTimeout(() => dlCtrl.abort(), 30_000);
+            const imgResp = await fetch(imageData.url, { signal: dlCtrl.signal });
+            clearTimeout(dlTimeout);
             const buffer = Buffer.from(await imgResp.arrayBuffer());
             fs.mkdirSync(path.dirname(outPath), { recursive: true });
             fs.writeFileSync(outPath, buffer);

package/dist/tools/read.js

@@ -33,7 +33,7 @@ async function execute(input, ctx) {
         }
         const raw = fs.readFileSync(resolved, 'utf-8');
         const allLines = raw.split('\n');
-        const startLine = Math.max(0, (offset ?? 1) - 1);
+        const startLine = Math.max(0, (Math.max(1, offset ?? 1)) - 1);
         const maxLines = limit ?? 2000;
         const endLine = Math.min(allLines.length, startLine + maxLines);
         const slice = allLines.slice(startLine, endLine);

package/dist/tools/write.js

@@ -40,6 +40,16 @@ async function execute(input, ctx) {
         }
     }
     catch { /* parent doesn't exist yet, will be created */ }
+    // Also check if target file itself is a symlink to a sensitive location
+    try {
+        if (fs.existsSync(resolved) && fs.lstatSync(resolved).isSymbolicLink()) {
+            const realTarget = fs.realpathSync(resolved);
+            if (checkPath(realTarget)) {
+                return { output: `Error: refusing to write — symlink resolves to sensitive location: ${realTarget}`, isError: true };
+            }
+        }
+    }
+    catch { /* file doesn't exist yet, ok */ }
     try {
         // Ensure parent directory exists
         const parentDir = path.dirname(resolved);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/runcode",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "RunCode — AI coding agent powered by 41+ models. Pay per use with USDC.",
   "type": "module",
   "bin": {