@compass-ai/nova 1.0.74 → 1.0.76

package/dist/services/sdk-runner.js

@@ -1,1424 +0,0 @@
-/**
- * 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