@thegitai/cli 1.0.0-preview.2 → 1.0.0-preview.21

package/dist/src/project-index.js

@@ -39,10 +39,21 @@ function removeFile(index, relPath) {
     index.chunksByFile.delete(relPath);
     index.fileSignatures.delete(relPath);
 }
+function countIndexedChunks(index) {
+    return Array.from(index.chunksByFile.values()).reduce((sum, chunks) => sum + chunks.length, 0);
+}
 async function initializeIndex(index) {
     if (index.initialized) {
-        return Array.from(index.chunksByFile.values()).reduce((sum, chunks) => sum + chunks.length, 0);
+        return countIndexedChunks(index);
+    }
+    if (!index._initializing) {
+        index._initializing = scanProjectIntoIndex(index).finally(() => {
+            index._initializing = null;
+        });
     }
+    return index._initializing;
+}
+async function scanProjectIntoIndex(index) {
     const files = listProjectFiles(index.rootDir);
     const chunks = await scanFiles(index.rootDir, files);
     index.fileSignatures.clear();
@@ -106,6 +117,7 @@ export function createIndex({ rootDir, onStatus = null, onContextLog = null, })
     return {
         rootDir: path.resolve(rootDir),
         initialized: false,
+        _initializing: null,
         fileSignatures: new Map(),
         chunksByFile: new Map(),
         onStatus,

package/dist/src/session-store.js

@@ -1,12 +1,15 @@
+import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { getClientStateDir } from './client-state.js';
+import { findStoredImageByContent, pruneSessionImages, readSessionImage, sweepOrphanSessionImages, } from './core/session-image-store.js';
 import { normalizeAssistantEditJournal } from './edit-journal.js';
+import { createSessionGrants } from './permissions.js';
 import { cloneSessionSafetyState, createSessionSafetyState, mergeLocalSessionSafetyState, normalizeSessionSafetyState, } from './session-safety.js';
-import { truncate } from './utils.js';
+import { singleLinePreview } from './utils.js';
 const SESSION_STORE_VERSION = 1;
-const MAX_RECENT_SESSIONS = 5;
+export const MAX_RECENT_SESSIONS = 10;
 function cloneJson(value) {
     return JSON.parse(JSON.stringify(value ?? null));
 }
@@ -77,6 +80,45 @@ function listSessionFiles(rootDir, env = process.env) {
         .filter((name) => name.endsWith('.json'))
         .map((name) => path.join(dir, name));
 }
+function normalizeBranch(value) {
+    const text = String(value ?? '')
+        .replace(/[\r\n\t]/g, ' ')
+        .trim();
+    return text ? text.slice(0, 120) : null;
+}
+function dehydrateHistoryImages(history) {
+    return history.map((entry) => ({
+        ...entry,
+        parts: (entry.parts ?? []).map((part) => {
+            if (!part?.inlineData?.data)
+                return part;
+            const cachePath = part.imageCachePath ?? findStoredImageByContent(part.inlineData.data);
+            if (!cachePath)
+                return part;
+            return {
+                imageRef: { cachePath, mimeType: part.inlineData.mimeType },
+                text: '[image stored in this session]',
+            };
+        }),
+    }));
+}
+function rehydrateHistoryImages(history) {
+    return history.map((entry) => ({
+        ...entry,
+        parts: (entry.parts ?? []).map((part) => {
+            const ref = part?.imageRef;
+            if (!ref?.cachePath)
+                return part;
+            const stored = readSessionImage(String(ref.cachePath));
+            if (!stored)
+                return { text: part.text ?? '[image no longer available]' };
+            return {
+                inlineData: { mimeType: stored.mimeType, data: stored.base64Data },
+                imageCachePath: ref.cachePath,
+            };
+        }),
+    }));
+}
 function normalizeHistory(value) {
     if (!Array.isArray(value))
         return [];
@@ -107,6 +149,7 @@ function normalizeSnapshot(raw, rootDir) {
         createdAt: normalizeIsoDate(raw.createdAt),
         updatedAt: normalizeIsoDate(raw.updatedAt),
         modelId,
+        branch: normalizeBranch(raw.branch),
         history: cloneJson(normalizeHistory(raw.history)),
         clientState: sanitizeClientState(raw.clientState),
         serverState: sanitizeOpaqueState(raw.serverState),
@@ -145,14 +188,57 @@ function assertSessionNameAvailable(rootDir, name, sessionId, env = process.env)
         throw new Error(`Session name "${name}" is already used by ${duplicate.id}. Use --session "${name}" to resume it or choose a different name.`);
     }
 }
+function listAllSessionIds(env = process.env) {
+    const ids = new Set();
+    const projectsDir = path.join(getSessionBaseDir(env), 'sessions', 'projects');
+    if (!existsSync(projectsDir))
+        return ids;
+    try {
+        for (const project of readdirSync(projectsDir)) {
+            const dir = path.join(projectsDir, project);
+            try {
+                for (const file of readdirSync(dir)) {
+                    if (file.endsWith('.json'))
+                        ids.add(path.basename(file, '.json'));
+                }
+            }
+            catch {
+            }
+        }
+    }
+    catch {
+        return ids;
+    }
+    return ids;
+}
 export function pruneSavedSessions(rootDir, env = process.env) {
     const snapshots = loadAllSnapshots(rootDir, env);
     const keep = new Set(snapshots.slice(0, MAX_RECENT_SESSIONS).map((snapshot) => snapshot.id));
     for (const snapshot of snapshots.slice(MAX_RECENT_SESSIONS)) {
         if (!keep.has(snapshot.id)) {
             rmSync(getSessionPath(rootDir, snapshot.id, env), { force: true });
+            pruneSessionImages(snapshot.id, env);
         }
     }
+    sweepOrphanSessionImages({
+        activeSessionIds: listAllSessionIds(env),
+        env,
+    });
+}
+export function readGitBranch(rootDir) {
+    try {
+        const result = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+            cwd: rootDir,
+            encoding: 'utf8',
+            timeout: 1500,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const branch = result.status === 0 ? String(result.stdout ?? '').trim() : '';
+        return branch && branch !== 'HEAD' ? branch : null;
+    }
+    catch {
+        return null;
+    }
 }
 export function snapshotFromSession(session) {
     const now = new Date().toISOString();
@@ -168,6 +254,7 @@ export function snapshotFromSession(session) {
         createdAt,
         updatedAt: now,
         modelId: session.modelId,
+        branch: readGitBranch(session.rootDir),
         history: cloneJson(session.history),
         clientState: {
             editCounter: session.clientState.editCounter,
@@ -187,6 +274,7 @@ export function saveSessionState(session, env = process.env) {
 }
 export function applySessionSnapshot(session, snapshot, options = {}) {
     const currentAgentMode = session.agentMode;
+    const previousSessionId = session.sessionId;
     session.sessionId = snapshot.id;
     session.sessionName = snapshot.name;
     session.sessionCreatedAt = snapshot.createdAt;
@@ -196,6 +284,9 @@ export function applySessionSnapshot(session, snapshot, options = {}) {
     session.serverState = sanitizeOpaqueState(snapshot.serverState);
     session.agentMode = options.preserveAgentMode ? currentAgentMode : 'default';
     session.autoYes = session.agentMode === 'auto-accept';
+    if (previousSessionId !== session.sessionId) {
+        session.grants = createSessionGrants();
+    }
     session.turnState = {
         id: null,
         historyStartIndex: session.history.length,
@@ -210,6 +301,9 @@ export function applySessionSnapshot(session, snapshot, options = {}) {
         safety: mergeLocalSessionSafetyState(session.clientState.safety, snapshot.clientState.safety),
     };
 }
+export function sessionHasUserMessage(session) {
+    return session.history.some((entry) => Boolean(userPromptText(entry)));
+}
 function extractMarkedSection(text, marker) {
     const index = text.indexOf(marker);
     if (index === -1)
@@ -218,23 +312,27 @@ function extractMarkedSection(text, marker) {
     const end = after.indexOf('\n\n');
     return (end === -1 ? after : after.slice(0, end)).trim();
 }
-function extractLastUserMessage(history) {
-    for (let i = history.length - 1; i >= 0; i--) {
-        const entry = history[i];
-        if (!entry || entry.role !== 'user')
-            continue;
-        const text = (entry.parts ?? [])
-            .map((part) => (typeof part?.text === 'string' ? part.text : ''))
-            .filter(Boolean)
-            .join('\n')
-            .trim();
-        if (!text)
-            continue;
-        const request = extractMarkedSection(text, 'Current user request:') ||
-            extractMarkedSection(text, 'User request:');
-        const message = extractMarkedSection(text, 'Current user message:') ||
-            extractMarkedSection(text, 'User message:');
-        return truncate(request || message || text, 120);
+export function userPromptText(entry) {
+    if (!entry || entry.role !== 'user' || entry.kind !== 'turnStart')
+        return '';
+    const text = (entry.parts ?? [])
+        .map((part) => (typeof part?.text === 'string' ? part.text : ''))
+        .filter(Boolean)
+        .join('\n')
+        .trim();
+    if (!text)
+        return '';
+    const request = extractMarkedSection(text, 'Current user request:') ||
+        extractMarkedSection(text, 'User request:');
+    const message = extractMarkedSection(text, 'Current user message:') ||
+        extractMarkedSection(text, 'User message:');
+    return (request || message || text).trim();
+}
+function extractFirstUserPrompt(history) {
+    for (const entry of history) {
+        const text = userPromptText(entry);
+        if (text)
+            return singleLinePreview(text, 120);
     }
     return '';
 }
@@ -247,8 +345,9 @@ function metadataFromSnapshot(snapshot) {
         updatedAt: snapshot.updatedAt,
         modelId: snapshot.modelId,
         messageCount: snapshot.history.length,
-        lastUserMessage: extractLastUserMessage(snapshot.history),
+        lastUserMessage: extractFirstUserPrompt(snapshot.history),
         summaryPreview: '',
+        branch: snapshot.branch ?? null,
     };
 }
 export function listSessionMetadata(rootDir, env = process.env) {

package/dist/src/session.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { normalizeAgentMode, } from './agent-mode.js';
+import { createSessionGrants, } from './permissions.js';
 import { createSessionSafetyState, } from './session-safety.js';
 import { clampInteger } from './utils.js';
 const DEFAULT_MAX_TOOL_STEPS = 32;
@@ -31,7 +32,7 @@ function preserveProviderSelection(serverState) {
         : null;
     return providerSelection ? { providerSelection } : {};
 }
-export function createSession({ rootDir, autoYes = false, agentMode, modelId, maxToolSteps = DEFAULT_MAX_TOOL_STEPS, confirmCommand = null, confirmPatch = null, requestSudoPassword = null, onStatus = null, onContextLog = null, onToolEvent = null, env = process.env, sessionId = createSessionId(), sessionName = null, history = [], serverState = null, editJournal = [], stickyFilePaths = [], editCounter = 0, safety = createSessionSafetyState(), }) {
+export function createSession({ rootDir, autoYes = false, agentMode, modelId, maxToolSteps = DEFAULT_MAX_TOOL_STEPS, requestPermission = null, requestSudoPassword = null, requestUserInput = null, onStatus = null, onContextLog = null, onToolEvent = null, env = process.env, sessionId = createSessionId(), sessionName = null, history = [], serverState = null, editJournal = [], stickyFilePaths = [], editCounter = 0, safety = createSessionSafetyState(), }) {
     const createdAt = new Date().toISOString();
     const initialAgentMode = normalizeAgentMode(agentMode ?? (autoYes ? 'auto-accept' : 'default'));
     return {
@@ -43,9 +44,10 @@ export function createSession({ rootDir, autoYes = false, agentMode, modelId, ma
         onStatus: onStatus ?? defaultStatus,
         onContextLog: onContextLog ?? defaultContextLog,
         onToolEvent,
-        confirmCommand,
-        confirmPatch,
+        grants: createSessionGrants(),
+        requestPermission,
         requestSudoPassword,
+        requestUserInput,
         history: JSON.parse(JSON.stringify(history)),
         initialized: true,
         sessionId,
@@ -69,8 +71,17 @@ export function createSession({ rootDir, autoYes = false, agentMode, modelId, ma
         serverState: cloneOpaqueState(serverState),
     };
 }
+export function startNewConversation(session) {
+    clearConversation(session);
+    const createdAt = new Date().toISOString();
+    session.sessionId = createSessionId();
+    session.sessionName = null;
+    session.sessionCreatedAt = createdAt;
+    session.sessionUpdatedAt = createdAt;
+}
 export function clearConversation(session) {
     session.history = [];
+    session.grants = createSessionGrants();
     session.serverState = preserveProviderSelection(session.serverState);
     session.turnState = {
         id: null,

package/dist/src/tool-executor.js

@@ -277,8 +277,8 @@ export async function executeLocalToolCall(toolContext, session, call) {
             sessionId: session.sessionId,
             projectIndex: toolContext.projectIndex,
             autoYes: session.autoYes,
-            confirmCommand: session.confirmCommand,
-            confirmPatch: session.confirmPatch,
+            grants: session.grants,
+            requestPermission: session.requestPermission,
             requestSudoPassword: session.requestSudoPassword,
             onStatus: session.onStatus,
             editJournal: session.clientState.editJournal,

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

@@ -3,6 +3,7 @@ import { classifyProjectPath, deleteProjectFile } from '../patcher.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { removeIndexFile } from '../project-index.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
+import { ensurePermission } from '../permissions.js';
 export async function deleteFile(context, args) {
     const { rootDir, projectIndex } = context;
     const filePath = String(args.filePath ?? '').trim();
@@ -24,6 +25,19 @@ export async function deleteFile(context, args) {
         };
     }
     const scratchPath = pathKind === 'scratch';
+    if (!scratchPath) {
+        const denied = await ensurePermission(context, {
+            bucket: 'delete',
+            title: 'Approve file deletion?',
+            body: `Delete ${filePath}`,
+            filePath,
+        }, 'delete_file', { filePath });
+        if (denied) {
+            if (!isTuiMode())
+                console.log(chalk.dim(`  ⏭  Delete skipped: ${filePath}`));
+            return denied;
+        }
+    }
     const result = deleteProjectFile(rootDir, filePath);
     if (result.deleted) {
         if (!scratchPath) {

package/dist/src/tools/index.js

@@ -22,6 +22,7 @@ import { shellJobKill } from './shell-job-kill.js';
 import { strReplace } from './str-replace.js';
 import { undoEdit } from './undo-edit.js';
 import { updateTodos } from './update-todos.js';
+import { readImageFile } from './read-image-file.js';
 import { writeFile } from './write-file.js';
 export const TOOL_MAP = {
     search_code: (context, args) => searchCode(context.projectIndex, args),
@@ -50,6 +51,7 @@ export const TOOL_MAP = {
     shell_job_output: shellJobOutput,
     shell_job_kill: shellJobKill,
     update_todos: updateTodos,
+    analyze_image: (context, args) => readImageFile(context, args),
 };
 function invalidToolCall(error) {
     return {

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

@@ -7,9 +7,10 @@ import { repairFilePath } from './path-suggest.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']);
 export async function patchFile(context, args) {
-    const { rootDir, projectIndex, autoYes, confirmPatch } = context;
+    const { rootDir, projectIndex } = context;
     const filePath = repairFilePath(rootDir, String(args.filePath ?? '').trim());
     let patch = typeof args.patch === 'string' ? args.patch : '';
     if (!filePath) {
@@ -74,23 +75,18 @@ export async function patchFile(context, args) {
         };
     }
     renderDiffPreview(filePath, patch);
-    if (!autoYes && confirmPatch) {
-        const confirmed = await confirmPatch(filePath, patch);
-        if (!confirmed) {
+    if (!scratchPath) {
+        const denied = await ensurePermission(context, {
+            bucket: getCurrentFileHash(rootDir, filePath) === null ? 'create' : 'edit',
+            title: 'Approve patch?',
+            body: 'Review changes before applying.',
+            filePath,
+            diff: patch,
+        }, 'patch_file', { filePath });
+        if (denied) {
             if (!isTuiMode())
                 console.log(chalk.dim(`  ⏭  Patch skipped: ${filePath}`));
-            return {
-                ok: false,
-                skipped: true,
-                filePath,
-                failureCategory: 'user_declined',
-                failureDetails: {
-                    category: 'user_declined',
-                    tool: 'patch_file',
-                    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 patch. Nothing was changed; this was not a tool failure or an automated system skip.',
-            };
+            return denied;
         }
     }
     const { changed } = writeProjectFile(rootDir, filePath, patchedContent);

package/dist/src/tools/read-image-file.js

@@ -0,0 +1,85 @@
+import path from 'node:path';
+import { normalizeProjectRelativePath } from '../artifact-policy.js';
+import { SessionImageError, getImageStoreSession, isSessionStorePath, readSessionImage, readSessionImageByIndex, storeSessionImageFromPath, } from '../core/session-image-store.js';
+export async function readImageFile(context, args) {
+    const rawPath = String(args.path ?? args.filePath ?? args.file_path ?? '').trim();
+    if (!rawPath) {
+        const requested = Number(args.imageIndex ?? args.image_index ?? args.index);
+        const stored = Number.isInteger(requested)
+            ? readSessionImageByIndex(requested)
+            : null;
+        if (!stored) {
+            return {
+                ok: false,
+                error: Number.isInteger(requested)
+                    ? `Image #${requested} is not in this session's image store.`
+                    : 'path is required and must name an image file on this machine.',
+                failureCategory: Number.isInteger(requested)
+                    ? 'not_found'
+                    : 'missing_required_argument',
+            };
+        }
+        return {
+            ok: true,
+            imageBytes: {
+                base64Data: stored.base64Data,
+                mimeType: stored.mimeType,
+                cachePath: stored.cachePath,
+                index: stored.index,
+            },
+        };
+    }
+    let resolved;
+    if (path.isAbsolute(rawPath)) {
+        resolved = rawPath;
+    }
+    else if (normalizeProjectRelativePath(context.rootDir, rawPath)) {
+        resolved = path.resolve(context.rootDir, rawPath);
+    }
+    else {
+        return {
+            ok: false,
+            error: `Refusing to access path outside the project root: ${rawPath}`,
+            failureCategory: 'permission_denied',
+        };
+    }
+    try {
+        const stored = isSessionStorePath(resolved)
+            ? readSessionImage(resolved)
+            : storeSessionImageFromPath({
+                sessionId: getImageStoreSession() ?? 'unbound',
+                sourcePath: resolved,
+            });
+        if (!stored) {
+            return {
+                ok: false,
+                error: `Not a readable image: ${resolved}`,
+                failureCategory: 'not_found',
+            };
+        }
+        return {
+            ok: true,
+            imageBytes: {
+                base64Data: stored.base64Data,
+                mimeType: stored.mimeType,
+                filePath: resolved,
+                cachePath: stored.cachePath,
+                index: stored.index,
+            },
+        };
+    }
+    catch (err) {
+        if (err instanceof SessionImageError) {
+            return {
+                ok: false,
+                error: err.message,
+                failureCategory: err.code === 'NOT_FOUND' ? 'not_found' : 'invalid_argument',
+            };
+        }
+        return {
+            ok: false,
+            error: `Could not read image: ${err?.message ?? err}`,
+            failureCategory: 'tool_exception',
+        };
+    }
+}

package/dist/src/tools/replace-document-text.js

@@ -6,6 +6,8 @@ import { readCliAuthConfig } from '../api/auth.js';
 import { resolveProjectPath, writeProjectFileBuffer } from '../patcher.js';
 import { repairFilePath, suggestClosestPath } from './path-suggest.js';
 import { isTuiMode } from '../runtime-mode.js';
+import { ensurePermission } from '../permissions.js';
+import { getCurrentFileHash } from '../session-safety.js';
 function normalizeReplacements(value) {
     if (!Array.isArray(value))
         return [];
@@ -178,27 +180,35 @@ export async function replaceDocumentText(context, args) {
     }
     const preview = String(serverResult.preview ?? '');
     renderPreview(targetPath, preview);
-    if (!context.autoYes && context.confirmPatch) {
-        const confirmed = await context.confirmPatch(targetPath, preview);
-        if (!confirmed) {
-            if (!isTuiMode()) {
-                console.log(chalk.dim(`  replace_document_text skipped: ${targetPath}`));
-            }
-            return {
-                ok: false,
-                skipped: true,
-                filePath: targetPath,
-                failureCategory: 'user_declined',
-                failureDetails: {
-                    category: 'user_declined',
-                    tool: 'replace_document_text',
-                    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 document edit. Nothing was changed; this was not a tool failure or an automated system skip.',
-            };
+    const targetHashBeforeApproval = getCurrentFileHash(context.rootDir, targetPath);
+    const documentIsNew = targetHashBeforeApproval === null;
+    const denied = await ensurePermission(context, {
+        bucket: documentIsNew ? 'create' : 'edit',
+        title: documentIsNew ? 'Approve new document?' : 'Approve document edit?',
+        body: 'Review changes before applying.',
+        filePath: targetPath,
+        diff: preview,
+    }, 'replace_document_text', { filePath: targetPath });
+    if (denied) {
+        if (!isTuiMode()) {
+            console.log(chalk.dim(`  replace_document_text skipped: ${targetPath}`));
         }
+        return denied;
     }
     const fileData = String(serverResult.fileData ?? '');
+    if (getCurrentFileHash(context.rootDir, targetPath) !== targetHashBeforeApproval) {
+        return {
+            ok: false,
+            filePath: targetPath,
+            failureCategory: 'conflict',
+            error: `replace_document_text refused: ${targetPath} changed on disk while the approval prompt was open.`,
+            failureDetails: {
+                category: 'conflict',
+                tool: 'replace_document_text',
+                action: 'Re-read the document to see its current contents, then rebuild the replacements against it and retry.',
+            },
+        };
+    }
     const nextData = Buffer.from(fileData, 'base64');
     const write = writeProjectFileBuffer(context.rootDir, targetPath, nextData);
     const failedCount = Number(serverResult.failedCount ?? 0);

package/dist/src/tools/run-command.js

@@ -2,13 +2,14 @@ import chalk from '../colors.js';
 import { startBackgroundJob } from '../background-jobs.js';
 import { getBlockedCommandReason, runCommand, } from '../executor.js';
 import { syncIndexFromDisk } from '../project-index.js';
+import { ensurePermission } from '../permissions.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { redactConnectionStringCredentials } from '../secret-preview.js';
 import { buildNestedGitHint } from '../session-safety.js';
 import { buildDeferredShellDiagnostics, invalidateShellDiagnosticsCache, } from './shell-diagnostics.js';
 const MAX_OUTPUT_CHARS = 4000;
 export async function runShellCommand(context, args) {
-    const { rootDir, projectIndex, autoYes, confirmCommand, requestSudoPassword, onStatus, } = context;
+    const { rootDir, projectIndex, requestSudoPassword, onStatus, } = context;
     const command = String(args.command ?? '').trim();
     if (!command) {
         return { ok: false, error: 'command is required' };
@@ -31,33 +32,18 @@ export async function runShellCommand(context, args) {
     }
     if (!isTuiMode())
         console.log(chalk.bold.yellow(`\n  ⚡ Command: ${command}`));
-    if (!autoYes) {
-        if (confirmCommand == null) {
-            return {
-                ok: false,
-                command,
-                error: 'confirmCommand is required when autoYes is false',
-            };
-        }
-        const approved = await confirmCommand(runInBackground
+    const denied = await ensurePermission(context, {
+        bucket: 'run',
+        title: 'Approve command?',
+        body: runInBackground
             ? `${command}\n\nRuns as a managed background job until it exits or is killed.`
-            : command);
-        if (!approved) {
-            if (!isTuiMode())
-                console.log(chalk.dim(`  ⏭  Skipped: ${command}`));
-            return {
-                ok: false,
-                skipped: true,
-                command,
-                failureCategory: 'user_declined',
-                failureDetails: {
-                    category: 'user_declined',
-                    tool: 'run_command',
-                    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 command. Nothing was executed; this was not a tool failure or an automated system skip.',
-            };
-        }
+            : command,
+        command,
+    }, 'run_command', { command });
+    if (denied) {
+        if (!isTuiMode())
+            console.log(chalk.dim(`  ⏭  Skipped: ${command}`));
+        return denied;
     }
     if (runInBackground) {
         return runBackgroundCommand(context, command, args.timeout_ms, repoHint);