@compass-ai/nova 1.0.72 → 1.0.74

package/dist/services/sdk-runner.js

@@ -0,0 +1,1424 @@
+/**
+ * SDK Runner Service for non-interactive CLI mode
+ *
+ * This service handles the -p flag functionality where the CLI runs a single
+ * query and exits. It provides the full agentic experience (tools, MCP, etc.)
+ * with output suitable for programmatic consumption.
+ *
+ * Key features:
+ * - Full agentic loop with tool execution
+ * - MCP tool integration
+ * - Streaming output to stdout
+ * - Auto-approval mode for non-interactive use
+ * - Piped input support with size limits
+ */
+import { getAnthropicClient } from './anthropic-client.js';
+import { getSessionManager } from './session-manager.js';
+import { getTokenTracker } from './token-tracker.js';
+import { getConfigManager } from './config-manager.js';
+import { getConsentManager } from './consent-manager.js';
+import { getCredentialStore } from './credential-store.js';
+import { getContextBuilder } from '../core/context-builder.js';
+import { getToolRegistry } from './tool-registry.js';
+import { registerBuiltInTools } from '../tools/index.js';
+import { getMCPToolIntegration } from './mcp-tool-integration.js';
+import { getApprovalManager } from './approval-manager.js';
+import { getAuditLogger } from './audit-logger.js';
+import { buildSystemPrompt } from '../prompts/index.js';
+import { getSystemUtilitiesPromptSection } from './system-utility-detector.js';
+import { loadAllMemory } from './memory-service.js';
+import { ensureDir } from '../utils/file-system.js';
+import { getGlobalCompassDir, getProjectCompassDir } from '../utils/path.js';
+import { logger } from '../utils/logger.js';
+import { buildAttachmentContentBlocks } from '../utils/attachment-handler.js';
+import { ApprovalMode } from '../types/approval.js';
+import { getCompassAuthService } from './compass-auth-service.js';
+import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_AGENTIC_ITERATIONS } from '../constants/defaults.js';
+import chalk from 'chalk';
+/** Maximum size for piped input in bytes (100KB) */
+const MAX_PIPED_INPUT_SIZE = 100 * 1024;
+/** Timeout for reading stdin in milliseconds */
+const STDIN_READ_TIMEOUT = 500;
+/**
+ * Extracts a short summary from an error message
+ */
+function summarizeError(error) {
+    // Extract key information from common error patterns
+    if (error.includes('not unique')) {
+        const match = error.match(/Found (\d+) occurrences/i);
+        return match ? `non-unique match (${match[1]} occurrences)` : 'non-unique match';
+    }
+    if (error.includes('not found in file')) {
+        return 'text not found';
+    }
+    if (error.includes('Permission denied')) {
+        return 'permission denied';
+    }
+    if (error.includes('File not found') || error.includes('ENOENT')) {
+        return 'file not found';
+    }
+    // Fallback: truncate long errors
+    const cleanError = error.replace(/^Error:\s*/i, '');
+    return cleanError.length > 50 ? cleanError.slice(0, 47) + '...' : cleanError;
+}
+/**
+ * Checks if the current tool call is a retry of the previous failed tool
+ */
+function isConsecutiveRetry(currentToolName, currentInput, retryState) {
+    if (!retryState)
+        return false;
+    // Must be the same tool
+    if (retryState.toolName !== currentToolName)
+        return false;
+    // For file-based tools, check if targeting the same file
+    const fileTools = ['edit_file', 'read_file', 'write_file'];
+    if (fileTools.includes(currentToolName)) {
+        const currentPath = currentInput.path;
+        if (currentPath && retryState.targetPath && currentPath !== retryState.targetPath) {
+            return false; // Different file, not a retry
+        }
+    }
+    return true;
+}
+/**
+ * Annotates tool result content with retry information
+ */
+function annotateToolResult(content, isError, attemptCount, previousErrors) {
+    if (attemptCount <= 1) {
+        return content; // First attempt, no annotation needed
+    }
+    const previousSummary = previousErrors.join(' → ');
+    if (isError) {
+        // Still failing - show attempt count and history
+        return `[Attempt ${attemptCount}] ${content}\n\n--- Previous attempts ---\n${previousErrors.map((e, i) => `#${i + 1}: ${e}`).join('\n')}`;
+    }
+    else {
+        // Success after failures - show resolution info
+        return `${content}\n\n[Resolved after ${attemptCount} attempts. Previous errors: ${previousSummary}]`;
+    }
+}
+/**
+ * Reads piped input from stdin with size limit and timeout
+ * @returns The piped content or undefined if no pipe or empty
+ */
+export async function readStdin() {
+    // Only read stdin if data is being piped (not a TTY)
+    if (process.stdin.isTTY) {
+        return undefined;
+    }
+    return new Promise((resolve) => {
+        let data = '';
+        let resolved = false;
+        const finish = (result) => {
+            if (!resolved) {
+                resolved = true;
+                process.stdin.removeAllListeners();
+                process.stdin.pause();
+                resolve(result);
+            }
+        };
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+            // Check size limit
+            if (Buffer.byteLength(data, 'utf8') > MAX_PIPED_INPUT_SIZE) {
+                logger.warn(`Piped input exceeds ${MAX_PIPED_INPUT_SIZE / 1024}KB limit, truncating`);
+                data = data.slice(0, MAX_PIPED_INPUT_SIZE);
+                finish(data);
+            }
+        });
+        process.stdin.on('end', () => {
+            finish(data || undefined);
+        });
+        process.stdin.on('error', (err) => {
+            logger.debug('Error reading stdin', err);
+            finish(undefined);
+        });
+        // Timeout to avoid hanging if no data
+        setTimeout(() => {
+            finish(data || undefined);
+        }, STDIN_READ_TIMEOUT);
+        // Start reading
+        process.stdin.resume();
+    });
+}
+/**
+ * Maps agent-friendly tool aliases to registered tool names.
+ * Agent definitions use Claude-Code-style names (Read, Grep, Bash, etc.)
+ * but tools are registered with different names (read_file, search_code, etc.).
+ */
+const TOOL_NAME_ALIASES = {
+    'grep': 'search_code',
+    'bash': 'execute_command',
+    'askuserquestion': 'ask_user',
+    'notebookedit': 'notebook_edit',
+    // Swarm tools
+    'spawnteam': 'spawn_team',
+    'getteamstatus': 'get_team_status',
+    'listteams': 'list_teams',
+    'cancelteam': 'cancel_team',
+    'teammessage': 'team_message',
+};
+/**
+ * Builds a set of tool names that are allowed by an agent's allowedTools list.
+ * Resolves aliases and display names to actual registered tool names.
+ */
+function resolveAllowedToolNames(allowedTools, toolRegistry) {
+    const resolvedNames = new Set();
+    for (const alias of allowedTools) {
+        const lower = alias.toLowerCase();
+        // Check direct alias mapping
+        if (TOOL_NAME_ALIASES[lower]) {
+            resolvedNames.add(TOOL_NAME_ALIASES[lower]);
+        }
+        // Also add the raw name (handles cases where allowedTools uses the actual name)
+        resolvedNames.add(lower);
+    }
+    // Now build the final set: for each registered tool, check if it matches
+    const allTools = toolRegistry.getToolDefinitions({ includeDisabled: true });
+    const matchedNames = new Set();
+    for (const tool of allTools) {
+        const toolNameLower = tool.name.toLowerCase();
+        const displayNameLower = toolRegistry.getDisplayName(tool.name).toLowerCase();
+        if (resolvedNames.has(toolNameLower) || resolvedNames.has(displayNameLower)) {
+            matchedNames.add(tool.name);
+        }
+    }
+    return matchedNames;
+}
+/**
+ * Tools that are safe to execute in parallel (read-only, no side effects)
+ */
+const PARALLEL_SAFE_TOOLS = new Set([
+    // File reads
+    'read_file',
+    'read_media_file',
+    'read_multiple_files',
+    // Directory operations (read-only)
+    'list_files',
+    'list_directory',
+    'list_directory_with_sizes',
+    'directory_tree',
+    'get_file_info',
+    // Search operations
+    'search_code',
+    'find_files',
+    'analyze_dependencies',
+    // Git read operations
+    'git_status',
+    'git_diff',
+    'git_log',
+    // Process/task listing
+    'list_processes',
+    'list_tasks',
+    // NOTE: poll_task is NOT parallel-safe because it blocks by default until completion
+    'list_skills',
+]);
+/**
+ * Determines if a tool call is safe to execute in parallel
+ */
+function isParallelSafe(toolName, toolInput) {
+    // Check if tool is in the safe list
+    if (PARALLEL_SAFE_TOOLS.has(toolName)) {
+        return true;
+    }
+    // Special case: execute_command is safe if it's a read-only command
+    if (toolName === 'execute_command') {
+        const command = String(toolInput.command || '').trim().toLowerCase();
+        // Common read-only command patterns
+        const readOnlyPatterns = [
+            /^git\s+(status|diff|log|show|branch|tag)/,
+            /^ls\b/,
+            /^cat\b/,
+            /^echo\b/,
+            /^pwd\b/,
+            /^whoami\b/,
+            /^which\b/,
+            /^where\b/,
+            /^node\s+--version/,
+            /^npm\s+(list|ls|view|show)/,
+            /^yarn\s+(list|info)/,
+            /^pnpm\s+list/,
+            /^python\s+--version/,
+            /^java\s+-version/,
+        ];
+        return readOnlyPatterns.some(pattern => pattern.test(command));
+    }
+    // Default to sequential for safety
+    return false;
+}
+/**
+ * Executes a single tool call and returns formatted results
+ */
+async function executeSingleTool(toolUse, projectRoot, toolRegistry) {
+    const startTime = Date.now();
+    let userRejected = false;
+    let endTurn = false;
+    try {
+        const result = await toolRegistry.executeTool(toolUse.name, toolUse.input, { projectRoot, toolCallId: toolUse.id });
+        const duration = Date.now() - startTime;
+        if (result.success) {
+            const toolData = result.data;
+            const isToolRejection = toolData?.success === false &&
+                (String(toolData?.error || '').toLowerCase().includes('rejected by user') ||
+                    String(toolData?.error || '').toLowerCase().includes('rejected'));
+            // Check if a plan was cancelled — this signals the turn should end
+            if (toolData?.planCancelled === true) {
+                endTurn = true;
+                logger.info(`Plan cancelled via ${toolUse.name} — will end turn`);
+            }
+            if (isToolRejection) {
+                userRejected = true;
+                return {
+                    toolResult: {
+                        type: 'tool_result',
+                        tool_use_id: toolUse.id,
+                        content: `Error: ${toolData?.error || 'Operation rejected by user'}`,
+                        is_error: true,
+                    },
+                    toolRecord: {
+                        name: toolUse.name,
+                        input: toolUse.input,
+                        result: null,
+                        success: false,
+                        error: String(toolData?.error || 'Operation rejected by user'),
+                        duration_ms: duration,
+                    },
+                    userRejected,
+                    endTurn,
+                };
+            }
+            else {
+                logger.debug(`Tool ${toolUse.name} succeeded in ${duration}ms`);
+                return {
+                    toolResult: {
+                        type: 'tool_result',
+                        tool_use_id: toolUse.id,
+                        content: JSON.stringify(result.data, null, 2),
+                    },
+                    toolRecord: {
+                        name: toolUse.name,
+                        input: toolUse.input,
+                        result: result.data,
+                        success: true,
+                        duration_ms: duration,
+                    },
+                    userRejected,
+                    endTurn,
+                };
+            }
+        }
+        else {
+            const isUserRejection = result.error?.toLowerCase().includes('rejected by user') ||
+                result.error?.toLowerCase().includes('rejected');
+            if (isUserRejection) {
+                userRejected = true;
+            }
+            logger.debug(`Tool ${toolUse.name} failed: ${result.error}`);
+            return {
+                toolResult: {
+                    type: 'tool_result',
+                    tool_use_id: toolUse.id,
+                    content: `Error: ${result.error}`,
+                    is_error: true,
+                },
+                toolRecord: {
+                    name: toolUse.name,
+                    input: toolUse.input,
+                    result: null,
+                    success: false,
+                    error: result.error,
+                    duration_ms: duration,
+                },
+                userRejected,
+                endTurn,
+            };
+        }
+    }
+    catch (err) {
+        const duration = Date.now() - startTime;
+        const errorMsg = err instanceof Error ? err.message : 'Tool execution failed';
+        logger.error(`Tool ${toolUse.name} threw error`, err);
+        return {
+            toolResult: {
+                type: 'tool_result',
+                tool_use_id: toolUse.id,
+                content: `Error: ${errorMsg}`,
+                is_error: true,
+            },
+            toolRecord: {
+                name: toolUse.name,
+                input: toolUse.input,
+                result: null,
+                success: false,
+                error: errorMsg,
+                duration_ms: duration,
+            },
+            userRejected,
+            endTurn,
+        };
+    }
+}
+/**
+ * Executes tool calls and returns tool results.
+ * Automatically runs tools in parallel when safe to do so.
+ */
+async function executeToolCalls(toolUseBlocks, projectRoot) {
+    const toolRegistry = getToolRegistry();
+    let userRejected = false;
+    let endTurn = false;
+    // Check if all tools are safe for parallel execution
+    const allSafeForParallel = toolUseBlocks.every(toolUse => isParallelSafe(toolUse.name, toolUse.input));
+    if (allSafeForParallel && toolUseBlocks.length > 1) {
+        // Execute all tools in parallel
+        logger.debug(`Executing ${toolUseBlocks.length} tools in parallel: ${toolUseBlocks.map(t => t.name).join(', ')}`);
+        const executionPromises = toolUseBlocks.map(toolUse => executeSingleTool(toolUse, projectRoot, toolRegistry));
+        const executionResults = await Promise.all(executionPromises);
+        // Extract results and check for user rejections
+        const toolResults = [];
+        const toolRecords = [];
+        for (const execResult of executionResults) {
+            toolResults.push(execResult.toolResult);
+            toolRecords.push(execResult.toolRecord);
+            if (execResult.userRejected) {
+                userRejected = true;
+            }
+            if (execResult.endTurn) {
+                endTurn = true;
+            }
+        }
+        return { results: toolResults, records: toolRecords, userRejected, endTurn };
+    }
+    else {
+        // Execute tools sequentially (original behavior)
+        if (toolUseBlocks.length > 1) {
+            logger.debug(`Executing ${toolUseBlocks.length} tools sequentially (contains write operations)`);
+        }
+        const toolResults = [];
+        const toolRecords = [];
+        for (const toolUse of toolUseBlocks) {
+            logger.debug(`Executing tool: ${toolUse.name}`);
+            const execResult = await executeSingleTool(toolUse, projectRoot, toolRegistry);
+            toolResults.push(execResult.toolResult);
+            toolRecords.push(execResult.toolRecord);
+            if (execResult.userRejected) {
+                userRejected = true;
+            }
+            if (execResult.endTurn) {
+                endTurn = true;
+            }
+        }
+        return { results: toolResults, records: toolRecords, userRejected, endTurn };
+    }
+}
+/**
+ * Runs a single query in non-interactive mode with full agentic capabilities
+ * Outputs response to stdout for programmatic consumption
+ */
+export async function runSDKQuery(options) {
+    const { query, pipedInput, attachments, projectRoot, continueSession, debug, autoApprove = true, cliAgentsJson, agentConfig, standaloneAgent, callbacks, silent = false, } = options;
+    // Helper to emit text chunks via callback or stdout
+    const emitTextChunk = (chunk) => {
+        if (callbacks?.onTextChunk) {
+            callbacks.onTextChunk(chunk);
+        }
+        if (!silent) {
+            process.stdout.write(chunk);
+        }
+    };
+    // Helper to emit status updates via callback or stderr
+    const emitStatus = (status) => {
+        if (callbacks?.onStatusUpdate) {
+            callbacks.onStatusUpdate(status);
+        }
+    };
+    // Helper to emit tool events
+    const emitToolStart = (toolName, toolId, input) => {
+        if (callbacks?.onToolStart) {
+            callbacks.onToolStart(toolName, toolId, input);
+        }
+    };
+    const emitToolComplete = (toolName, toolId, result, success, error) => {
+        if (callbacks?.onToolComplete) {
+            callbacks.onToolComplete(toolName, toolId, result, success, error);
+        }
+    };
+    // Helper to emit errors
+    const emitError = (error) => {
+        if (callbacks?.onError) {
+            callbacks.onError(error);
+        }
+        if (!silent) {
+            process.stderr.write(chalk.red(`Error: ${error}\n`));
+        }
+    };
+    if (debug) {
+        logger.configure({ level: 'debug' });
+    }
+    try {
+        // === SUBAGENT FAST-PATH ===
+        // When running as a subagent, skip all singleton re-initialization to avoid
+        // corrupting parent process state (model, session, approval mode, etc.)
+        // Uses the already-initialized singleton client but passes model per-call
+        // instead of mutating with setModel().
+        if (options.isSubagent) {
+            logger.debug('Running in subagent mode - skipping singleton re-initialization');
+            // Use the already-initialized singleton client (read-only - never call setModel)
+            const client = await getAnthropicClient();
+            if (!client.isInitialized()) {
+                emitError('Subagent: API client not initialized.');
+                return {
+                    success: false,
+                    content: '',
+                    error: 'Subagent: API client not initialized.',
+                    exitCode: 1,
+                };
+            }
+            // Resolve the model to use per-call (without mutating the singleton)
+            const { resolveModelId, getModelConfig } = await import('../constants/models.js');
+            let subagentModelId; // undefined = use client's current default
+            if (options.model) {
+                subagentModelId = options.model.modelId;
+                logger.debug(`Subagent using session model: ${options.model.providerId}/${subagentModelId}`);
+            }
+            if (agentConfig?.model && agentConfig.model !== 'inherit') {
+                subagentModelId = resolveModelId(agentConfig.model);
+                logger.debug(`Subagent using agent model: ${agentConfig.model} → ${subagentModelId}`);
+            }
+            // Resolve model config for system prompt (without mutating singleton)
+            const modelConfig = subagentModelId
+                ? (getModelConfig(subagentModelId) || client.getCurrentModel())
+                : client.getCurrentModel();
+            // Reuse existing tool registry (already registered by parent)
+            const toolRegistry = getToolRegistry();
+            let tools = toolRegistry.getToolDefinitions();
+            // Filter tools if agent has allowedTools restriction
+            if (agentConfig?.allowedTools && agentConfig.allowedTools.length > 0) {
+                const allowedNames = resolveAllowedToolNames(agentConfig.allowedTools, toolRegistry);
+                tools = tools.filter(tool => allowedNames.has(tool.name));
+                logger.debug(`Subagent filtered tools (${tools.length} matched): ${tools.map(t => t.name).join(', ')}`);
+            }
+            // Build system prompt
+            const contextBuilder = getContextBuilder({ projectRoot });
+            const projectSummary = await contextBuilder.getProjectSummary();
+            let systemPrompt;
+            if (standaloneAgent && agentConfig?.systemPrompt) {
+                systemPrompt = agentConfig.systemPrompt;
+            }
+            else {
+                const sessionManager = getSessionManager();
+                const personalityMode = sessionManager.getEffectivePersonalityMode();
+                const unguardedMode = options.unguardedMode ?? sessionManager.getUnguardedMode();
+                let systemUtilitiesSection;
+                if (unguardedMode) {
+                    try {
+                        systemUtilitiesSection = await getSystemUtilitiesPromptSection();
+                    }
+                    catch (error) {
+                        logger.debug('Failed to generate system utilities section', error);
+                    }
+                }
+                systemPrompt = buildSystemPrompt({
+                    projectSummary: projectSummary ? { formatted: projectSummary.formatted } : null,
+                    workingDirectory: projectRoot,
+                    modelName: modelConfig.name,
+                    modelId: modelConfig.id,
+                    personalityMode,
+                    unguardedMode,
+                    systemUtilitiesSection,
+                });
+                if (agentConfig?.systemPrompt) {
+                    systemPrompt = `${agentConfig.systemPrompt}\n\n---\n\n${systemPrompt}`;
+                }
+            }
+            if (options.systemPromptAddition) {
+                systemPrompt = `${systemPrompt}\n\n${options.systemPromptAddition}`;
+            }
+            // Append memory content (NOVA.md + auto memory)
+            try {
+                const memoryContent = await loadAllMemory(projectRoot);
+                if (memoryContent) {
+                    systemPrompt = `${systemPrompt}\n\n${memoryContent}`;
+                }
+            }
+            catch (error) {
+                logger.debug('Failed to load memory content for subagent', error);
+            }
+            // Build user message
+            let userContent = query;
+            if (pipedInput && pipedInput.trim()) {
+                userContent = `Context:\n\`\`\`\n${pipedInput.trim()}\n\`\`\`\n\n${query}`;
+            }
+            let userMessageContent = userContent;
+            if (attachments && attachments.length > 0) {
+                const attachmentBlocks = buildAttachmentContentBlocks(attachments);
+                userMessageContent = [
+                    { type: 'text', text: userContent },
+                    ...attachmentBlocks,
+                ];
+            }
+            const messages = [];
+            messages.push({ role: 'user', content: userMessageContent });
+            // === SUBAGENT AGENTIC LOOP ===
+            const configManager = getConfigManager();
+            const agenticConfig = configManager.getValue('agentic');
+            const maxIterations = agenticConfig?.maxIterations ?? DEFAULT_MAX_AGENTIC_ITERATIONS;
+            let iterations = 0;
+            let accumulatedText = '';
+            let finalResponse = '';
+            let hasStartedOutput = false;
+            let toolRetryState = null;
+            while (iterations < maxIterations) {
+                iterations++;
+                // Cancellation check
+                if (options.processId) {
+                    const { getAgentSpawner } = await import('./agent-spawner.js');
+                    const spawner = getAgentSpawner();
+                    const proc = spawner.getProcess(options.processId);
+                    if (proc?.status === 'cancelled') {
+                        finalResponse = accumulatedText + '\n\n*(Process cancelled)*';
+                        break;
+                    }
+                }
+                // Budget enforcement
+                if (options.budget) {
+                    const budget = options.budget;
+                    if (budget.turnsUsed >= budget.maxTurns) {
+                        finalResponse = accumulatedText + '\n\n*(Turn budget exceeded)*';
+                        if (options.onBudgetExceeded)
+                            options.onBudgetExceeded('turns');
+                        break;
+                    }
+                    if (budget.tokensUsed >= budget.maxTokens) {
+                        finalResponse = accumulatedText + '\n\n*(Token budget exceeded)*';
+                        if (options.onBudgetExceeded)
+                            options.onBudgetExceeded('tokens');
+                        break;
+                    }
+                }
+                if (callbacks?.onIterationStart) {
+                    callbacks.onIterationStart(iterations, maxIterations);
+                }
+                // Pass model per-call to avoid mutating the singleton
+                const response = await client.createAgenticMessage(messages, { system: systemPrompt, tools, maxTokens: DEFAULT_MAX_TOKENS, model: subagentModelId }, (chunk) => {
+                    accumulatedText += chunk;
+                    if (!hasStartedOutput)
+                        hasStartedOutput = true;
+                    emitTextChunk(chunk);
+                }, (toolEvent) => {
+                    if (toolEvent.type === 'tool_start') {
+                        emitToolStart(toolEvent.name, toolEvent.id, {});
+                    }
+                    else if (toolEvent.type === 'tool_complete') {
+                        emitToolComplete(toolEvent.name, toolEvent.id, toolEvent.input, true);
+                    }
+                });
+                // Budget tracking
+                if (options.budget) {
+                    const tokensThisTurn = response.usage.inputTokens + response.usage.outputTokens;
+                    options.budget.tokensUsed += tokensThisTurn;
+                    options.budget.turnsUsed = iterations;
+                }
+                if (response.stopReason === 'max_tokens') {
+                    messages.push({ role: 'assistant', content: response.contentBlocks });
+                    messages.push({ role: 'user', content: 'Continue from where you left off.' });
+                    continue;
+                }
+                if (response.stopReason !== 'tool_use' || response.toolUseBlocks.length === 0) {
+                    finalResponse = accumulatedText;
+                    break;
+                }
+                // Execute tool calls
+                const { results: toolResults, records: toolRecords, endTurn } = await executeToolCalls(response.toolUseBlocks, projectRoot);
+                // End turn check (plan cancellation)
+                if (endTurn) {
+                    logger.info('End turn signalled (plan cancelled) — stopping subagent agentic loop');
+                    finalResponse = accumulatedText;
+                    break;
+                }
+                // Cancellation check after tools
+                if (options.processId) {
+                    const { getAgentSpawner } = await import('./agent-spawner.js');
+                    const spawner = getAgentSpawner();
+                    const proc = spawner.getProcess(options.processId);
+                    if (proc?.status === 'cancelled') {
+                        finalResponse = accumulatedText + '\n\n*(Process cancelled)*';
+                        break;
+                    }
+                }
+                // Tool retry replacement logic (same as parent loop)
+                const isSingleToolCall = response.toolUseBlocks.length === 1;
+                const singleTool = isSingleToolCall ? response.toolUseBlocks[0] : null;
+                const singleToolResult = isSingleToolCall ? toolResults[0] : null;
+                const singleToolRecord = isSingleToolCall ? toolRecords[0] : null;
+                const shouldReplace = isSingleToolCall && singleTool && toolRetryState &&
+                    isConsecutiveRetry(singleTool.name, singleTool.input, toolRetryState);
+                if (shouldReplace && singleToolResult && singleToolRecord) {
+                    const isCurrentError = singleToolResult.is_error === true;
+                    const currentContent = singleToolResult.content;
+                    if (isCurrentError) {
+                        toolRetryState.attemptCount++;
+                        toolRetryState.previousErrors.push(summarizeError(currentContent));
+                    }
+                    const annotatedContent = annotateToolResult(currentContent, isCurrentError, toolRetryState.attemptCount, toolRetryState.previousErrors.slice(0, -1));
+                    const annotatedToolResult = { ...singleToolResult, content: annotatedContent };
+                    messages.pop();
+                    messages.pop();
+                    messages.push({ role: 'assistant', content: response.contentBlocks });
+                    messages.push({ role: 'user', content: [annotatedToolResult] });
+                    if (!isCurrentError)
+                        toolRetryState = null;
+                }
+                else {
+                    messages.push({ role: 'assistant', content: response.contentBlocks });
+                    messages.push({ role: 'user', content: toolResults });
+                    if (isSingleToolCall && singleToolRecord && !singleToolRecord.success) {
+                        const toolInput = singleTool.input;
+                        toolRetryState = {
+                            toolName: singleTool.name,
+                            targetPath: toolInput.path,
+                            attemptCount: 1,
+                            previousErrors: [summarizeError(singleToolRecord.error || 'Unknown error')],
+                        };
+                    }
+                    else {
+                        toolRetryState = null;
+                    }
+                }
+                if (iterations >= maxIterations) {
+                    finalResponse = accumulatedText + '\n\n*(Reached maximum iterations)*';
+                    break;
+                }
+            }
+            if (callbacks?.onComplete) {
+                callbacks.onComplete(finalResponse, { inputTokens: 0, outputTokens: 0, totalTokens: 0 }, { inputCost: 0, outputCost: 0, totalCost: 0, currency: 'USD' });
+            }
+            return {
+                success: true,
+                content: finalResponse,
+                exitCode: 0,
+            };
+        }
+        // === INITIALIZATION PHASE (parent / non-subagent path) ===
+        const _diag = silent
+            ? (step) => process.stderr.write(`[SDK-DIAG] ${step} (${Date.now()})\n`)
+            : (step) => logger.debug(`[SDK-DIAG] ${step}`);
+        // Ensure directories exist
+        _diag('ensureDir START');
+        await ensureDir(getGlobalCompassDir());
+        await ensureDir(getProjectCompassDir(projectRoot));
+        _diag('ensureDir DONE');
+        // Load configuration
+        _diag('configManager.load START');
+        const configManager = getConfigManager();
+        await configManager.load(projectRoot);
+        _diag('configManager.load DONE');
+        // Check consent
+        _diag('consentManager START');
+        const consentManager = await getConsentManager();
+        const consentStatus = await consentManager.getStatus();
+        _diag('consentManager DONE');
+        if (!consentStatus.isValid) {
+            emitError('Consent not granted. Run "compass setup" first.');
+            return {
+                success: false,
+                content: '',
+                error: 'Consent not granted. Run "compass setup" first.',
+                exitCode: 1,
+            };
+        }
+        // Check API key
+        _diag('credentialStore START');
+        const credentialStore = await getCredentialStore();
+        const hasApiKey = await credentialStore.hasApiKey();
+        _diag('credentialStore DONE');
+        if (!hasApiKey) {
+            emitError('API key not configured. Run "compass setup" first.');
+            return {
+                success: false,
+                content: '',
+                error: 'API key not configured. Run "compass setup" first.',
+                exitCode: 1,
+            };
+        }
+        // Initialize Anthropic client
+        _diag('client.initialize START');
+        const client = await getAnthropicClient();
+        const initialized = await client.initialize();
+        _diag('client.initialize DONE');
+        if (!initialized) {
+            emitError('Failed to initialize API client.');
+            return {
+                success: false,
+                content: '',
+                error: 'Failed to initialize API client.',
+                exitCode: 1,
+            };
+        }
+        // Validate Compass API key to resolve subscription/plan status
+        // Without this, compassAuth defaults to 'no_subscription' (150K limit)
+        _diag('compassAuth.validateApiKey START');
+        try {
+            const compassAuth = getCompassAuthService();
+            const compassKey = await credentialStore.getCompassApiKey();
+            if (compassKey) {
+                await compassAuth.validateApiKey(compassKey);
+                logger.debug(`SDK mode plan status: ${compassAuth.getPlanStatus()}`);
+            }
+        }
+        catch (planError) {
+            logger.warn('Failed to validate Compass API key in SDK mode', planError);
+            // Non-fatal — defaults to no_subscription limits
+        }
+        _diag('compassAuth.validateApiKey DONE');
+        // Initialize token tracker
+        _diag('tokenTracker START');
+        const tokenTracker = await getTokenTracker();
+        tokenTracker.startSession();
+        _diag('tokenTracker DONE');
+        // Register built-in tools
+        _diag('registerBuiltInTools START');
+        await registerBuiltInTools();
+        _diag('registerBuiltInTools DONE');
+        // Initialize MCP tool integration
+        _diag('mcpToolIntegration.initialize START');
+        try {
+            const mcpToolIntegration = getMCPToolIntegration();
+            await mcpToolIntegration.initialize(projectRoot);
+            logger.debug('MCP tool integration initialized');
+        }
+        catch (mcpError) {
+            logger.warn('Failed to initialize MCP tool integration', mcpError);
+            // Non-fatal - continue without MCP tools
+        }
+        _diag('mcpToolIntegration.initialize DONE');
+        // Initialize skill service with project root
+        const { setSkillProjectRoot } = await import('./skill-service.js');
+        setSkillProjectRoot(projectRoot);
+        // Initialize custom command service with project root
+        const { setCommandsProjectRoot } = await import('./custom-command-service.js');
+        setCommandsProjectRoot(projectRoot);
+        // Initialize hook service with project root
+        const { setHooksProjectRoot } = await import('./hook-service.js');
+        setHooksProjectRoot(projectRoot);
+        // Initialize agent manager with CLI agents if provided
+        if (cliAgentsJson) {
+            try {
+                const { initializeAgentManager } = await import('./agent-manager.js');
+                await initializeAgentManager(projectRoot, cliAgentsJson);
+                logger.debug('Agent manager initialized with CLI agents');
+            }
+            catch (agentError) {
+                logger.warn('Failed to initialize agent manager with CLI agents', agentError);
+                // Non-fatal - continue without CLI agents
+            }
+        }
+        // Apply model configuration if provided (e.g., from ACP session)
+        // This takes precedence over the default model but can be overridden by agentConfig
+        if (options.model) {
+            const modelIdToSet = options.model.modelId;
+            client.setModel(modelIdToSet);
+            logger.debug(`Switched to session model: ${options.model.providerId}/${modelIdToSet}`);
+        }
+        // Apply agent configuration if provided
+        if (agentConfig) {
+            logger.info(`Running with agent: ${agentConfig.name}`);
+            // Switch model if agent specifies one (overrides session model)
+            if (agentConfig.model && agentConfig.model !== 'inherit') {
+                const { resolveModelId } = await import('../constants/models.js');
+                const resolvedModelId = resolveModelId(agentConfig.model);
+                client.setModel(resolvedModelId);
+                logger.debug(`Switched to agent model: ${agentConfig.model}`);
+            }
+        }
+        // Set approval mode for non-interactive use
+        const approvalManager = getApprovalManager();
+        if (autoApprove) {
+            approvalManager.setMode(ApprovalMode.AUTO);
+            approvalManager.enableSessionAutoApproval();
+            logger.debug('Auto-approval enabled for non-interactive mode');
+        }
+        // Initialize session manager
+        _diag('sessionManager.load START');
+        const sessionManager = getSessionManager();
+        const existingSession = await sessionManager.load(projectRoot);
+        _diag('sessionManager.load DONE');
+        if (!existingSession) {
+            sessionManager.createSession(projectRoot);
+        }
+        // Initialize audit logger
+        const auditLogger = getAuditLogger(projectRoot);
+        const session = sessionManager.getSession();
+        if (session) {
+            auditLogger.setSessionId(session.id);
+        }
+        // Get conversation history and handle archival
+        _diag('sessionArchival START');
+        let messages = [];
+        const state = sessionManager.getState();
+        const hasHistory = state?.conversationHistory && state.conversationHistory.length > 0;
+        const hasOperations = state?.operations && state.operations.length > 0;
+        if (hasHistory) {
+            if (continueSession) {
+                // -c flag: Archive, load messages into context, then clear session.json
+                const { archive, result } = await sessionManager.archiveAndClearSession();
+                if (result.success && result.filename) {
+                    logger.info(`Archived previous session to: ${result.filename}`);
+                }
+                // Load archived messages into context
+                if (archive && archive.messages.length > 0) {
+                    messages = archive.messages.map((msg) => ({
+                        role: msg.role,
+                        content: msg.content,
+                    }));
+                    logger.debug(`Continuing with ${messages.length} archived messages`);
+                }
+            }
+            else {
+                // No -c flag: Archive and clear, don't load into context
+                const { result } = await sessionManager.archiveAndClearSession();
+                if (result.success && result.filename) {
+                    logger.info(`Archived previous session to: ${result.filename}`);
+                }
+            }
+        }
+        else {
+            // No conversation history — clear stale operations if any
+            if (hasOperations) {
+                sessionManager.clearHistory();
+            }
+            // -c flag: load latest archive even when session is clean
+            if (continueSession) {
+                const archivalService = sessionManager.getArchivalService();
+                const archive = await archivalService.getLatestArchive();
+                if (archive && archive.messages.length > 0) {
+                    messages = archive.messages.map((msg) => ({
+                        role: msg.role,
+                        content: msg.content,
+                    }));
+                    logger.debug(`Continuing with ${messages.length} messages from latest archive`);
+                }
+            }
+        }
+        _diag('sessionArchival DONE');
+        // Build the user message with optional piped context and attachments
+        let userContent = query;
+        if (pipedInput && pipedInput.trim()) {
+            userContent = `Context:\n\`\`\`\n${pipedInput.trim()}\n\`\`\`\n\n${query}`;
+        }
+        // Handle file attachments if provided
+        let userMessageContent = userContent;
+        if (attachments && attachments.length > 0) {
+            // Build ContentBlock[] with text and attachments
+            const attachmentBlocks = buildAttachmentContentBlocks(attachments);
+            userMessageContent = [
+                { type: 'text', text: userContent },
+                ...attachmentBlocks,
+            ];
+            logger.info(`Added ${attachments.length} file attachment(s) to user message`);
+        }
+        // Add user message
+        messages.push({
+            role: 'user',
+            content: userMessageContent,
+        });
+        // Build system prompt with project context
+        _diag('contextBuilder.getProjectSummary START');
+        const contextBuilder = getContextBuilder({ projectRoot });
+        const projectSummary = await contextBuilder.getProjectSummary();
+        _diag('contextBuilder.getProjectSummary DONE');
+        const model = client.getCurrentModel();
+        let systemPrompt;
+        // Handle standalone agent mode - use ONLY the agent's system prompt
+        if (standaloneAgent && agentConfig?.systemPrompt) {
+            systemPrompt = agentConfig.systemPrompt;
+            logger.info(`Running in standalone agent mode - using only agent's system prompt (${agentConfig.systemPrompt.length} chars)`);
+        }
+        else {
+            // Get personality mode and unguarded mode from session (prefer explicit option over singleton)
+            const sessionManager = getSessionManager();
+            const personalityMode = sessionManager.getEffectivePersonalityMode();
+            const unguardedMode = options.unguardedMode ?? sessionManager.getUnguardedMode();
+            // Get system utilities section for unguarded mode
+            let systemUtilitiesSection;
+            if (unguardedMode) {
+                try {
+                    systemUtilitiesSection = await getSystemUtilitiesPromptSection();
+                    if (systemUtilitiesSection) {
+                        logger.debug('System utilities section generated for unguarded mode');
+                    }
+                }
+                catch (error) {
+                    logger.debug('Failed to generate system utilities section', error);
+                }
+            }
+            // Build default CLI system prompt with personality and unguarded mode
+            systemPrompt = buildSystemPrompt({
+                projectSummary: projectSummary ? { formatted: projectSummary.formatted } : null,
+                workingDirectory: projectRoot,
+                modelName: model.name,
+                modelId: model.id,
+                personalityMode,
+                unguardedMode,
+                systemUtilitiesSection,
+            });
+            // Prepend agent's system prompt if provided (non-standalone mode)
+            if (agentConfig?.systemPrompt) {
+                systemPrompt = `${agentConfig.systemPrompt}\n\n---\n\n${systemPrompt}`;
+                logger.debug(`Applied agent system prompt (${agentConfig.systemPrompt.length} chars)`);
+            }
+        }
+        // Apply mode-specific system prompt additions
+        if (options.systemPromptAddition) {
+            systemPrompt = `${systemPrompt}\n\n${options.systemPromptAddition}`;
+            logger.debug(`Applied system prompt addition (${options.systemPromptAddition.length} chars)`);
+        }
+        // Append memory content (NOVA.md + auto memory)
+        _diag('loadAllMemory START');
+        try {
+            const memoryContent = await loadAllMemory(projectRoot);
+            if (memoryContent) {
+                systemPrompt = `${systemPrompt}\n\n${memoryContent}`;
+                logger.debug(`Applied memory content (${memoryContent.length} chars)`);
+            }
+        }
+        catch (error) {
+            logger.debug('Failed to load memory content', error);
+        }
+        _diag('loadAllMemory DONE');
+        // Apply plan mode instructions if forced
+        if (options.forcePlanMode) {
+            const planModeInstructions = `
+## ⚠️ PLAN MODE ENFORCED - MANDATORY TOOL CALL REQUIRED
+
+**CRITICAL REQUIREMENT**: You MUST call the \`enter_plan_mode\` tool as your FIRST action for ANY task that involves code changes, file modifications, or implementation work.
+
+### Mandatory First Step
+Before doing ANYTHING else, call:
+\`\`\`
+enter_plan_mode({ task_summary: "<brief description of the task>" })
+\`\`\`
+
+### Rules You MUST Follow
+1. **ALWAYS call \`enter_plan_mode\` FIRST** - No exceptions. Do not analyze, do not explain, do not read files first. Call the tool immediately.
+2. **NO direct implementation** - You are FORBIDDEN from using file editing tools (edit_file, write_file) until a plan is approved.
+3. **NO skipping** - Even for "simple" tasks, you must use \`enter_plan_mode\`. The tool will assess complexity.
+4. **Wait for approval** - After the plan is generated, wait for user approval before executing any changes.
+
+### What Happens If You Don't Comply
+If you attempt to make code changes without first calling \`enter_plan_mode\`, you are violating the user's explicit mode selection. The user chose Plan Mode because they want to review and approve changes before they happen.
+
+### After Plan Approval
+- Execute tasks one at a time
+- Call \`complete_plan_task\` after each task
+- If issues arise, call \`update_plan\` instead of improvising
+
+**START by calling \`enter_plan_mode\` NOW.**
+`;
+            systemPrompt = `${systemPrompt}\n\n${planModeInstructions}`;
+            logger.debug('Applied plan mode enforcement instructions');
+        }
+        // Log for audit
+        await auditLogger.logUserInput(userContent, false);
+        await auditLogger.logSystemPrompt(systemPrompt);
+        // Get tool definitions
+        const toolRegistry = getToolRegistry();
+        let tools = toolRegistry.getToolDefinitions();
+        // Filter tools if agent has allowedTools restriction
+        if (agentConfig?.allowedTools && agentConfig.allowedTools.length > 0) {
+            const allowedNames = resolveAllowedToolNames(agentConfig.allowedTools, toolRegistry);
+            tools = tools.filter(tool => allowedNames.has(tool.name));
+            logger.debug(`Filtered tools to agent's allowed list (${tools.length} matched): ${tools.map(t => t.name).join(', ')}`);
+        }
+        // Filter MCP tools if agent has mcpServers restriction
+        if (agentConfig?.mcpServers && agentConfig.mcpServers.length > 0) {
+            const mcpToolIntegration = getMCPToolIntegration();
+            const allowedMcpTools = new Set(mcpToolIntegration.getFilteredToolNames(agentConfig.mcpServers).map(t => t.toLowerCase()));
+            // Keep non-MCP tools and only MCP tools from allowed servers
+            tools = tools.filter(tool => {
+                const isFromMcp = mcpToolIntegration.isMCPTool(tool.name);
+                if (!isFromMcp) {
+                    return true; // Keep all non-MCP tools
+                }
+                return allowedMcpTools.has(tool.name.toLowerCase());
+            });
+            logger.debug(`Filtered MCP tools to agent's allowed servers: ${agentConfig.mcpServers.join(', ')}`);
+        }
+        // === AGENTIC LOOP ===
+        _diag('INIT COMPLETE - entering agentic loop');
+        // Get MCP tool integration for silent tool checks
+        const mcpToolIntegration = getMCPToolIntegration();
+        // Load agentic configuration
+        const agenticConfig = configManager.getValue('agentic');
+        const maxIterations = agenticConfig?.maxIterations ?? DEFAULT_MAX_AGENTIC_ITERATIONS;
+        // Track agentic loop data
+        const loopStartTime = Date.now();
+        const agenticIterations = [];
+        let totalToolCalls = 0;
+        const totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+        const totalCost = { inputCost: 0, outputCost: 0, totalCost: 0, currency: 'USD' };
+        let iterations = 0;
+        let accumulatedText = '';
+        let finalResponse = '';
+        let reachedMaxIterations = false;
+        let hasStartedOutput = false;
+        // Track consecutive tool retry attempts to replace instead of accumulate
+        let toolRetryState = null;
+        while (iterations < maxIterations) {
+            iterations++;
+            logger.debug(`Agentic loop iteration ${iterations}`);
+            // === CANCELLATION CHECK ===
+            // Check if process was cancelled before each iteration
+            if (options.processId) {
+                const { getAgentSpawner } = await import('./agent-spawner.js');
+                const spawner = getAgentSpawner();
+                const process = spawner.getProcess(options.processId);
+                if (process?.status === 'cancelled') {
+                    logger.info(`Process ${options.processId} was cancelled - stopping execution`);
+                    finalResponse = accumulatedText + '\n\n*(Process cancelled)*';
+                    break;
+                }
+            }
+            // === BUDGET ENFORCEMENT ===
+            // Check budget limits before each iteration
+            if (options.budget) {
+                const budget = options.budget;
+                // Check turn limit
+                if (budget.turnsUsed >= budget.maxTurns) {
+                    logger.warn(`Agent turn budget exceeded: ${budget.turnsUsed}/${budget.maxTurns} turns`);
+                    finalResponse = accumulatedText + '\n\n*(Turn budget exceeded)*';
+                    if (options.onBudgetExceeded) {
+                        options.onBudgetExceeded('turns');
+                    }
+                    break;
+                }
+                // Check token limit (pre-flight estimate)
+                if (budget.tokensUsed >= budget.maxTokens) {
+                    logger.warn(`Agent token budget exceeded: ${budget.tokensUsed}/${budget.maxTokens} tokens`);
+                    finalResponse = accumulatedText + '\n\n*(Token budget exceeded)*';
+                    if (options.onBudgetExceeded) {
+                        options.onBudgetExceeded('tokens');
+                    }
+                    break;
+                }
+                // Log budget status
+                const tokenPercent = ((budget.tokensUsed / budget.maxTokens) * 100).toFixed(1);
+                const turnPercent = ((budget.turnsUsed / budget.maxTurns) * 100).toFixed(1);
+                logger.debug(`Budget status: ${budget.tokensUsed}/${budget.maxTokens} tokens (${tokenPercent}%), ${budget.turnsUsed}/${budget.maxTurns} turns (${turnPercent}%)`);
+            }
+            // Emit iteration start event
+            if (callbacks?.onIterationStart) {
+                callbacks.onIterationStart(iterations, maxIterations);
+            }
+            // Call Claude with tools
+            _diag(`API CALL START (iteration ${iterations})`);
+            const response = await client.createAgenticMessage(messages, {
+                system: systemPrompt,
+                tools,
+                maxTokens: DEFAULT_MAX_TOKENS,
+            }, (chunk) => {
+                // Stream text chunks
+                accumulatedText += chunk;
+                if (!hasStartedOutput) {
+                    hasStartedOutput = true;
+                }
+                emitTextChunk(chunk);
+            }, (toolEvent) => {
+                // Log tool events
+                if (toolEvent.type === 'tool_start') {
+                    const isSilent = mcpToolIntegration.isSilentTool(toolEvent.name);
+                    logger.debug(`Tool started: ${toolEvent.name}${isSilent ? ' (silent)' : ''}`);
+                    if (!isSilent) {
+                        emitToolStart(toolEvent.name, toolEvent.id, {});
+                        if (hasStartedOutput && !silent) {
+                            // Show tool execution in stderr so it doesn't pollute stdout
+                            process.stderr.write(chalk.dim(`\n[Executing: ${toolEvent.name}]\n`));
+                        }
+                    }
+                }
+                else if (toolEvent.type === 'tool_complete') {
+                    const isSilent = mcpToolIntegration.isSilentTool(toolEvent.name);
+                    if (!isSilent) {
+                        emitToolComplete(toolEvent.name, toolEvent.id, toolEvent.input, true);
+                    }
+                }
+            });
+            _diag(`API CALL DONE (iteration ${iterations}, stopReason=${response.stopReason})`);
+            logger.debug(`Response stop_reason: ${response.stopReason}, tool calls: ${response.toolUseBlocks.length}`);
+            // Accumulate usage and cost
+            totalUsage.inputTokens += response.usage.inputTokens;
+            totalUsage.outputTokens += response.usage.outputTokens;
+            totalUsage.totalTokens += response.usage.totalTokens;
+            totalCost.inputCost += response.cost.inputCost;
+            totalCost.outputCost += response.cost.outputCost;
+            totalCost.totalCost += response.cost.totalCost;
+            // === BUDGET TRACKING ===
+            // Update budget usage after API call
+            if (options.budget) {
+                const tokensThisTurn = response.usage.inputTokens + response.usage.outputTokens;
+                options.budget.tokensUsed += tokensThisTurn;
+                options.budget.turnsUsed = iterations;
+                logger.debug(`Budget updated: +${tokensThisTurn} tokens this turn, total: ${options.budget.tokensUsed}/${options.budget.maxTokens}`);
+                // Check if we exceeded budget after this call
+                if (options.budget.tokensUsed >= options.budget.maxTokens) {
+                    logger.warn(`Token budget exceeded after API call: ${options.budget.tokensUsed}/${options.budget.maxTokens}`);
+                    // Don't break here - let the loop continue to process this response
+                    // Budget will be checked at start of next iteration
+                }
+            }
+            // Handle max_tokens - prompt continuation
+            if (response.stopReason === 'max_tokens') {
+                logger.warn('Response truncated due to max_tokens - prompting continuation');
+                agenticIterations.push({
+                    iteration: iterations,
+                    llm_call: {
+                        messages_count: messages.length,
+                        response_text: response.textContent,
+                        tool_calls_count: 0,
+                        usage: response.usage,
+                        cost: response.cost,
+                    },
+                    tool_calls: [],
+                    stop_reason: response.stopReason,
+                });
+                messages.push({
+                    role: 'assistant',
+                    content: response.contentBlocks,
+                });
+                messages.push({
+                    role: 'user',
+                    content: 'Continue from where you left off.',
+                });
+                continue;
+            }
+            // If no tool calls, we're done
+            if (response.stopReason !== 'tool_use' || response.toolUseBlocks.length === 0) {
+                agenticIterations.push({
+                    iteration: iterations,
+                    llm_call: {
+                        messages_count: messages.length,
+                        response_text: response.textContent,
+                        tool_calls_count: 0,
+                        usage: response.usage,
+                        cost: response.cost,
+                    },
+                    tool_calls: [],
+                    stop_reason: response.stopReason,
+                });
+                finalResponse = accumulatedText;
+                break;
+            }
+            // Execute tool calls
+            emitStatus(`Running ${response.toolUseBlocks.length} tool(s)`);
+            // Emit tool start events for all non-silent tools about to be executed
+            for (const toolUse of response.toolUseBlocks) {
+                if (!mcpToolIntegration.isSilentTool(toolUse.name)) {
+                    emitToolStart(toolUse.name, toolUse.id, toolUse.input);
+                }
+                else {
+                    logger.debug(`Silent tool suppressed from UI: ${toolUse.name}`);
+                }
+            }
+            const { results: toolResults, records: toolRecords, userRejected, endTurn } = await executeToolCalls(response.toolUseBlocks, projectRoot);
+            totalToolCalls += toolRecords.length;
+            // Emit tool complete events for all executed tools
+            // Silent tools: suppress UI output unless there's an error (errors always surface)
+            for (let i = 0; i < toolRecords.length; i++) {
+                const record = toolRecords[i];
+                const toolUse = response.toolUseBlocks[i];
+                const isToolSilent = mcpToolIntegration.isSilentTool(record.name);
+                if (!isToolSilent || !record.success) {
+                    // Always emit for non-silent tools; also emit for silent tools that errored
+                    emitToolComplete(record.name, toolUse.id, record.result, record.success, record.error);
+                }
+                else {
+                    logger.debug(`Silent tool result suppressed from UI: ${record.name}`);
+                }
+            }
+            // === CANCELLATION CHECK (after tool execution) ===
+            // Check again after tools complete, in case cancellation happened during tool execution
+            if (options.processId) {
+                const { getAgentSpawner } = await import('./agent-spawner.js');
+                const spawner = getAgentSpawner();
+                const process = spawner.getProcess(options.processId);
+                if (process?.status === 'cancelled') {
+                    logger.info(`Process ${options.processId} was cancelled during tool execution - stopping`);
+                    finalResponse = accumulatedText + '\n\n*(Process cancelled)*';
+                    break;
+                }
+            }
+            // === END TURN CHECK (plan cancellation) ===
+            // If a plan tool signalled endTurn (user cancelled a plan), stop the loop immediately
+            if (endTurn) {
+                logger.info('End turn signalled (plan cancelled) — stopping agentic loop');
+                finalResponse = accumulatedText;
+                break;
+            }
+            // If user rejected an operation, log it but continue the loop
+            // The LLM will see the rejection error in the tool result and can decide what to do
+            if (userRejected) {
+                logger.info('Operation rejected - continuing agentic loop so LLM can respond');
+            }
+            // Log this iteration
+            agenticIterations.push({
+                iteration: iterations,
+                llm_call: {
+                    messages_count: messages.length,
+                    response_text: response.textContent,
+                    tool_calls_count: response.toolUseBlocks.length,
+                    usage: response.usage,
+                    cost: response.cost,
+                },
+                tool_calls: toolRecords,
+                stop_reason: response.stopReason,
+            });
+            // === TOOL RETRY REPLACEMENT LOGIC ===
+            // Check if this is a consecutive retry of a single failed tool
+            const isSingleToolCall = response.toolUseBlocks.length === 1;
+            const singleTool = isSingleToolCall ? response.toolUseBlocks[0] : null;
+            const singleToolResult = isSingleToolCall ? toolResults[0] : null;
+            const singleToolRecord = isSingleToolCall ? toolRecords[0] : null;
+            // Determine if we should replace the previous failed attempt
+            const shouldReplace = isSingleToolCall &&
+                singleTool &&
+                toolRetryState &&
+                isConsecutiveRetry(singleTool.name, singleTool.input, toolRetryState);
+            if (shouldReplace && singleToolResult && singleToolRecord) {
+                // This is a retry - replace the previous messages instead of appending
+                const isCurrentError = singleToolResult.is_error === true;
+                const currentContent = singleToolResult.content;
+                // Update retry state
+                if (isCurrentError) {
+                    toolRetryState.attemptCount++;
+                    toolRetryState.previousErrors.push(summarizeError(currentContent));
+                }
+                // Annotate the tool result with retry information
+                const annotatedContent = annotateToolResult(currentContent, isCurrentError, toolRetryState.attemptCount, toolRetryState.previousErrors.slice(0, -1) // Exclude current error from "previous"
+                );
+                // Create annotated tool result
+                const annotatedToolResult = {
+                    ...singleToolResult,
+                    content: annotatedContent,
+                };
+                // Replace the last two messages (previous assistant + previous tool_result)
+                messages.pop(); // Remove previous tool_result
+                messages.pop(); // Remove previous assistant message
+                // Add updated messages
+                messages.push({
+                    role: 'assistant',
+                    content: response.contentBlocks,
+                });
+                messages.push({
+                    role: 'user',
+                    content: [annotatedToolResult],
+                });
+                logger.debug(`Tool retry detected: ${singleTool.name} attempt ${toolRetryState.attemptCount} (replaced previous)`);
+                // Reset retry state if this attempt succeeded
+                if (!isCurrentError) {
+                    toolRetryState = null;
+                }
+            }
+            else {
+                // Not a retry or multiple tools - append normally
+                messages.push({
+                    role: 'assistant',
+                    content: response.contentBlocks,
+                });
+                messages.push({
+                    role: 'user',
+                    content: toolResults,
+                });
+                // Update retry state for potential future retries
+                if (isSingleToolCall && singleToolRecord && !singleToolRecord.success) {
+                    // Single tool failed - start tracking for potential retry
+                    const toolInput = singleTool.input;
+                    toolRetryState = {
+                        toolName: singleTool.name,
+                        targetPath: toolInput.path,
+                        attemptCount: 1,
+                        previousErrors: [summarizeError(singleToolRecord.error || 'Unknown error')],
+                    };
+                    logger.debug(`Tool retry tracking started: ${singleTool.name}`);
+                }
+                else {
+                    // Multiple tools or success - reset retry state
+                    toolRetryState = null;
+                }
+            }
+            // Check iteration limit
+            if (iterations >= maxIterations) {
+                logger.warn('Agentic loop reached maximum iterations');
+                finalResponse = accumulatedText + '\n\n*(Reached maximum iterations)*';
+                reachedMaxIterations = true;
+                break;
+            }
+        }
+        // Ensure output ends with newline
+        if (finalResponse && !finalResponse.endsWith('\n') && !silent) {
+            process.stdout.write('\n');
+        }
+        // Emit completion callback
+        if (callbacks?.onComplete) {
+            callbacks.onComplete(finalResponse, totalUsage, totalCost);
+        }
+        // Log the complete agentic loop
+        const loopDuration = Date.now() - loopStartTime;
+        await auditLogger.logAgenticLoop({
+            user_input: userContent,
+            system_prompt: systemPrompt,
+            model: client.getCurrentModel().id,
+            iterations: agenticIterations,
+            final_response: finalResponse,
+            total_iterations: iterations,
+            total_tool_calls: totalToolCalls,
+            total_usage: totalUsage,
+            total_cost: totalCost,
+            duration_ms: loopDuration,
+            reached_max_iterations: reachedMaxIterations,
+            isPlanMode: false,
+        });
+        // Save conversation for potential continuation
+        // Convert ContentBlock[] to string for session storage
+        const userContentForStorage = typeof userMessageContent === 'string'
+            ? userMessageContent
+            : userMessageContent.map(block => {
+                if (block.type === 'text') {
+                    return block.text;
+                }
+                else if (block.type === 'image' && block.source) {
+                    return `[Image: ${block.source.media_type}]`;
+                }
+                else if (block.type === 'document' && block.source) {
+                    return `[Document: ${block.source.media_type}]`;
+                }
+                return '[Unknown content type]';
+            }).join('\n');
+        const userMessageWithAttachments = attachments && attachments.length > 0
+            ? { role: 'user', content: userContentForStorage, attachments }
+            : { role: 'user', content: userContentForStorage };
+        sessionManager.addMessage(userMessageWithAttachments);
+        if (finalResponse) {
+            sessionManager.addMessage({ role: 'assistant', content: finalResponse });
+        }
+        await sessionManager.save();
+        // End token tracking
+        await tokenTracker.endSession();
+        return {
+            success: true,
+            content: finalResponse,
+            exitCode: 0,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error('SDK runner error', error);
+        emitError(errorMessage);
+        return {
+            success: false,
+            content: '',
+            error: errorMessage,
+            exitCode: 1,
+        };
+    }
+}
+//# sourceMappingURL=sdk-runner.js.map