@blockrun/runcode 2.4.0 → 2.5.1

package/dist/agent/commands.js

@@ -108,13 +108,16 @@ const DIRECT_COMMANDS = {
         emitDone(ctx);
     },
     '/help': (ctx) => {
+        const ultrathinkOn = ctx.config.ultrathink;
         ctx.onEvent({ kind: 'text_delta', text: `**RunCode Commands**\n\n` +
                 `  **Coding:** /commit /review /test /fix /debug /explain /search /find /refactor /scaffold\n` +
                 `  **Git:** /push /pr /undo /status /diff /log /branch /stash /unstash\n` +
                 `  **Analysis:** /security /lint /optimize /todo /deps /clean /migrate /doc\n` +
-                `  **Session:** /plan /execute /compact /retry /sessions /resume /context /tasks\n` +
-                `  **Info:** /model /wallet /cost /mcp /doctor /version /bug /help\n` +
-                `  **UI:** /clear /exit\n`
+                `  **Session:** /plan /ultraplan /execute /compact /retry /sessions /resume /context /tasks\n` +
+                `  **Power:** /ultrathink [query] /ultraplan /dump\n` +
+                `  **Info:** /model /wallet /cost /tokens /mcp /doctor /version /bug /help\n` +
+                `  **UI:** /clear /exit\n` +
+                (ultrathinkOn ? `\n  Ultrathink: ON\n` : '')
         });
         emitDone(ctx);
     },
@@ -201,6 +204,27 @@ const DIRECT_COMMANDS = {
         }
         emitDone(ctx);
     },
+    '/ultrathink': (ctx) => {
+        const cfg = ctx.config;
+        cfg.ultrathink = !cfg.ultrathink;
+        if (cfg.ultrathink) {
+            ctx.onEvent({ kind: 'text_delta', text: '**Ultrathink mode ON.** Extended reasoning active — the model will think deeply before responding.\n' +
+                    'Use `/ultrathink` again to disable, or `/ultrathink <query>` to send a one-shot deep analysis.\n'
+            });
+        }
+        else {
+            ctx.onEvent({ kind: 'text_delta', text: '**Ultrathink mode OFF.** Normal response mode restored.\n' });
+        }
+        emitDone(ctx);
+    },
+    '/dump': (ctx) => {
+        const instructions = ctx.config.systemInstructions;
+        const joined = instructions.join('\n\n---\n\n');
+        ctx.onEvent({ kind: 'text_delta', text: `**System Prompt** (${instructions.length} section${instructions.length !== 1 ? 's' : ''}):\n\n` +
+                `\`\`\`\n${joined.slice(0, 4000)}${joined.length > 4000 ? `\n... (${joined.length - 4000} chars truncated)` : ''}\n\`\`\`\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' });
@@ -264,9 +288,19 @@ const REWRITE_COMMANDS = {
     '/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.',
+    '/ultraplan': 'Enter ultraplan mode: create a detailed, step-by-step implementation plan before writing any code. ' +
+        'First, thoroughly read ALL relevant files. Map out every dependency and potential side effect. ' +
+        'Identify edge cases, security considerations, and performance implications. ' +
+        'Then produce a numbered implementation plan with specific file paths, function names, and code changes. ' +
+        'Do NOT write any code yet — only the plan.',
 };
 // Commands with arguments (prefix match → rewrite)
 const ARG_COMMANDS = [
+    { prefix: '/ultrathink ', rewrite: (a) => `Think deeply, carefully, and thoroughly before responding. ` +
+            `Consider multiple approaches, check edge cases, reason through implications step by step, ` +
+            `and challenge your initial assumptions. Take your time — quality of reasoning matters more than speed. ` +
+            `Now respond to: ${a}`
+    },
     { 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.` },

package/dist/agent/context.js

@@ -50,8 +50,9 @@ You have access to tools for reading, writing, editing files, running shell comm
 # Slash Commands Available
 The user can type these shortcuts: /commit, /review, /test, /fix, /debug, /explain <file>,
 /search <query>, /find <pattern>, /refactor <desc>, /init, /todo, /deps, /diff, /status,
-/log, /branch, /stash, /plan, /execute, /compact, /retry, /sessions, /resume, /tasks,
-/context, /doctor, /model, /cost, /clear, /help, /exit.`;
+/log, /branch, /stash, /plan, /ultraplan, /execute, /compact, /retry, /sessions, /resume,
+/tasks, /context, /doctor, /tokens, /model, /cost, /dump, /ultrathink [query], /clear,
+/help, /exit.`;
 /**
  * Build the full system instructions array for a session.
  */

package/dist/agent/loop.js

@@ -5,9 +5,9 @@
  */
 import { ModelClient } from './llm.js';
 import { autoCompactIfNeeded, microCompact } from './compact.js';
-import { estimateHistoryTokens, updateActualTokens, resetTokenAnchor } from './tokens.js';
+import { estimateHistoryTokens, updateActualTokens, resetTokenAnchor, getAnchoredTokenCount, getContextWindow } from './tokens.js';
 import { handleSlashCommand } from './commands.js';
-import { compressHistory } from '../compression/adapter.js';
+import { reduceTokens } from './reduce.js';
 import { PermissionManager } from './permissions.js';
 import { StreamingExecutor } from './streaming-executor.js';
 import { optimizeHistory, CAPPED_MAX_TOKENS, ESCALATED_MAX_TOKENS, getMaxOutputTokens } from './optimize.js';
@@ -214,6 +214,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
     // Session persistence
     const sessionId = createSessionId();
     let turnCount = 0;
+    let tokenBudgetWarned = false; // Emit token budget warning at most once per session
     pruneOldSessions(sessionId); // Cleanup old sessions on start, protect current
     while (true) {
         let input = await getUserInput();
@@ -254,23 +255,22 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 history.length = 0;
                 history.push(...optimized);
             }
-            // 2. Microcompact: only when history has >15 messages (skip for short conversations)
+            // 2. Token reduction: age old results, normalize whitespace, trim verbose messages
+            const reduced = reduceTokens(history, config.debug);
+            if (reduced !== history) {
+                history.length = 0;
+                history.push(...reduced);
+            }
+            // 3. Microcompact: only when history has >15 messages (skip for short conversations)
             if (history.length > 15) {
                 const microCompacted = microCompact(history, 8);
                 if (microCompacted !== history) {
                     history.length = 0;
                     history.push(...microCompacted);
+                    resetTokenAnchor(); // History shrunk — resync token tracking
                 }
             }
-            // 3. Context compression: 7-layer compression for 15-40% token savings
-            if (history.length > 10) {
-                const compressed = await compressHistory(history, config.debug);
-                if (compressed) {
-                    history.length = 0;
-                    history.push(...compressed.history);
-                }
-            }
-            // 4. Auto-compact: summarize history if approaching context limit
+            // 3. Auto-compact: summarize history if approaching context limit
             // Circuit breaker: stop retrying after 3 consecutive failures
             if (compactFailures < 3) {
                 try {
@@ -292,7 +292,18 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                     }
                 }
             }
-            const systemPrompt = config.systemInstructions.join('\n\n');
+            // Inject ultrathink instruction when mode is active
+            const systemParts = [...config.systemInstructions];
+            if (config.ultrathink) {
+                systemParts.push('# Ultrathink Mode\n' +
+                    'You are in deep reasoning mode. Before responding to any request:\n' +
+                    '1. Thoroughly analyze the problem from multiple angles\n' +
+                    '2. Consider edge cases, failure modes, and second-order effects\n' +
+                    '3. Challenge your initial assumptions before committing to an approach\n' +
+                    '4. Think step by step — show your reasoning explicitly when it adds value\n' +
+                    'Prioritize correctness and thoroughness over speed.');
+            }
+            const systemPrompt = systemParts.join('\n\n');
             const modelMaxOut = getMaxOutputTokens(config.model);
             let maxTokens = Math.min(maxTokensOverride ?? CAPPED_MAX_TOKENS, modelMaxOut);
             let responseParts = [];
@@ -435,6 +446,19 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                     turnCount,
                     messageCount: history.length,
                 });
+                // Token budget warning — emit once per session when crossing 70%
+                if (!tokenBudgetWarned) {
+                    const { estimated } = getAnchoredTokenCount(history);
+                    const contextWindow = getContextWindow(config.model);
+                    const pct = (estimated / contextWindow) * 100;
+                    if (pct >= 70) {
+                        tokenBudgetWarned = true;
+                        onEvent({
+                            kind: 'text_delta',
+                            text: `\n\n> **Token budget: ${pct.toFixed(0)}% used** (~${estimated.toLocaleString()} / ${(contextWindow / 1000).toFixed(0)}k tokens). Run \`/compact\` to free up space.\n`,
+                        });
+                    }
+                }
                 onEvent({ kind: 'turn_done', reason: 'completed' });
                 break;
             }

package/dist/agent/reduce.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Token Reduction for runcode.
+ * Original implementation — reduces context size through intelligent pruning.
+ *
+ * Strategy: instead of compression/encoding, we PRUNE redundant content.
+ * The model doesn't need verbose tool outputs from 20 turns ago.
+ *
+ * Three reduction passes:
+ * 1. Tool result aging — progressively shorten old tool results
+ * 2. Whitespace normalization — remove excessive blank lines and indentation
+ * 3. Stale context removal — drop system info that's been superseded
+ */
+import type { Dialogue } from './types.js';
+/**
+ * Progressively shorten tool results based on age.
+ * Recent results: keep full. Older results: keep summary. Very old: keep one line.
+ *
+ * This is the biggest token saver — a 10KB bash output from 20 turns ago
+ * can be reduced to "✓ Bash: ran npm test (exit 0)" saving ~2500 tokens.
+ */
+export declare function ageToolResults(history: Dialogue[]): Dialogue[];
+/**
+ * Normalize whitespace in text messages.
+ * - Collapse 3+ blank lines to 2
+ * - Remove trailing spaces
+ * - Reduce indentation beyond 8 spaces to 8
+ */
+export declare function normalizeWhitespace(history: Dialogue[]): Dialogue[];
+/**
+ * Trim very long assistant text messages from old turns.
+ * Recent messages: keep full. Old long messages: keep first 1000 chars.
+ */
+export declare function trimOldAssistantMessages(history: Dialogue[]): Dialogue[];
+/**
+ * Remove consecutive duplicate messages (same role + same content).
+ */
+export declare function deduplicateMessages(history: Dialogue[]): Dialogue[];
+/**
+ * Run all token reduction passes on conversation history.
+ * Returns same reference if nothing changed (cheap identity check).
+ */
+export declare function reduceTokens(history: Dialogue[], debug?: boolean): Dialogue[];

package/dist/agent/reduce.js

@@ -0,0 +1,258 @@
+/**
+ * Token Reduction for runcode.
+ * Original implementation — reduces context size through intelligent pruning.
+ *
+ * Strategy: instead of compression/encoding, we PRUNE redundant content.
+ * The model doesn't need verbose tool outputs from 20 turns ago.
+ *
+ * Three reduction passes:
+ * 1. Tool result aging — progressively shorten old tool results
+ * 2. Whitespace normalization — remove excessive blank lines and indentation
+ * 3. Stale context removal — drop system info that's been superseded
+ */
+// ─── 1. Tool Result Aging ─────────────────────────────────────────────────
+/**
+ * Progressively shorten tool results based on age.
+ * Recent results: keep full. Older results: keep summary. Very old: keep one line.
+ *
+ * This is the biggest token saver — a 10KB bash output from 20 turns ago
+ * can be reduced to "✓ Bash: ran npm test (exit 0)" saving ~2500 tokens.
+ */
+export function ageToolResults(history) {
+    // Find all tool_result positions
+    const toolPositions = [];
+    for (let i = 0; i < history.length; i++) {
+        const msg = history[i];
+        if (msg.role === 'user' &&
+            Array.isArray(msg.content) &&
+            msg.content.some(p => p.type === 'tool_result')) {
+            toolPositions.push(i);
+        }
+    }
+    if (toolPositions.length <= 3)
+        return history; // Nothing to age
+    const result = [...history];
+    const totalResults = toolPositions.length;
+    for (let idx = 0; idx < toolPositions.length; idx++) {
+        const pos = toolPositions[idx];
+        const age = totalResults - idx; // Higher = older
+        const msg = result[pos];
+        if (!Array.isArray(msg.content))
+            continue;
+        const parts = msg.content;
+        let modified = false;
+        const aged = parts.map(part => {
+            if (part.type !== 'tool_result')
+                return part;
+            const content = typeof part.content === 'string'
+                ? part.content
+                : JSON.stringify(part.content);
+            const charLen = content.length;
+            // Recent 3 results: keep full
+            if (age <= 3)
+                return part;
+            // Age 4-8: keep first 500 chars
+            if (age <= 8 && charLen > 500) {
+                modified = true;
+                const truncated = content.slice(0, 500);
+                const lastNl = truncated.lastIndexOf('\n');
+                const clean = lastNl > 250 ? truncated.slice(0, lastNl) : truncated;
+                return {
+                    ...part,
+                    content: `${clean}\n... (${charLen - clean.length} chars omitted, ${age} turns ago)`,
+                };
+            }
+            // Age 9-15: keep first 200 chars
+            if (age <= 15 && charLen > 200) {
+                modified = true;
+                const firstLine = content.split('\n')[0].slice(0, 150);
+                return {
+                    ...part,
+                    content: `${firstLine}\n... (${charLen} chars, ${age} turns ago)`,
+                };
+            }
+            // Age 16+: one line summary
+            if (age > 15 && charLen > 80) {
+                modified = true;
+                const summary = content.split('\n')[0].slice(0, 60);
+                return {
+                    ...part,
+                    content: part.is_error
+                        ? `[Error: ${summary}...]`
+                        : `[Result: ${summary}...]`,
+                };
+            }
+            return part;
+        });
+        if (modified) {
+            result[pos] = { role: 'user', content: aged };
+        }
+    }
+    return result;
+}
+// ─── 2. Whitespace Normalization ──────────────────────────────────────────
+/**
+ * Normalize whitespace in text messages.
+ * - Collapse 3+ blank lines to 2
+ * - Remove trailing spaces
+ * - Reduce indentation beyond 8 spaces to 8
+ */
+export function normalizeWhitespace(history) {
+    let modified = false;
+    const result = history.map(msg => {
+        if (typeof msg.content !== 'string')
+            return msg;
+        const original = msg.content;
+        const cleaned = original
+            .replace(/[ \t]+$/gm, '') // Trailing spaces
+            .replace(/\n{4,}/g, '\n\n\n') // Max 3 consecutive newlines
+            .replace(/^( {9,})/gm, '        '); // Cap indentation at 8 spaces
+        if (cleaned !== original) {
+            modified = true;
+            return { ...msg, content: cleaned };
+        }
+        return msg;
+    });
+    return modified ? result : history;
+}
+// ─── 3. Verbose Assistant Message Trimming ────────────────────────────────
+/**
+ * Trim very long assistant text messages from old turns.
+ * Recent messages: keep full. Old long messages: keep first 1000 chars.
+ */
+export function trimOldAssistantMessages(history) {
+    const MAX_OLD_ASSISTANT_CHARS = 1500;
+    const KEEP_RECENT = 4; // Keep last 4 assistant messages full
+    let assistantCount = 0;
+    for (const msg of history) {
+        if (msg.role === 'assistant')
+            assistantCount++;
+    }
+    if (assistantCount <= KEEP_RECENT)
+        return history;
+    let seenAssistant = 0;
+    let modified = false;
+    const result = history.map(msg => {
+        if (msg.role !== 'assistant')
+            return msg;
+        seenAssistant++;
+        // Keep recent messages full
+        if (assistantCount - seenAssistant < KEEP_RECENT)
+            return msg;
+        if (typeof msg.content === 'string' && msg.content.length > MAX_OLD_ASSISTANT_CHARS) {
+            modified = true;
+            const truncated = msg.content.slice(0, MAX_OLD_ASSISTANT_CHARS);
+            const lastNl = truncated.lastIndexOf('\n');
+            const clean = lastNl > MAX_OLD_ASSISTANT_CHARS / 2 ? truncated.slice(0, lastNl) : truncated;
+            return { ...msg, content: clean + '\n... (response truncated)' };
+        }
+        // Also handle content array with text parts
+        if (Array.isArray(msg.content)) {
+            const parts = msg.content;
+            let totalChars = 0;
+            for (const p of parts) {
+                if (p.type === 'text')
+                    totalChars += p.text.length;
+            }
+            if (totalChars > MAX_OLD_ASSISTANT_CHARS) {
+                modified = true;
+                const trimmedParts = parts.map(p => {
+                    if (p.type !== 'text' || p.text.length <= 500)
+                        return p;
+                    return { ...p, text: p.text.slice(0, 500) + '\n... (trimmed)' };
+                });
+                return { ...msg, content: trimmedParts };
+            }
+        }
+        return msg;
+    });
+    return modified ? result : history;
+}
+// ─── 4. Deduplication ────────────���────────────────────────────────────────
+/**
+ * Remove consecutive duplicate messages (same role + same content).
+ */
+export function deduplicateMessages(history) {
+    if (history.length < 3)
+        return history;
+    const result = [history[0]];
+    let modified = false;
+    for (let i = 1; i < history.length; i++) {
+        const prev = history[i - 1];
+        const curr = history[i];
+        if (curr.role === prev.role && typeof curr.content === 'string' && curr.content === prev.content) {
+            modified = true;
+            continue;
+        }
+        result.push(curr);
+    }
+    return modified ? result : history;
+}
+// ─── Pipeline ───────���───────────────────���─────────────────────────────────
+/**
+ * Run all token reduction passes on conversation history.
+ * Returns same reference if nothing changed (cheap identity check).
+ */
+export function reduceTokens(history, debug) {
+    if (history.length < 8)
+        return history; // Skip for short conversations
+    let current = history;
+    let totalSaved = 0;
+    // Pass 1: Age old tool results
+    const aged = ageToolResults(current);
+    if (aged !== current) {
+        const before = estimateChars(current);
+        current = aged;
+        const saved = before - estimateChars(current);
+        totalSaved += saved;
+    }
+    // Pass 2: Normalize whitespace
+    const normalized = normalizeWhitespace(current);
+    if (normalized !== current) {
+        const before = estimateChars(current);
+        current = normalized;
+        totalSaved += before - estimateChars(current);
+    }
+    // Pass 3: Trim old verbose assistant messages
+    const trimmed = trimOldAssistantMessages(current);
+    if (trimmed !== current) {
+        const before = estimateChars(current);
+        current = trimmed;
+        totalSaved += before - estimateChars(current);
+    }
+    // Pass 4: Remove consecutive duplicate messages
+    const deduped = deduplicateMessages(current);
+    if (deduped !== current) {
+        const before = estimateChars(current);
+        current = deduped;
+        totalSaved += before - estimateChars(current);
+    }
+    if (debug && totalSaved > 500) {
+        const tokensSaved = Math.round(totalSaved / 4);
+        console.error(`[runcode] Token reduction: ~${tokensSaved} tokens saved`);
+    }
+    return current;
+}
+function estimateChars(history) {
+    let total = 0;
+    for (const msg of history) {
+        if (typeof msg.content === 'string') {
+            total += msg.content.length;
+        }
+        else if (Array.isArray(msg.content)) {
+            for (const p of msg.content) {
+                if ('type' in p) {
+                    if (p.type === 'text')
+                        total += p.text.length;
+                    else if (p.type === 'tool_result') {
+                        total += typeof p.content === 'string' ? p.content.length : JSON.stringify(p.content).length;
+                    }
+                    else if (p.type === 'tool_use') {
+                        total += JSON.stringify(p.input).length;
+                    }
+                }
+            }
+        }
+    }
+    return total;
+}

package/dist/agent/streaming-executor.js

@@ -39,21 +39,27 @@ export class StreamingExecutor {
     async collectResults(allInvocations) {
         const results = [];
         const alreadyStarted = new Set(this.pending.map(p => p.invocation.id));
-        // Wait for concurrent results that were started during streaming
-        for (const p of this.pending) {
-            const result = await p.promise;
-            results.push([p.invocation, result]);
+        const pendingSnapshot = [...this.pending];
+        this.pending = []; // Clear immediately so errors don't leave stale state
+        try {
+            // Wait for concurrent results that were started during streaming
+            for (const p of pendingSnapshot) {
+                const result = await p.promise;
+                results.push([p.invocation, result]);
+            }
+            // Execute sequential (non-concurrent) tools now
+            for (const inv of allInvocations) {
+                if (alreadyStarted.has(inv.id))
+                    continue;
+                this.onStart(inv.id, inv.name);
+                const result = await this.executeWithPermissions(inv);
+                results.push([inv, result]);
+            }
         }
-        // Execute sequential (non-concurrent) tools now
-        for (const inv of allInvocations) {
-            if (alreadyStarted.has(inv.id))
-                continue;
-            this.onStart(inv.id, inv.name);
-            const result = await this.executeWithPermissions(inv);
-            results.push([inv, result]);
+        catch (err) {
+            // Return partial results rather than losing them; caller handles errors
+            throw err;
         }
-        // Clear for next round
-        this.pending = [];
         return results;
     }
     async executeWithPermissions(invocation) {

package/dist/agent/types.d.ts

@@ -101,4 +101,6 @@ export interface AgentConfig {
     permissionMode?: 'default' | 'trust' | 'deny-all' | 'plan';
     onEvent?: (event: StreamEvent) => void;
     debug?: boolean;
+    /** Ultrathink mode: inject deep-reasoning instruction into every prompt */
+    ultrathink?: boolean;
 }

package/dist/commands/start.js

@@ -170,7 +170,6 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
     flushStats();
     await disconnectMcpServers();
     console.log(chalk.dim('\nGoodbye.\n'));
-    process.exit(0);
 }
 // ─── Basic readline UI (piped input) ───────────────────────────────────────
 async function runWithBasicUI(agentConfig, model, workDir) {
@@ -224,7 +223,6 @@ async function runWithBasicUI(agentConfig, model, workDir) {
     }
     ui.printGoodbye();
     flushStats();
-    process.exit(0);
 }
 async function handleSlashCommand(cmd, config, ui) {
     const parts = cmd.trim().split(/\s+/);

package/dist/index.js

@@ -108,6 +108,7 @@ if (firstArg === 'solana' || firstArg === 'base') {
         }
     }
     await startCommand(startOpts);
+    process.exit(0);
 }
 else if (!firstArg || (firstArg.startsWith('-') && !['-h', '--help', '-V', '--version'].includes(firstArg))) {
     // No subcommand or only flags — treat as 'start' with flags
@@ -122,6 +123,7 @@ else if (!firstArg || (firstArg.startsWith('-') && !['-h', '--help', '-V', '--ve
         }
     }
     await startCommand(startOpts);
+    process.exit(0);
 }
 else {
     program.parse();

package/dist/tools/bash.js

@@ -12,15 +12,22 @@ async function execute(input, ctx) {
     const timeoutMs = Math.min(timeout ?? DEFAULT_TIMEOUT_MS, 600_000);
     return new Promise((resolve) => {
         const shell = process.env.SHELL || '/bin/bash';
-        const child = spawn(shell, ['-c', command], {
-            cwd: ctx.workingDir,
-            env: {
-                ...process.env,
-                RUNCODE: '1', // Let scripts detect they're running inside runcode
-                RUNCODE_WORKDIR: ctx.workingDir,
-            },
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
+        let child;
+        try {
+            child = spawn(shell, ['-c', command], {
+                cwd: ctx.workingDir,
+                env: {
+                    ...process.env,
+                    RUNCODE: '1', // Let scripts detect they're running inside runcode
+                    RUNCODE_WORKDIR: ctx.workingDir,
+                },
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        }
+        catch (spawnErr) {
+            resolve({ output: `Error spawning shell: ${spawnErr.message}`, isError: true });
+            return;
+        }
         let stdout = '';
         let stderr = '';
         let outputBytes = 0;

package/dist/ui/terminal.d.ts

@@ -10,15 +10,23 @@ export declare class TerminalUI {
     private totalInputTokens;
     private totalOutputTokens;
     private mdRenderer;
+    private lineQueue;
+    private lineWaiters;
+    private stdinEOF;
+    constructor();
     /**
      * Prompt the user for input. Returns null on EOF/exit.
+     * Uses a line-queue approach so piped input works across multiple calls.
      */
     promptUser(promptText?: string): Promise<string | null>;
+    private nextLine;
+    /** No-op kept for API compatibility — readline closes when stdin EOF. */
+    closeInput(): void;
     /**
      * Handle a stream event from the agent loop.
      */
     handleEvent(event: StreamEvent): void;
-    /** Check if input is a slash command. Returns true if handled. */
+    /** Check if input is a slash command. Returns true if handled locally (don't pass to agent). */
     handleSlashCommand(input: string): boolean;
     printWelcome(model: string, workDir: string): void;
     printUsageSummary(): void;