@thegitai/cli 1.0.0-preview.15 → 1.0.0-preview.17

package/dist/src/tools/run-node-script.js

@@ -1,5 +1,6 @@
 import chalk from '../colors.js';
 import { execFileSync, spawn } from 'node:child_process';
+import { ensurePermission } from '../permissions.js';
 import { syncIndexFromDisk } from '../project-index.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { buildDeferredShellDiagnostics, invalidateShellDiagnosticsCache, } from './shell-diagnostics.js';
@@ -148,7 +149,7 @@ function executeNodeScript(rootDir, script, timeout) {
     });
 }
 export async function runNodeScript(context, args) {
-    const { rootDir, autoYes, confirmCommand } = context;
+    const { rootDir } = context;
     const script = typeof args.script === 'string' ? args.script : '';
     if (!script.trim()) {
         return { ok: false, error: 'script is required' };
@@ -158,32 +159,16 @@ export async function runNodeScript(context, args) {
         console.log(chalk.bold.yellow(`\n  ⚡ Node script:\n${commandForApproval}\n`));
         console.log(chalk.dim(`    in: ${rootDir}\n`));
     }
-    if (!autoYes) {
-        if (confirmCommand == null) {
-            return {
-                ok: false,
-                command: COMMAND_LABEL,
-                error: 'confirmCommand is required when autoYes is false',
-            };
-        }
-        const approved = await confirmCommand(commandForApproval);
-        if (!approved) {
-            if (!isTuiMode()) {
-                console.log(chalk.dim(`  ⏭  Skipped: ${COMMAND_LABEL}`));
-            }
-            return {
-                ok: false,
-                skipped: true,
-                command: COMMAND_LABEL,
-                failureCategory: 'user_declined',
-                failureDetails: {
-                    category: 'user_declined',
-                    tool: 'run_node_script',
-                    action: 'Respect the real user’s decision. Do not retry the same or an equivalent action; reconsider the approach or ask one specific question if needed.',
-                },
-                error: 'The real user rejected this proposed script. Nothing was executed; this was not a tool failure or an automated system skip.',
-            };
+    const denied = await ensurePermission(context, {
+        bucket: 'run',
+        title: 'Approve node script?',
+        body: commandForApproval,
+    }, 'run_node_script', { command: COMMAND_LABEL });
+    if (denied) {
+        if (!isTuiMode()) {
+            console.log(chalk.dim(`  ⏭  Skipped: ${COMMAND_LABEL}`));
         }
+        return denied;
     }
     const beforeGitStatus = readGitStatusSignature(rootDir);
     const result = await executeNodeScript(rootDir, script, typeof args.timeout_ms === 'number' && args.timeout_ms > 0

package/dist/src/tools/str-replace.js

@@ -7,6 +7,7 @@ import { upsertIndexFile } from '../project-index.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { getCurrentFileHash, resolveRedactionTokens } from '../session-safety.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
+import { ensurePermission } from '../permissions.js';
 const DOCUMENT_EXTENSIONS = new Set(['.pdf', '.xlsx', '.docx']);
 function countOccurrences(haystack, needle) {
     if (needle.length === 0)
@@ -76,7 +77,7 @@ function buildStrReplacePreview(oldString, newString) {
     return `@@ str_replace @@\n${minus}\n${plus}`;
 }
 export async function strReplace(context, args) {
-    const { rootDir, projectIndex, autoYes, confirmPatch } = context;
+    const { rootDir, projectIndex } = context;
     const filePath = repairFilePath(rootDir, String(args.filePath ?? args.file_path ?? '').trim());
     let oldString = typeof args.old_string === 'string'
         ? args.old_string
@@ -175,23 +176,18 @@ export async function strReplace(context, args) {
         }
         console.log();
     }
-    if (!autoYes && confirmPatch) {
-        const confirmed = await confirmPatch(filePath, preview);
-        if (!confirmed) {
+    if (!scratchPath) {
+        const denied = await ensurePermission(context, {
+            bucket: 'edit',
+            title: 'Approve patch?',
+            body: 'Review changes before applying.',
+            filePath,
+            diff: preview,
+        }, 'str_replace', { filePath });
+        if (denied) {
             if (!isTuiMode())
                 console.log(chalk.dim(`  ⏭  str_replace skipped: ${filePath}`));
-            return {
-                ok: false,
-                skipped: true,
-                filePath,
-                failureCategory: 'user_declined',
-                failureDetails: {
-                    category: 'user_declined',
-                    tool: 'str_replace',
-                    action: 'Respect the real user’s decision. Do not retry the same or an equivalent edit; reconsider the approach or ask one specific question if needed.',
-                },
-                error: 'The real user rejected this proposed edit. Nothing was changed; this was not a tool failure or an automated system skip.',
-            };
+            return denied;
         }
     }
     const nextContent = originalContent.split(oldString).join(newString);

package/dist/src/tools/write-file.js

@@ -2,11 +2,47 @@ import chalk from '../colors.js';
 import path from 'node:path';
 import { normalizeProjectRelativePath } from '../artifact-policy.js';
 import { classifyProjectPath, writeProjectFile } from '../patcher.js';
+import { readFileEditSnapshot } from '../edit-journal.js';
 import { upsertIndexFile } from '../project-index.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { getCurrentFileHash, hasFreshFullReadCoverage, resolveRedactionTokens, } from '../session-safety.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
+import { ensurePermission } from '../permissions.js';
 const DOCUMENT_EXTENSIONS = new Set(['.pdf', '.xlsx', '.docx']);
+const MAX_WRITE_PREVIEW_LINES = 400;
+function boundedLines(text, limit) {
+    const lines = [];
+    let omitted = 0;
+    let start = 0;
+    for (;;) {
+        const newline = text.indexOf('\n', start);
+        if (lines.length < limit) {
+            lines.push(text.slice(start, newline === -1 ? undefined : newline));
+        }
+        else {
+            omitted += 1;
+        }
+        if (newline === -1)
+            break;
+        start = newline + 1;
+    }
+    return { lines, omitted };
+}
+function buildWritePreview(previous, next) {
+    const rows = ['@@ write_file @@'];
+    const append = (text, sign, marker) => {
+        const { lines, omitted } = boundedLines(text, MAX_WRITE_PREVIEW_LINES);
+        for (const line of lines)
+            rows.push(`${sign}${line}`);
+        if (omitted > 0) {
+            rows.push(`@@ ${omitted} more ${marker} line(s) not shown @@`);
+        }
+    };
+    if (previous !== null)
+        append(previous, '-', 'removed');
+    append(next, '+', 'added');
+    return rows.join('\n');
+}
 export async function writeFile(context, args) {
     const { rootDir, projectIndex } = context;
     const filePath = String(args.filePath ?? '').trim();
@@ -60,6 +96,36 @@ export async function writeFile(context, args) {
         };
     }
     content = resolveRedactionTokens(context.safety, content, coveragePath, currentHash);
+    if (!scratchPath) {
+        const before = currentHash === null ? null : readFileEditSnapshot(rootDir, filePath);
+        const existing = before && before.contentEncoding === 'utf8' ? before.content : null;
+        const denied = await ensurePermission(context, {
+            bucket: currentHash === null ? 'create' : 'edit',
+            title: currentHash === null ? 'Approve new file?' : 'Approve patch?',
+            body: 'Review changes before applying.',
+            filePath,
+            diff: buildWritePreview(existing, content),
+        }, 'write_file', { filePath });
+        if (denied) {
+            if (!isTuiMode())
+                console.log(chalk.dim(`  ⏭  write_file skipped: ${filePath}`));
+            return denied;
+        }
+        if (getCurrentFileHash(rootDir, filePath) !== currentHash) {
+            return {
+                ok: false,
+                filePath,
+                failureCategory: 'conflict',
+                error: `write_file refused: ${filePath} changed on disk while the approval prompt was open.`,
+                failureDetails: {
+                    category: 'conflict',
+                    tool: 'write_file',
+                    action: 'Re-read the file to see its current contents, then decide whether the write is still correct and retry.',
+                },
+                currentHash,
+            };
+        }
+    }
     const { changed } = writeProjectFile(rootDir, filePath, content);
     let indexedChunks = 0;
     let retrievalTokensUsed = 0;

package/dist/src/ui/repl.js

@@ -1,4 +1,5 @@
 import { createRatatuiBridge } from './tui/bridge.js';
+import { bucketActionLabel, } from '../permissions.js';
 import { approvalScrollLimit, buildTuiFrame, formatJobElapsed, formatTodoProgress, pickThinkingFallbackPhrase, renderTranscriptEntryLines, THINKING_FALLBACK_PHRASES, userInputViewportForFrame, } from './tui/build-frame.js';
 import { createTerminalTitleController } from './tui/terminal-title.js';
 import { captureTerminalWrites, releaseTerminalWrites, } from './tui/terminal-writes.js';
@@ -74,23 +75,6 @@ const WORKING_TOOL_PREVIEW_ITEMS = 4;
 const THINKING_NOTE_PREVIEW_ROWS = 3;
 const WORKING_TOOL_PREVIEW_ROWS = 3;
 const AGENT_MODE_LABEL_WIDTH = 16;
-const APPROVAL_OPTIONS = [
-    {
-        value: 'y',
-        label: 'Approve once',
-        description: 'Run this action only this time',
-    },
-    {
-        value: 'a',
-        label: 'Approve all remaining actions',
-        description: 'Turn on auto-approve for the rest of the session',
-    },
-    {
-        value: 'n',
-        label: 'Deny',
-        description: 'Reject this action',
-    },
-];
 export const SLASH_COMMANDS = [
     {
         command: '/help',
@@ -852,6 +836,13 @@ export function buildTranscriptFromSessionHistory(history) {
             }
             continue;
         }
+        if (entry.role === 'user' && entry.kind === 'userInterjection') {
+            const text = String(entry.userInput ?? '').trim();
+            if (text) {
+                entries.push({ body: text, kind: 'user', title: 'You · sent mid-turn' });
+            }
+            continue;
+        }
         const text = textFromHistoryEntry(entry);
         if ((entry.role === 'model' || entry.role === 'assistant') && text) {
             if (isTurnFailureMarker(text)) {
@@ -988,7 +979,7 @@ function createInitialShellState(session, serverModels, debugUi) {
         activeTurnInputPreformatted: false,
         agentMode: session.agentMode,
         analyzingImages: 0,
-        approvalCursor: getDefaultApprovalCursor(),
+        approvalCursor: 0,
         approvalPrompt: null,
         approvalScrollOffset: 0,
         autoYes: session.autoYes,
@@ -1022,6 +1013,7 @@ function createInitialShellState(session, serverModels, debugUi) {
         resumePickerSessions: [],
         transcriptScrollOffset: 0,
         queuedMessage: null,
+        turnMessages: [],
         serverModels: serverModels.models,
         sudoPrompt: null,
         status: 'Ready',
@@ -1271,26 +1263,13 @@ export function navigatePromptHistory(state, direction) {
         promptHistoryCursor: nextCursor,
     };
 }
-function getDefaultApprovalCursor() {
-    const denyIndex = APPROVAL_OPTIONS.findIndex((option) => option.value === 'n');
-    return denyIndex === -1 ? 0 : denyIndex;
-}
-export function getNextApprovalCursor(currentIndex, direction) {
-    return (currentIndex + direction + APPROVAL_OPTIONS.length) % APPROVAL_OPTIONS.length;
-}
-export function getApprovalChoiceForCursor(cursor) {
-    return (APPROVAL_OPTIONS[Math.min(Math.max(cursor, 0), APPROVAL_OPTIONS.length - 1)]
-        ?.value ?? 'n');
-}
-export function resolveApprovalChoiceFromInput(input) {
-    const normalizedInput = String(input ?? '').trim().toLowerCase();
-    if (normalizedInput === 'y')
-        return 'y';
-    if (normalizedInput === 'a')
-        return 'a';
-    if (normalizedInput === 'n')
-        return 'n';
-    return null;
+export function getDefaultApprovalCursor(optionCount) {
+    return Math.max(0, optionCount - 1);
+}
+export function getNextApprovalCursor(currentIndex, direction, optionCount) {
+    if (optionCount <= 0)
+        return 0;
+    return (currentIndex + direction + optionCount) % optionCount;
 }
 export function pauseBusyClock(state, nowMs) {
     if (state.busySince === null || state.busyPausedAt !== null)
@@ -1374,7 +1353,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         let currentServerModels = serverModels;
         let sessionAutoYes = session.autoYes;
         let resolveDone = null;
-        let resolveApprovalChoice = null;
+        let resolvePermissionDecision = null;
         let resolveSudoPassword = null;
         let pendingUserInput = null;
         let cleanupSudoPasswordPrompt = null;
@@ -1393,6 +1372,9 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         let latestUsageSummary = null;
         let pendingTurnEntries = [];
         let activeTurnAbort = null;
+        let activeServerTurnId = null;
+        let unacknowledged = new Map();
+        const blockedRows = new WeakMap();
         let newConversationInFlight = false;
         let todosTouchedThisTurn = false;
         const syncTodosState = () => {
@@ -1597,14 +1579,14 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             }
         };
         const dismissPendingApproval = () => {
-            if (!resolveApprovalChoice)
+            if (!resolvePermissionDecision)
                 return;
-            const pendingResolve = resolveApprovalChoice;
-            resolveApprovalChoice = null;
-            pendingResolve('n');
+            const pendingResolve = resolvePermissionDecision;
+            resolvePermissionDecision = null;
+            pendingResolve({ kind: 'deny' });
             store.update((current) => ({
                 ...resumeBusyClock(current, Date.now()),
-                approvalCursor: getDefaultApprovalCursor(),
+                approvalCursor: 0,
                 approvalPrompt: null,
                 approvalScrollOffset: 0,
             }));
@@ -1677,6 +1659,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 status: 'Ready',
                 thinkingTitle: '',
                 thinkingNotes: [],
+                turnMessages: [],
                 workingTools: [],
                 tokenUsage: formatClientTokenUsage(busyElapsedMs(current, Date.now()), latestUsageSummary),
             }));
@@ -1927,40 +1910,45 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             pending.resolve(result);
             scheduleLiveFrameRemount();
         };
-        const openApprovalPrompt = (title, body, options = {}) => new Promise((resolve) => {
+        const openApprovalPrompt = (request) => new Promise((resolve) => {
+            const deny = { kind: 'deny' };
             if (exiting) {
-                resolve('n');
+                resolve(deny);
                 return;
             }
-            resolveApprovalChoice = resolve;
+            resolvePermissionDecision = resolve;
             store.update((current) => ({
                 ...pauseBusyClock(current, Date.now()),
-                approvalCursor: getDefaultApprovalCursor(),
+                approvalCursor: getDefaultApprovalCursor(request.options.length),
+                approvalOpenedAt: Date.now(),
                 approvalScrollOffset: 0,
                 approvalPrompt: {
-                    title,
-                    body,
-                    diffPreview: options.diff && options.filePath
-                        ? parseDiffPreview(options.diff)
+                    title: request.title,
+                    body: request.body,
+                    diffPreview: request.diff && request.filePath
+                        ? parseDiffPreview(request.diff)
                         : undefined,
-                    filePath: options.filePath,
+                    filePath: request.filePath,
+                    options: request.options,
                     returnStatus: current.status,
                 },
-                status: title,
+                status: request.title,
             }));
         });
-        const handleInlineApprovalChoice = async (choice) => {
+        const handleInlineApprovalChoice = async (index) => {
             const current = store.getState();
-            const pendingResolve = resolveApprovalChoice;
-            resolveApprovalChoice = null;
+            const options = current.approvalPrompt?.options ?? [];
+            const chosen = options[index]?.decision ?? { kind: 'deny' };
+            const pendingResolve = resolvePermissionDecision;
+            resolvePermissionDecision = null;
             store.update((next) => ({
                 ...resumeBusyClock(next, Date.now()),
-                approvalCursor: getDefaultApprovalCursor(),
+                approvalCursor: getDefaultApprovalCursor(options.length),
                 approvalPrompt: null,
                 approvalScrollOffset: 0,
                 status: current.approvalPrompt?.returnStatus ?? next.status,
             }));
-            pendingResolve?.(choice);
+            pendingResolve?.(chosen);
         };
         const refreshServerModels = async () => {
             currentServerModels = await models.fetchServerModels({ config: authConfig });
@@ -2230,6 +2218,129 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             }));
             await handleSubmit(queued.body);
         };
+        let turnMessageCounter = 0;
+        const upsertTurnMessage = (id, patch) => {
+            store.update((current) => ({
+                ...current,
+                turnMessages: current.turnMessages.map((message) => message.id === id ? { ...message, ...patch } : message),
+            }));
+        };
+        const recoverUnacknowledgedMessages = (autoSubmits = true) => {
+            if (unacknowledged.size === 0)
+                return;
+            const stranded = [...unacknowledged.values()];
+            unacknowledged = new Map();
+            for (const { row } of stranded) {
+                upsertTurnMessage(row, {
+                    state: 'queued',
+                    note: autoSubmits
+                        ? 'not read — sending as the next prompt'
+                        : 'not read — left in the composer',
+                });
+            }
+            const existing = store.getState().queuedMessage;
+            const combined = [
+                ...stranded.map((entry) => entry.queued),
+                ...(existing ? [existing] : []),
+            ];
+            const body = combined
+                .map((entry) => entry.body)
+                .filter((entry) => entry.trim())
+                .join('\n\n');
+            if (!body.trim())
+                return;
+            scheduleLiveFrameRemount();
+            store.update((current) => ({
+                ...current,
+                queuedMessage: {
+                    body,
+                    imageAttachments: combined.flatMap((entry) => entry.imageAttachments),
+                    pastedChunks: combined.flatMap((entry) => entry.pastedChunks),
+                },
+            }));
+        };
+        const fireQueuedMessage = async () => {
+            const state = store.getState();
+            const queued = state.queuedMessage;
+            if (!queued || !state.busy || exiting)
+                return;
+            const text = (queued.pastedChunks.length
+                ? expandPastedChunks(queued.body, queued.pastedChunks)
+                : queued.body).trim();
+            if (!text)
+                return;
+            const turnId = activeServerTurnId;
+            const blockedReason = queued.imageAttachments.length > 0
+                ? 'waiting — images go with the next prompt'
+                : !turnId
+                    ? 'waiting for the turn to end'
+                    : null;
+            const existingRow = blockedRows.get(queued);
+            if (existingRow !== undefined) {
+                upsertTurnMessage(existingRow, {
+                    state: 'queued',
+                    ...(blockedReason ? { note: blockedReason } : {}),
+                });
+                if (blockedReason || !turnId)
+                    return;
+            }
+            const id = existingRow ?? ++turnMessageCounter;
+            const messageId = `m${id}_${Date.now().toString(36)}`;
+            if (existingRow === undefined) {
+                scheduleLiveFrameRemount();
+                store.update((current) => ({
+                    ...current,
+                    turnMessages: [
+                        ...current.turnMessages,
+                        {
+                            id,
+                            text,
+                            state: blockedReason ? 'queued' : 'sending',
+                            ...(blockedReason ? { note: blockedReason } : {}),
+                        },
+                    ],
+                }));
+            }
+            if (blockedReason || !turnId) {
+                blockedRows.set(queued, id);
+                return;
+            }
+            blockedRows.delete(queued);
+            unacknowledged.set(messageId, { row: id, queued });
+            scheduleLiveFrameRemount();
+            store.update((current) => current.queuedMessage === queued
+                ? { ...current, queuedMessage: null }
+                : current);
+            queueTurnEntry({
+                body: text,
+                kind: 'user',
+                preformatted: queued.pastedChunks.length > 0,
+                title: 'You · sent mid-turn',
+            });
+            const rollback = (note) => {
+                if (!unacknowledged.delete(messageId))
+                    return;
+                upsertTurnMessage(id, { state: 'queued', note });
+                scheduleLiveFrameRemount();
+                store.update((current) => current.queuedMessage ? current : { ...current, queuedMessage: queued });
+            };
+            let outcome;
+            try {
+                outcome = await chat.postInterjection({
+                    config: authConfig,
+                    turnId,
+                    text,
+                    messageId,
+                });
+            }
+            catch (error) {
+                rollback(`not sent — ${error?.message ?? 'request failed'}`);
+                return;
+            }
+            if (outcome === 'stale') {
+                rollback('turn ended — sending as the next prompt');
+            }
+        };
         const handleSubmit = async (rawInput) => {
             const chunks = store.getState().pastedChunks;
             const expanded = chunks.length
@@ -2481,6 +2592,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             }
             latestUsageSummary = null;
             disarmExitConfirm();
+            unacknowledged = new Map();
             const turnStartedAt = Date.now();
             const turnGeneration = ++activeTurnGeneration;
             const turnAbort = new AbortController();
@@ -2513,6 +2625,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 transcriptScrollOffset: 0,
                 tokenUsage: formatClientTokenUsage(0, latestUsageSummary),
                 turnCounter: current.turnCounter + 1,
+                turnMessages: [],
                 workingTools: [],
             }));
             try {
@@ -2523,6 +2636,25 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     input,
                     imageAttachments,
                     signal: turnAbort.signal,
+                    onTurnStart: (serverTurnId) => {
+                        if (turnGeneration !== activeTurnGeneration)
+                            return;
+                        activeServerTurnId = serverTurnId;
+                    },
+                    onInterjectionDelivered: (event) => {
+                        if (turnGeneration !== activeTurnGeneration)
+                            return;
+                        for (const messageId of event.messageIds ?? []) {
+                            const pending = unacknowledged.get(messageId);
+                            if (!pending)
+                                continue;
+                            unacknowledged.delete(messageId);
+                            upsertTurnMessage(pending.row, {
+                                state: 'delivered',
+                                note: undefined,
+                            });
+                        }
+                    },
                 });
                 if (turnGeneration !== activeTurnGeneration)
                     return;
@@ -2571,6 +2703,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     status: result.waitingForApproval ? 'Awaiting approval' : 'Ready',
                     tokenUsage: formatClientTokenUsage(Date.now() - turnStartedAt, latestUsageSummary),
                 }));
+                recoverUnacknowledgedMessages();
                 await flushQueuedMessage();
             }
             catch (error) {
@@ -2616,6 +2749,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     appendError(error.message);
                 }
                 await remountTui();
+                recoverUnacknowledgedMessages(!cancelled);
                 if (!cancelled && turnGeneration === activeTurnGeneration) {
                     await flushQueuedMessage();
                 }
@@ -2626,7 +2760,9 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 }
                 if (turnGeneration === activeTurnGeneration) {
                     lastTurnStartedAt = null;
+                    activeServerTurnId = null;
                 }
+                recoverUnacknowledgedMessages();
             }
         };
         session.onImageAnalysis = (activeImageCount) => {
@@ -2721,44 +2857,28 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         projectIndex.onContextLog = session.onContextLog;
         session.requestSudoPassword = async ({ command, prompt, signal }) => openSudoPasswordPrompt(command, prompt, signal);
         session.requestUserInput = async (request, signal) => openUserInputPrompt(request.questions, signal);
-        session.confirmCommand = async (command) => {
+        session.requestPermission = async (request) => {
+            const deny = { kind: 'deny' };
             if (exiting)
-                return false;
+                return deny;
             if (sessionAutoYes)
-                return true;
-            const choice = await openApprovalPrompt('Approve command?', command);
-            if (choice === 'a') {
-                setAgentMode('auto-accept');
-                syncShellStateFromSession();
+                return { kind: 'once' };
+            const decision = await openApprovalPrompt(request);
+            if (decision.kind === 'always-bucket') {
                 appendTurnAwareEntry({
-                    body: 'Auto-approve enabled for the rest of this session.',
+                    body: `Allowed for the rest of this session: ${bucketActionLabel(request.bucket)}.`,
                     kind: 'system',
                     title: 'Approvals',
                 });
-                return true;
             }
-            return choice === 'y';
-        };
-        session.confirmPatch = async (filePath, patch) => {
-            if (exiting)
-                return false;
-            if (sessionAutoYes)
-                return true;
-            const choice = await openApprovalPrompt('Approve patch?', 'Review changes before applying.', {
-                diff: patch,
-                filePath,
-            });
-            if (choice === 'a') {
-                setAgentMode('auto-accept');
-                syncShellStateFromSession();
+            else if (decision.kind === 'always-prefix') {
                 appendTurnAwareEntry({
-                    body: 'Auto-approve enabled for the rest of this session.',
+                    body: `Allowed for the rest of this session: commands starting with \`${decision.prefix}\`.`,
                     kind: 'system',
                     title: 'Approvals',
                 });
-                return true;
             }
-            return choice === 'y';
+            return decision;
         };
         const shellInputHandlers = {
             getApprovalScrollLimit: () => {
@@ -2791,6 +2911,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             onJobsPickerKill: handleJobsPickerKill,
             onSudoPasswordInput: handleSudoPasswordInput,
             onSubmit: handleSubmit,
+            onFireQueuedMessage: fireQueuedMessage,
         };
         const unsubscribe = store.subscribe(() => {
             renderCurrentFrame();