@beunec/rivine 0.3.1 → 0.3.2

package/dist/api/workspace.js

@@ -11,6 +11,14 @@
 import { createHash } from 'node:crypto';
 import { MEDIATOR_MODE, TARGET_ENGINE, apiUrl } from '../config.js';
 import { accessToken } from '../auth/session.js';
+export class TurnBusy extends Error {
+    detail;
+    constructor(detail) {
+        super(detail);
+        this.detail = detail;
+        this.name = 'TurnBusy';
+    }
+}
 export class InsufficientCredits extends Error {
     detail;
     constructor(detail) {
@@ -101,6 +109,10 @@ export async function openTurn(req) {
         const body = (await res.json().catch(() => ({})));
         throw new InsufficientCredits(body.error ?? 'Not enough credits for Rivine Code.');
     }
+    if (res.status === 409) {
+        const body = (await res.json().catch(() => ({})));
+        throw new TurnBusy(String(body.detail ?? body.error ?? 'A turn is already in progress.'));
+    }
     if (!res.ok) {
         const body = await res.text().catch(() => '');
         throw new Error(`The engine refused this turn (HTTP ${res.status}). ${body.slice(0, 300)}`);

package/dist/index.js

@@ -261,6 +261,9 @@ mcp
 function collect(value, previous) {
     return [...previous, value];
 }
+function onBusyOption(value) {
+    return value === 'follow' || value === 'stop' ? value : 'fail';
+}
 program
     .argument('[prompt...]', 'send one prompt and exit')
     .option('-p, --print <prompt>', 'send one prompt, print the answer, and exit')
@@ -270,6 +273,7 @@ program
     .option('--bypass', 'never ask for approval — for CI only, on a machine you are willing to have changed')
     .option('-C, --cwd <dir>', 'run against a different directory')
     .option('--output-format <format>', 'text | json — json puts one object on stdout and everything else on stderr', 'text')
+    .option('--on-busy <policy>', 'if an earlier turn on this project is still running: follow | stop | fail (default fail)')
     .action(async (prompt, options) => {
     const requested = options.cwd ? resolvePath(options.cwd) : process.cwd();
     const cwd = await realpath(requested).catch(() => requested);
@@ -297,7 +301,7 @@ program
             process.exitCode = 2;
             return;
         }
-        process.exitCode = await runHeadless({ cwd, mode, codeMode, prompt: oneShot, format });
+        process.exitCode = await runHeadless({ cwd, mode, codeMode, prompt: oneShot, format, onBusy: onBusyOption(options.onBusy) });
         return;
     }
     if (format === 'json' && oneShot) {
@@ -308,7 +312,7 @@ program
             process.exitCode = 2;
             return;
         }
-        process.exitCode = await runHeadless({ cwd, mode, codeMode, prompt: oneShot, format });
+        process.exitCode = await runHeadless({ cwd, mode, codeMode, prompt: oneShot, format, onBusy: onBusyOption(options.onBusy) });
         return;
     }
     const { waitUntilExit } = render(React.createElement(App, {

package/dist/protocol/fsExecutor.js

@@ -8,14 +8,42 @@
  * accompanying it; it is not open source and is not licensed for
  * redistribution or derivative works.
  */
-import { spawnSync } from 'node:child_process';
-import { mkdir, readFile, readdir, realpath, stat, writeFile, } from 'node:fs/promises';
+import { execFile, spawnSync } from 'node:child_process';
+import { mkdir, readFile, readdir, realpath, stat, unlink, writeFile, } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { promisify } from 'node:util';
 import { runShell } from './shell.js';
 import { applyEdit, describeFailure, writeFileAtomic } from './edit.js';
 import { decide } from './permissions.js';
 const VIRTUAL_ROOT = '/workspace';
 const MAX_READ_BYTES = 2 * 1024 * 1024;
+const IMAGE_FILE = /\.(png|jpe?g|gif|webp|heic|heif|bmp|tiff?)$/i;
+const IMAGE_CONVERT_ALWAYS = /\.(heic|heif|bmp|tiff?)$/i;
+const IMAGE_SEND_BYTES = 1_500_000;
+const execFileP = promisify(execFile);
+export async function shrinkImage(path) {
+    const out = join(tmpdir(), `rivine-img-${process.pid}-${Date.now()}.jpg`);
+    const attempts = [];
+    if (process.platform === 'darwin')
+        attempts.push(['sips', ['-s', 'format', 'jpeg', '-Z', '1600', path, '--out', out]]);
+    attempts.push(['magick', [path, '-resize', '1600x1600>', '-quality', '85', out]]);
+    attempts.push(['convert', [path, '-resize', '1600x1600>', '-quality', '85', out]]);
+    for (const [cmd, args] of attempts) {
+        try {
+            await execFileP(cmd, args, { timeout: 30_000 });
+            const buf = await readFile(out);
+            if (buf.length)
+                return buf;
+        }
+        catch {
+        }
+        finally {
+            await unlink(out).catch(() => undefined);
+        }
+    }
+    return null;
+}
 const SKIP_DIRS = new Set([
     'node_modules', '.git', 'dist', 'build', '.next', '.turbo', '.venv', 'venv',
     '__pycache__', '.mypy_cache', '.pytest_cache', 'target', '.cache', 'coverage',
@@ -307,6 +335,12 @@ export async function execute(root, request, hooks = {}) {
                 const info = await stat(target.absolute);
                 if (info.isDirectory())
                     return { ok: false, error: 'is_directory' };
+                if (IMAGE_FILE.test(target.absolute)
+                    && (info.size > IMAGE_SEND_BYTES || IMAGE_CONVERT_ALWAYS.test(target.absolute))) {
+                    const small = await shrinkImage(target.absolute);
+                    if (small)
+                        return { ok: true, data: { content: small.toString('base64'), encoding: 'base64' } };
+                }
                 if (info.size > MAX_READ_BYTES) {
                     return {
                         ok: false,

package/dist/protocol/permissions.js

@@ -104,6 +104,96 @@ const ALWAYS_ASK_COMMANDS = [
     { pattern: /curl[^|]*\|\s*(sudo\s+)?(ba)?sh|wget[^|]*\|\s*(sudo\s+)?(ba)?sh/, reason: 'pipes a download into a shell' },
     { pattern: /:\(\)\s*\{.*\|.*&.*\}/, reason: 'fork bomb' },
 ];
+const IRREVERSIBLE_COMMANDS = [
+    { pattern: /\bgit\s+push\b[^\n;&|]*(--force\b|--force-with-lease\b|\s-f\b|\s\+[\w./-]+)/, reason: 'force-pushes, rewriting history others may have' },
+    { pattern: /\bgit\s+push\b[^\n;&|]*(--delete\b|\s-d\b|\s:[\w./-]+)/, reason: 'deletes a remote branch' },
+    { pattern: /\bgh\s+repo\s+delete\b/, reason: 'deletes a GitHub repository' },
+    { pattern: /\baws\s+[\w-]+\s+(delete|terminate|remove|purge|deregister|disable-key|schedule-key-deletion)[\w-]*/, reason: 'deletes or disables AWS resources' },
+    { pattern: /\baws\s+s3\s+(rm|rb)\b/, reason: 'deletes S3 objects or buckets' },
+    { pattern: /\baws\s+s3\s+sync\b[^\n;&|]*--delete\b/, reason: 'deletes S3 objects missing from the source' },
+    { pattern: /\bgcloud\b[^\n;&|]*\s(delete|destroy)\b/, reason: 'deletes Google Cloud resources' },
+    { pattern: /\bwrangler\s+(delete\b|secret\s+(put|delete|bulk)\b|r2\s+(bucket|object)\s+delete\b|kv\s+\S+\s+delete\b|d1\s+delete\b|queues\s+delete\b)/, reason: 'deletes Cloudflare resources or writes a secret' },
+    { pattern: /\bsupabase\s+(db\s+(reset|push)\b|projects\s+delete\b|branches\s+delete\b)/, reason: 'resets, overwrites or deletes a Supabase database or project' },
+    { pattern: /\bterraform\s+(destroy\b|apply\b[^\n;&|]*-destroy\b)/, reason: 'destroys infrastructure' },
+    { pattern: /\bkubectl\s+delete\b/, reason: 'deletes cluster resources' },
+    { pattern: /\bheroku\s+(apps:destroy|pg:reset)\b|\bfly\s+(apps\s+destroy|volumes\s+destroy)\b|\bvercel\s+remove\b/, reason: 'destroys a hosted app or its data' },
+    { pattern: /\b(DROP\s+(TABLE|DATABASE|SCHEMA|ROLE)|TRUNCATE\s+(TABLE\s+)?[\w."]+)/i, reason: 'drops or empties database data' },
+    { pattern: /\bDELETE\s+FROM\s+[\w."]+\s*(;|'|"|$)/i, reason: 'deletes every row of a table' },
+    { pattern: /\bprisma\s+(migrate\s+reset\b|db\s+push\b[^\n;&|]*--force-reset\b)/, reason: 'wipes the database' },
+    { pattern: /\b(redis-cli|valkey-cli)\b[^\n;&|]*\b(FLUSHALL|FLUSHDB)\b/i, reason: 'empties a Redis database' },
+    { pattern: /\bdocker\s+(volume\s+(rm|prune)\b|system\s+prune\b[^\n;&|]*(\s-a\b|--all\b|--volumes\b))/, reason: 'deletes Docker volumes (data)' },
+    { pattern: /\bdocker(-compose|\s+compose)\s+down\b[^\n;&|]*(\s-v\b|--volumes\b)/, reason: 'deletes Docker Compose volumes (data)' },
+    { pattern: /\bmkfs(\.\w+)?\b|\bdd\s+[^\n;&|]*\bof=\/dev\//, reason: 'overwrites a disk' },
+    { pattern: /\bfind\s+(\/|~|\$HOME)\S*\s[^\n;&|]*-delete\b/, reason: 'deletes files across the disk or home folder' },
+];
+const DANGEROUS_RM_EXACT = new Set([
+    '/', '/*', '~', '~/', '~/*', '$HOME', '$HOME/', '${HOME}', '${HOME}/', '.', './', '*', './*',
+    '/workspace', '/workspace/', '/workspace/*',
+]);
+const SYSTEM_DIRS = /^\/(etc|usr|bin|sbin|var|lib|lib64|boot|dev|proc|sys|opt|srv|root|System|Library|Applications|private|Volumes|home|Users)(\/[^/]*)?\/?$/;
+const HOME_CLEANUP = /^(~|\$HOME|\$\{HOME\})\/(\.cache|\.npm|\.pnpm-store|\.yarn\/cache|\.cargo\/registry|\.gradle\/caches|\.m2\/repository|Library\/Caches|Library\/Developer\/Xcode\/DerivedData|Library\/Logs|\.Trash)(\/|$)/;
+const RM_RECURSIVE_OR_FORCE = /^-[a-zA-Z]*[rRf][a-zA-Z]*$|^--(recursive|force)$/;
+const SEGMENT_SPLIT = /\|\||&&|[;|\n]/;
+function words(segment) {
+    const out = [];
+    const re = /'([^']*)'|"([^"]*)"|(\S+)/g;
+    let m;
+    while ((m = re.exec(segment)) !== null)
+        out.push(m[1] ?? m[2] ?? m[3] ?? '');
+    return out;
+}
+function rmProblem(command) {
+    for (const segment of command.split(SEGMENT_SPLIT)) {
+        let argv = words(segment);
+        while (argv.length && (['sudo', 'command', 'nohup', 'time'].includes(argv[0]) || argv[0].includes('='))) {
+            argv = argv.slice(1);
+        }
+        if (!argv.length || argv[0].replace(/^.*\//, '') !== 'rm')
+            continue;
+        const args = argv.slice(1);
+        if (!args.some((a) => a.startsWith('-') && RM_RECURSIVE_OR_FORCE.test(a)))
+            continue;
+        for (const target of args.filter((a) => !a.startsWith('-'))) {
+            const t = target.replace(/\/+$/, '') || '/';
+            if (DANGEROUS_RM_EXACT.has(target) || DANGEROUS_RM_EXACT.has(t) || SYSTEM_DIRS.test(t) || t === '..' || t.startsWith('../')) {
+                return `deletes '${target}', a whole disk, home folder, project or system folder`;
+            }
+            if (/^(~|\$HOME|\$\{HOME\})(\/|$)/.test(t) && !HOME_CLEANUP.test(t)) {
+                return `deletes '${target}' in the home folder (only caches there are cleanup)`;
+            }
+        }
+    }
+    return null;
+}
+export function irreversibleCommand(command) {
+    for (const { pattern, reason } of IRREVERSIBLE_COMMANDS) {
+        if (pattern.test(command))
+            return reason;
+    }
+    return rmProblem(command);
+}
+const SECRET_READERS = new Set([
+    'cat', 'head', 'tail', 'less', 'more', 'grep', 'rg', 'ag', 'sed', 'awk', 'bat', 'strings', 'xxd', 'od',
+    'base64', 'cp', 'jq', 'source', '.', 'sort', 'cut', 'tac', 'nl',
+]);
+export function commandReadsSecret(command) {
+    for (const segment of command.split(SEGMENT_SPLIT)) {
+        const argv = words(segment.trim());
+        if (!argv.length)
+            continue;
+        const head = argv[0].replace(/^.*\//, '');
+        if ((head === 'env' && argv.length === 1) || head === 'printenv') {
+            return 'prints every environment variable, which usually include credentials';
+        }
+        if (!SECRET_READERS.has(head))
+            continue;
+        const secret = argv.slice(1).find((a) => !a.startsWith('-') && isSecretPath(a.replace(/^\.\//, '')));
+        if (secret)
+            return `${secret} looks like it holds credentials — reading it would send them to the model`;
+    }
+    return null;
+}
+const ALLOW_DESTRUCTIVE = Boolean(process.env.RIVINE_ALLOW_DESTRUCTIVE);
 const SHELL_CHAINING = /[;&|]|\$\(|`|>>|>|<\(/;
 const AGENT_METADATA_DIR = /^\.rivine(\/|$)/;
 export function isAgentMetadataPath(relPath) {
@@ -187,6 +277,20 @@ export function decide(input) {
             reason: `${relPath ?? 'this path'} is outside the project directory`,
         };
     }
+    if (op === 'execute' && command) {
+        const irreversible = irreversibleCommand(command);
+        if (irreversible && !(mode === 'bypass' && ALLOW_DESTRUCTIVE)) {
+            return {
+                verdict: 'ask',
+                category: 'destructive',
+                reason: `${irreversible} — this cannot be undone` +
+                    (mode === 'bypass' ? ' (set RIVINE_ALLOW_DESTRUCTIVE=1 to allow these without asking)' : ''),
+            };
+        }
+        const secretRead = commandReadsSecret(command);
+        if (secretRead)
+            return { verdict: 'ask', category: 'secret', reason: secretRead };
+    }
     if (mode === 'bypass')
         return { verdict: 'allow' };
     if (relPath && isSecretPath(relPath)) {

package/dist/protocol/runner.js

@@ -8,7 +8,7 @@
  * accompanying it; it is not open source and is not licensed for
  * redistribution or derivative works.
  */
-import { cancelTurn, closeSession, getTurnStatus, openTurn, postFsResult, resumeTurn } from '../api/workspace.js';
+import { cancelTurn, closeSession, getTurnStatus, openTurn, postFsResult, resumeTurn, TurnBusy } from '../api/workspace.js';
 import { apiUrl } from '../config.js';
 import { accessToken } from '../auth/session.js';
 import { classify, execute } from './fsExecutor.js';
@@ -19,6 +19,11 @@ import { readTurnStream } from './stream.js';
 import { displayStage } from '../ui/render.js';
 const PENDING_POLL_MS = 1200;
 const FOLLOW_POLL_MS = Number(process.env.RIVINE_FOLLOW_POLL_MS) || 3000;
+export function busyChoice(policy, message) {
+    if (policy !== 'auto')
+        return policy;
+    return /^\s*(continue|go on|keep going|resume|carry on)\b[\s.!]*$/i.test(message) ? 'follow' : 'stop';
+}
 export function writtenPaths(request) {
     const args = (request.args ?? {});
     let paths = [];
@@ -105,7 +110,7 @@ export class TurnRunner {
                 (selection.skipped.length ? ` (not needed: ${selection.skipped.join(', ')})` : ''));
         }
         try {
-            const response = await openTurn({
+            const request = {
                 workspaceId: this.ctx.workspaceId,
                 chatSpaceId: this.ctx.chatSpaceId,
                 sessionId: this.ctx.sessionId,
@@ -120,7 +125,31 @@ export class TurnRunner {
                     input_schema,
                 })),
                 sessionKey: this.key.toBase64(),
-            });
+            };
+            let response;
+            try {
+                response = await openTurn(request);
+            }
+            catch (err) {
+                if (!(err instanceof TurnBusy))
+                    throw err;
+                const choice = busyChoice(this.ctx.onBusy ?? 'auto', message);
+                if (choice === 'fail') {
+                    return {
+                        answer: '',
+                        cancelled: false,
+                        error: `${err.detail} Re-run with --on-busy follow to wait for it, or --on-busy stop to stop it and send this.`,
+                    };
+                }
+                if (choice === 'follow') {
+                    this.cb.onNotice('Your previous request is still running on the server — following it.');
+                    return await this.follow('');
+                }
+                this.cb.onNotice('Your previous request is still running on the server — stopping it and sending this one.');
+                await cancelTurn(this.ctx.workspaceId, this.ctx.chatSpaceId);
+                await this.waitUntilIdle();
+                response = await openTurn(request);
+            }
             return await this.consume(response);
         }
         finally {
@@ -130,85 +159,110 @@ export class TurnRunner {
             await Promise.allSettled([...this.inFlight]);
         }
     }
+    async waitUntilIdle(maxMs = 30_000) {
+        const until = Date.now() + maxMs;
+        while (Date.now() < until) {
+            try {
+                const status = await getTurnStatus(this.ctx.workspaceId, this.ctx.chatSpaceId);
+                if (status.status !== 'running')
+                    return;
+            }
+            catch {
+            }
+            await new Promise((r) => setTimeout(r, 1500));
+        }
+    }
+    async stop() {
+        this.stopped = true;
+        await cancelTurn(this.ctx.workspaceId, this.ctx.chatSpaceId);
+    }
     async consume(response) {
         let answer = '';
         let pendingHitl = null;
         let continuing = false;
-        for await (const event of readTurnStream(response)) {
-            switch (event.type) {
-                case 'token':
-                    answer += event.content ?? '';
-                    this.cb.onToken(event.content ?? '');
-                    break;
-                case 'stage': {
-                    const label = displayStage(String(event.label ?? ''));
-                    if (label)
-                        this.cb.onStage(label);
-                    break;
-                }
-                case 'tool_call_start': {
-                    const e = event;
-                    const detail = e.args?.command ?? e.args?.filename ?? '';
-                    this.cb.onTool(String(e.name ?? 'tool'), String(detail));
-                    break;
-                }
-                case 'file_diff': {
-                    const e = event;
-                    const path = String(e.path ?? '').trim();
-                    if (!path)
+        try {
+            for await (const event of readTurnStream(response)) {
+                switch (event.type) {
+                    case 'token':
+                        answer += event.content ?? '';
+                        this.cb.onToken(event.content ?? '');
                         break;
-                    this.cb.onFileDiff?.({
-                        path: path.replace(/^\/workspace\/?/, ''),
-                        stat: String(e.stat ?? ''),
-                        patch: String(e.patch ?? ''),
-                        added: Number(e.added ?? 0),
-                        removed: Number(e.removed ?? 0),
-                        isNew: Boolean(e.is_new),
-                        isDelete: Boolean(e.is_delete),
-                        binary: Boolean(e.binary),
-                    });
-                    break;
-                }
-                case 'code_file': {
-                    const e = event;
-                    const path = String(e.path ?? '').trim();
-                    const rel = path.replace(/^\/workspace\/?/, '');
-                    if (!rel || rel === '.' || rel.endsWith('/'))
+                    case 'stage': {
+                        const label = displayStage(String(event.label ?? ''));
+                        if (label)
+                            this.cb.onStage(label);
+                        break;
+                    }
+                    case 'tool_call_start': {
+                        const e = event;
+                        const detail = e.args?.command ?? e.args?.filename ?? '';
+                        this.cb.onTool(String(e.name ?? 'tool'), String(detail));
+                        break;
+                    }
+                    case 'file_diff': {
+                        const e = event;
+                        const path = String(e.path ?? '').trim();
+                        if (!path)
+                            break;
+                        this.cb.onFileDiff?.({
+                            path: path.replace(/^\/workspace\/?/, ''),
+                            stat: String(e.stat ?? ''),
+                            patch: String(e.patch ?? ''),
+                            added: Number(e.added ?? 0),
+                            removed: Number(e.removed ?? 0),
+                            isNew: Boolean(e.is_new),
+                            isDelete: Boolean(e.is_delete),
+                            binary: Boolean(e.binary),
+                        });
+                        break;
+                    }
+                    case 'code_file': {
+                        const e = event;
+                        const path = String(e.path ?? '').trim();
+                        const rel = path.replace(/^\/workspace\/?/, '');
+                        if (!rel || rel === '.' || rel.endsWith('/'))
+                            break;
+                        this.cb.onFileTouched(path, e.status);
+                        break;
+                    }
+                    case 'fs_request':
+                        this.dispatch(event);
+                        break;
+                    case 'approval_request': {
+                        const e = event;
+                        pendingHitl = {
+                            message: String(e.message ?? 'Approval required.'),
+                            tool: e.tool ? String(e.tool) : undefined,
+                            options: extractOptions(e),
+                            multi: Boolean(e.ui_schema?.multi ?? e.args?.multi),
+                            threadId: String(e.thread_id ?? `${this.ctx.workspaceId}_${this.ctx.chatSpaceId}`),
+                            kind: hitlKind(e.hitl_type, e.args),
+                        };
+                        break;
+                    }
+                    case 'final_answer':
+                        answer = String(event.content ?? answer);
+                        break;
+                    case 'turn_continuing':
+                        continuing = true;
+                        break;
+                    case 'error': {
+                        const e = event;
+                        return { answer, cancelled: Boolean(e.cancelled), error: String(e.content ?? 'Unknown error') };
+                    }
+                    case 'done':
+                        break;
+                    default:
                         break;
-                    this.cb.onFileTouched(path, e.status);
-                    break;
-                }
-                case 'fs_request':
-                    this.dispatch(event);
-                    break;
-                case 'approval_request': {
-                    const e = event;
-                    pendingHitl = {
-                        message: String(e.message ?? 'Approval required.'),
-                        tool: e.tool ? String(e.tool) : undefined,
-                        options: extractOptions(e),
-                        multi: Boolean(e.ui_schema?.multi ?? e.args?.multi),
-                        threadId: String(e.thread_id ?? `${this.ctx.workspaceId}_${this.ctx.chatSpaceId}`),
-                        kind: hitlKind(e.hitl_type, e.args),
-                    };
-                    break;
-                }
-                case 'final_answer':
-                    answer = String(event.content ?? answer);
-                    break;
-                case 'turn_continuing':
-                    continuing = true;
-                    break;
-                case 'error': {
-                    const e = event;
-                    return { answer, cancelled: Boolean(e.cancelled), error: String(e.content ?? 'Unknown error') };
                 }
-                case 'done':
-                    break;
-                default:
-                    break;
             }
         }
+        catch (err) {
+            if (this.stopped)
+                throw err;
+            this.cb.onNotice(`The connection to this turn dropped (${err.message}); following it on the server…`);
+            return this.follow(answer);
+        }
         if (pendingHitl) {
             const settled = await this.settleHitl(pendingHitl, answer);
             if (isFollowSignal(settled))

package/dist/protocol/shell.js

@@ -104,8 +104,8 @@ function shellInvocation(command) {
     }
     return { file: process.env.SHELL || '/bin/sh', args: ['-c', command] };
 }
-function agentEnv() {
-    return { ...process.env, GIT_PAGER: 'cat', PAGER: 'cat', GIT_TERMINAL_PROMPT: '0' };
+export function agentEnv() {
+    return { ...process.env, CI: process.env.CI || '1', GIT_PAGER: 'cat', PAGER: 'cat', GIT_TERMINAL_PROMPT: '0' };
 }
 function runWithPty(pty, command, options) {
     const { file, args } = shellInvocation(command);

package/dist/runHeadless.js

@@ -59,6 +59,7 @@ export async function runHeadless(options) {
             root: options.cwd,
             mode: options.mode,
             codeMode: options.codeMode,
+            onBusy: options.onBusy ?? 'fail',
         }, {
             onToken: (text) => out.token(text),
             onStage: (label) => out.status(label),

package/dist/ui/App.js

@@ -213,6 +213,10 @@ export function App({ cwd, initialMode, askForMode, initialCodeMode, oneShot })
                 push('system', `Rate: ${describeMode('bypass')}`);
                 push('notice', 'Accept-edits is gone — Bypass applies in-project edits without asking.');
                 return true;
+            case '/stop':
+                push('system', 'Stopping any turn still running on the server…');
+                void runnerRef.current?.stop().then(() => push('system', 'Stopped.'));
+                return true;
             case '/credits':
                 openBrowser(`${siteUrl()}/credits`);
                 push('system', `Opened ${siteUrl()}/credits`);
@@ -536,6 +540,11 @@ export function App({ cwd, initialMode, askForMode, initialCodeMode, oneShot })
             push('notice', 'Stopped the running command.');
             return;
         }
+        if (key.escape && phase === 'running') {
+            push('notice', 'Stopping this turn…');
+            void runnerRef.current?.stop();
+            return;
+        }
         if (key.ctrl && ch === 'c')
             quit();
     }, { isActive: phase === 'ready' || phase === 'running' });

package/dist/ui/headless.js

@@ -73,7 +73,11 @@ export class HeadlessRenderer {
     refuseApproval(approval) {
         const fix = this.mode === 'plan'
             ? 'plan mode makes no changes; re-run without --plan'
-            : 'no terminal to ask on — re-run with --rate bypass';
+            : approval.category === 'destructive'
+                ? 'cannot be undone and there is no terminal to confirm on — run it yourself, or set RIVINE_ALLOW_DESTRUCTIVE=1'
+                : approval.category === 'secret'
+                    ? 'would send credentials to the model and there is no terminal to confirm on'
+                    : 'no terminal to ask on — re-run with --rate bypass';
         this.refused += 1;
         this.line('notice', `Skipped: ${approval.summary}`);
         this.line('notice', `  ${approval.reason} (${fix})`);

package/dist/ui/slashCommands.js

@@ -30,6 +30,11 @@ export const SLASH_COMMANDS = [
         summary: 'switch Rate to Bypass',
         detail: 'Accept-edits is gone; Bypass applies in-project edits without asking.',
     },
+    {
+        name: '/stop',
+        summary: 'stop a turn still running on the server',
+        detail: 'While a turn runs, Esc does the same (when no command is running; Esc first stops the command).',
+    },
     { name: '/status', summary: 'account, project, Mode, Rate and balance' },
     { name: '/diff', summary: 'what changed in the working tree' },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beunec/rivine",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Rivine Code in your terminal — Beunec's software engineering runtime constructs, working on the files you already have open.",
   "license": "UNLICENSED",
   "author": "Beunec Technologies",