claudecode-omc 4.8.4 → 4.9.4

package/dist/mcp/gemini-core.js

@@ -1,674 +0,0 @@
-/**
- * Gemini Core Business Logic - Shared between SDK and Standalone MCP servers
- *
- * This module contains all the business logic for Gemini CLI integration:
- * - Constants and configuration
- * - CLI execution with timeout handling
- * - File validation and reading
- * - Complete tool handler logic with role validation, fallback chain, etc.
- *
- * This module is SDK-agnostic and can be imported by both:
- * - gemini-server.ts (in-process SDK MCP server)
- * - gemini-standalone-server.ts (stdio-based external process server)
- */
-import { spawn } from 'child_process';
-import { appendFileSync, existsSync, mkdirSync, readFileSync, realpathSync, unlinkSync, writeFileSync } from 'fs';
-import { resolve, relative, sep, isAbsolute, join } from 'path';
-import { createStdoutCollector, safeWriteOutputFile } from './shared-exec.js';
-import { detectGeminiCli } from './cli-detection.js';
-import { getWorktreeRoot } from '../lib/worktree-paths.js';
-import { isExternalPromptAllowed } from './mcp-config.js';
-import { resolveSystemPrompt, buildPromptWithSystemContext, wrapUntrustedCliResponse, isValidAgentRoleName, VALID_AGENT_ROLES, singleErrorBlock, inlineSuccessBlocks, validateContextFilePaths } from './prompt-injection.js';
-import { persistPrompt, persistResponse, getExpectedResponsePath, getPromptsDir, generatePromptId, slugify } from './prompt-persistence.js';
-import { writeJobStatus, getStatusFilePath, readJobStatus } from './prompt-persistence.js';
-import { resolveExternalModel, buildFallbackChain, GEMINI_MODEL_FALLBACKS, } from '../features/model-routing/external-model-policy.js';
-import { loadConfig } from '../config/loader.js';
-// Module-scoped PID registry - tracks PIDs spawned by this process
-const spawnedPids = new Set();
-export function isSpawnedPid(pid) {
-    return spawnedPids.has(pid);
-}
-export function clearSpawnedPids() {
-    spawnedPids.clear();
-}
-// Model name validation: alphanumeric start, then alphanumeric/dots/hyphens/underscores, max 64 chars
-const MODEL_NAME_REGEX = /^[a-z0-9][a-z0-9._-]{0,63}$/i;
-function validateModelName(model) {
-    if (!MODEL_NAME_REGEX.test(model)) {
-        throw new Error(`Invalid model name: "${model}". Model names must match pattern: alphanumeric start, followed by alphanumeric, dots, hyphens, or underscores (max 64 chars).`);
-    }
-}
-// Default model can be overridden via environment variable
-export const GEMINI_DEFAULT_MODEL = process.env.OMC_GEMINI_DEFAULT_MODEL || 'gemini-3.1-pro-preview';
-export const GEMINI_TIMEOUT = Math.min(Math.max(5000, parseInt(process.env.OMC_GEMINI_TIMEOUT || '3600000', 10) || 3600000), 3600000);
-// Gemini is best for design review and implementation tasks (recommended, not enforced)
-export const GEMINI_RECOMMENDED_ROLES = ['designer', 'writer', 'vision'];
-export const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5MB per file
-export const MAX_STDOUT_BYTES = 10 * 1024 * 1024; // 10MB stdout cap
-const GEMINI_RATE_LIMIT_OR_DISCONNECT_REGEX = /429|rate.?limit|too many requests|quota.?exceeded|resource.?exhausted|stream disconnected|transport closed|econnreset|epipe/i;
-/**
- * Check if Gemini output/stderr indicates a rate-limit (429) or quota error
- * that should trigger a fallback to the next model in the chain.
- */
-export function isGeminiRetryableError(stdout, stderr = '') {
-    const combined = `${stdout}\n${stderr}`;
-    // Check for model not found / not supported
-    if (/model.?not.?found|model is not supported|model.+does not exist|not.+available/i.test(combined)) {
-        const match = combined.match(/.*(?:model.?not.?found|model is not supported|model.+does not exist|not.+available).*/i);
-        return { isError: true, message: match?.[0]?.trim() || 'Model not available', type: 'model' };
-    }
-    // Check for 429/rate limit and transport disconnect signatures
-    if (GEMINI_RATE_LIMIT_OR_DISCONNECT_REGEX.test(combined)) {
-        const match = combined.match(/.*(?:429|rate.?limit|too many requests|quota.?exceeded|resource.?exhausted|stream disconnected|transport closed|econnreset|epipe).*/i);
-        return { isError: true, message: match?.[0]?.trim() || 'Retryable rate-limit/transport error detected', type: 'rate_limit' };
-    }
-    return { isError: false, message: '', type: 'none' };
-}
-/**
- * Execute Gemini CLI command and return the response
- */
-export function executeGemini(prompt, model, cwd) {
-    return new Promise((resolve, reject) => {
-        if (model)
-            validateModelName(model);
-        let settled = false;
-        const args = ['-p=.', '--yolo'];
-        if (model) {
-            args.push('--model', model);
-        }
-        const child = spawn('gemini', args, {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            ...(cwd ? { cwd } : {}),
-            // shell: true needed on Windows for .cmd/.bat executables.
-            // Safe: args are array-based and model names are regex-validated.
-            ...(process.platform === 'win32' ? { shell: true } : {})
-        });
-        const timeoutHandle = setTimeout(() => {
-            if (!settled) {
-                settled = true;
-                child.kill('SIGTERM');
-                reject(new Error(`Gemini timed out after ${GEMINI_TIMEOUT}ms`));
-            }
-        }, GEMINI_TIMEOUT);
-        const collector = createStdoutCollector(MAX_STDOUT_BYTES);
-        let stderr = '';
-        child.stdout.on('data', (data) => {
-            collector.append(data.toString());
-        });
-        child.stderr.on('data', (data) => {
-            stderr += data.toString();
-        });
-        child.on('close', (code) => {
-            if (!settled) {
-                settled = true;
-                clearTimeout(timeoutHandle);
-                const stdout = collector.toString();
-                if (code === 0 || stdout.trim()) {
-                    // Check for retryable errors even on "successful" exit
-                    const retryable = isGeminiRetryableError(stdout, stderr);
-                    if (retryable.isError) {
-                        reject(new Error(`Gemini ${retryable.type === 'rate_limit' ? 'rate limit' : 'model'} error: ${retryable.message}`));
-                    }
-                    else {
-                        resolve(stdout.trim());
-                    }
-                }
-                else {
-                    // Check stderr for rate limit errors before generic failure
-                    const retryableExit = isGeminiRetryableError(stderr, stdout);
-                    if (retryableExit.isError) {
-                        reject(new Error(`Gemini ${retryableExit.type === 'rate_limit' ? 'rate limit' : 'model'} error: ${retryableExit.message}`));
-                    }
-                    else {
-                        reject(new Error(`Gemini exited with code ${code}: ${stderr || 'No output'}`));
-                    }
-                }
-            }
-        });
-        child.on('error', (err) => {
-            if (!settled) {
-                settled = true;
-                clearTimeout(timeoutHandle);
-                child.kill('SIGTERM');
-                reject(new Error(`Failed to spawn Gemini CLI: ${err.message}`));
-            }
-        });
-        child.stdin.on('error', (err) => {
-            if (!settled) {
-                settled = true;
-                clearTimeout(timeoutHandle);
-                child.kill('SIGTERM');
-                reject(new Error(`Stdin write error: ${err.message}`));
-            }
-        });
-        child.stdin.write(prompt);
-        child.stdin.end();
-    });
-}
-/**
- * Execute Gemini CLI in background with fallback chain support
- * Retries with next model on model errors and 429/rate-limit errors
- */
-export function executeGeminiBackground(fullPrompt, modelInput, jobMeta, workingDirectory) {
-    try {
-        const modelExplicit = modelInput !== undefined && modelInput !== null && modelInput !== '';
-        const effectiveModel = modelInput || GEMINI_DEFAULT_MODEL;
-        // Build fallback chain
-        const modelsToTry = modelExplicit
-            ? [effectiveModel] // No fallback if model explicitly provided
-            : (GEMINI_MODEL_FALLBACKS.includes(effectiveModel)
-                ? GEMINI_MODEL_FALLBACKS.slice(GEMINI_MODEL_FALLBACKS.indexOf(effectiveModel))
-                : [effectiveModel, ...GEMINI_MODEL_FALLBACKS]);
-        // Helper to try spawning with a specific model
-        const trySpawnWithModel = (tryModel, remainingModels) => {
-            validateModelName(tryModel);
-            const args = ['-p=.', '--yolo', '--model', tryModel];
-            const child = spawn('gemini', args, {
-                detached: process.platform !== 'win32',
-                stdio: ['pipe', 'pipe', 'pipe'],
-                ...(workingDirectory ? { cwd: workingDirectory } : {}),
-                ...(process.platform === 'win32' ? { shell: true } : {})
-            });
-            if (!child.pid) {
-                return { error: 'Failed to get process ID' };
-            }
-            const pid = child.pid;
-            spawnedPids.add(pid);
-            child.unref();
-            const initialStatus = {
-                provider: 'gemini',
-                jobId: jobMeta.jobId,
-                slug: jobMeta.slug,
-                status: 'spawned',
-                pid,
-                promptFile: jobMeta.promptFile,
-                responseFile: jobMeta.responseFile,
-                model: tryModel,
-                agentRole: jobMeta.agentRole,
-                spawnedAt: new Date().toISOString(),
-            };
-            writeJobStatus(initialStatus, workingDirectory);
-            const collector = createStdoutCollector(MAX_STDOUT_BYTES);
-            const partialFile = jobMeta.responseFile + '.partial';
-            let stderr = '';
-            let settled = false;
-            const cleanupPartial = () => {
-                try {
-                    if (existsSync(partialFile))
-                        unlinkSync(partialFile);
-                }
-                catch { /* ignore */ }
-            };
-            const timeoutHandle = setTimeout(() => {
-                if (!settled) {
-                    settled = true;
-                    spawnedPids.delete(pid);
-                    try {
-                        if (process.platform !== 'win32')
-                            process.kill(-pid, 'SIGTERM');
-                        else
-                            child.kill('SIGTERM');
-                    }
-                    catch {
-                        // ignore
-                    }
-                    cleanupPartial();
-                    writeJobStatus({
-                        ...initialStatus,
-                        status: 'timeout',
-                        completedAt: new Date().toISOString(),
-                        error: `Gemini timed out after ${GEMINI_TIMEOUT}ms`,
-                    }, workingDirectory);
-                }
-            }, GEMINI_TIMEOUT);
-            child.stdout?.on('data', (data) => {
-                collector.append(data.toString());
-                try {
-                    appendFileSync(partialFile, data);
-                }
-                catch { /* ignore */ }
-            });
-            child.stderr?.on('data', (data) => { stderr += data.toString(); });
-            child.stdin?.on('error', (err) => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timeoutHandle);
-                cleanupPartial();
-                writeJobStatus({
-                    ...initialStatus,
-                    status: 'failed',
-                    completedAt: new Date().toISOString(),
-                    error: `Stdin write error: ${err.message}`,
-                }, workingDirectory);
-            });
-            child.stdin?.write(fullPrompt);
-            child.stdin?.end();
-            writeJobStatus({ ...initialStatus, status: 'running' }, workingDirectory);
-            child.on('close', (code) => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timeoutHandle);
-                spawnedPids.delete(pid);
-                cleanupPartial();
-                const stdout = collector.toString();
-                // Check if user killed this job
-                const currentStatus = readJobStatus('gemini', jobMeta.slug, jobMeta.jobId, workingDirectory);
-                if (currentStatus?.killedByUser) {
-                    return;
-                }
-                if (code === 0 || stdout.trim()) {
-                    // Check for retryable errors (model errors + rate limit/429)
-                    const retryableErr = isGeminiRetryableError(stdout, stderr);
-                    if (retryableErr.isError && remainingModels.length > 0) {
-                        const nextModel = remainingModels[0];
-                        const newRemainingModels = remainingModels.slice(1);
-                        const retryResult = trySpawnWithModel(nextModel, newRemainingModels);
-                        if ('error' in retryResult) {
-                            writeJobStatus({
-                                ...initialStatus,
-                                status: 'failed',
-                                completedAt: new Date().toISOString(),
-                                error: `Fallback spawn failed for model ${nextModel}: ${retryResult.error}`,
-                            }, workingDirectory);
-                        }
-                        return;
-                    }
-                    if (retryableErr.isError) {
-                        writeJobStatus({
-                            ...initialStatus,
-                            status: 'failed',
-                            completedAt: new Date().toISOString(),
-                            error: `All models in fallback chain failed. Last error (${retryableErr.type}): ${retryableErr.message}`,
-                        }, workingDirectory);
-                        return;
-                    }
-                    const response = stdout.trim();
-                    const usedFallback = tryModel !== effectiveModel;
-                    persistResponse({
-                        provider: 'gemini',
-                        agentRole: jobMeta.agentRole,
-                        model: tryModel,
-                        promptId: jobMeta.jobId,
-                        slug: jobMeta.slug,
-                        response,
-                        workingDirectory,
-                        usedFallback,
-                        fallbackModel: usedFallback ? tryModel : undefined,
-                    });
-                    writeJobStatus({
-                        ...initialStatus,
-                        model: tryModel,
-                        status: 'completed',
-                        completedAt: new Date().toISOString(),
-                        usedFallback: usedFallback || undefined,
-                        fallbackModel: usedFallback ? tryModel : undefined,
-                    }, workingDirectory);
-                }
-                else {
-                    // Check if the failure is a retryable error before giving up
-                    const retryableExit = isGeminiRetryableError(stderr, stdout);
-                    if (retryableExit.isError && remainingModels.length > 0) {
-                        const nextModel = remainingModels[0];
-                        const newRemainingModels = remainingModels.slice(1);
-                        const retryResult = trySpawnWithModel(nextModel, newRemainingModels);
-                        if ('error' in retryResult) {
-                            writeJobStatus({
-                                ...initialStatus,
-                                status: 'failed',
-                                completedAt: new Date().toISOString(),
-                                error: `Fallback spawn failed for model ${nextModel}: ${retryResult.error}`,
-                            }, workingDirectory);
-                        }
-                        return;
-                    }
-                    writeJobStatus({
-                        ...initialStatus,
-                        status: 'failed',
-                        completedAt: new Date().toISOString(),
-                        error: `Gemini exited with code ${code}: ${stderr || 'No output'}`,
-                    }, workingDirectory);
-                }
-            });
-            child.on('error', (err) => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timeoutHandle);
-                cleanupPartial();
-                writeJobStatus({
-                    ...initialStatus,
-                    status: 'failed',
-                    completedAt: new Date().toISOString(),
-                    error: `Failed to spawn Gemini CLI: ${err.message}`,
-                }, workingDirectory);
-            });
-            return { pid };
-        };
-        // Start execution with the first model in the chain
-        return trySpawnWithModel(modelsToTry[0], modelsToTry.slice(1));
-    }
-    catch (err) {
-        return { error: `Failed to start background execution: ${err.message}` };
-    }
-}
-/**
- * Handle ask_gemini tool request - contains ALL business logic
- *
- * This function is called by both the SDK server and standalone server.
- * It performs:
- * - Agent role validation
- * - CLI detection
- * - System prompt resolution
- * - File context building
- * - Full prompt assembly
- * - Fallback chain execution
- * - Error handling
- *
- * @returns MCP-compatible response with content array
- */
-export async function handleAskGemini(args) {
-    if (!args || typeof args !== 'object' || Array.isArray(args)) {
-        return singleErrorBlock('Invalid request: args must be an object.');
-    }
-    const { agent_role, files } = args;
-    // Resolve model based on configuration and agent role
-    const config = loadConfig();
-    const resolved = resolveExternalModel(config.externalModels, {
-        agentRole: agent_role,
-        explicitProvider: 'gemini',
-        explicitModel: args.model, // user explicitly passed model
-    });
-    const resolvedModel = resolved.model || GEMINI_DEFAULT_MODEL;
-    // Derive baseDir from working_directory if provided
-    let baseDir = args.working_directory || process.cwd();
-    let baseDirReal;
-    // Path policy for error messages
-    const pathPolicy = process.env.OMC_ALLOW_EXTERNAL_WORKDIR === '1' ? 'permissive' : 'strict';
-    try {
-        baseDirReal = realpathSync(baseDir);
-        baseDir = baseDirReal;
-    }
-    catch (err) {
-        return singleErrorBlock(`E_WORKDIR_INVALID: working_directory '${args.working_directory}' does not exist or is not accessible.\nError: ${err.message}\nResolved working directory: ${baseDir}\nPath policy: ${pathPolicy}\nSuggested: ensure the working directory exists and is accessible`);
-    }
-    // Security: validate working_directory is within worktree (unless bypass enabled)
-    if (process.env.OMC_ALLOW_EXTERNAL_WORKDIR !== '1') {
-        const worktreeRoot = getWorktreeRoot(baseDirReal);
-        if (worktreeRoot) {
-            let worktreeReal;
-            try {
-                worktreeReal = realpathSync(worktreeRoot);
-            }
-            catch {
-                // If worktree root can't be resolved, skip boundary check rather than break
-                worktreeReal = '';
-            }
-            if (worktreeReal) {
-                const relToWorktree = relative(worktreeReal, baseDirReal);
-                if (relToWorktree.startsWith('..') || isAbsolute(relToWorktree)) {
-                    return singleErrorBlock(`E_WORKDIR_INVALID: working_directory '${args.working_directory}' is outside the project worktree (${worktreeRoot}).\nRequested: ${args.working_directory}\nResolved working directory: ${baseDirReal}\nWorktree root: ${worktreeRoot}\nPath policy: ${pathPolicy}\nSuggested: use a working_directory within the project worktree, or set OMC_ALLOW_EXTERNAL_WORKDIR=1 to bypass`);
-                }
-            }
-        }
-    }
-    // Validate agent_role - must be non-empty and pass character validation
-    if (typeof agent_role !== 'string' || !agent_role.trim()) {
-        return singleErrorBlock('agent_role is required and must be a non-empty string.');
-    }
-    if (!isValidAgentRoleName(agent_role)) {
-        return singleErrorBlock(`Invalid agent_role: "${agent_role}". Role names must contain only lowercase letters, numbers, and hyphens. Recommended for Gemini: ${GEMINI_RECOMMENDED_ROLES.join(', ')}`);
-    }
-    // Validate agent_role exists in discovered roles (allowlist enforcement)
-    if (!VALID_AGENT_ROLES.includes(agent_role)) {
-        return singleErrorBlock(`Unknown agent_role: "${agent_role}". Available roles: ${VALID_AGENT_ROLES.join(', ')}. Recommended for Gemini: ${GEMINI_RECOMMENDED_ROLES.join(', ')}`);
-    }
-    // Inline prompt support: when `prompt` is provided as a string, auto-persist
-    // it to a file for audit trail and continue with normal prompt_file flow.
-    // Defined-value precedence: if `prompt_file` key exists with a non-undefined value, file mode wins.
-    // This handles JSON-RPC serializers that emit `prompt_file: undefined` as "not provided".
-    // Separate intent detection (field presence) from content validation (non-empty).
-    const inlinePrompt = typeof args.prompt === 'string' ? args.prompt : undefined;
-    const hasPromptFileField = Object.prototype.hasOwnProperty.call(args, 'prompt_file') && args.prompt_file !== undefined;
-    const promptFileInput = hasPromptFileField && typeof args.prompt_file === 'string' ? args.prompt_file.trim() || undefined : undefined;
-    let resolvedPromptFile = promptFileInput;
-    let resolvedOutputFile = typeof args.output_file === 'string' ? args.output_file : undefined;
-    const hasInlineIntent = inlinePrompt !== undefined && !hasPromptFileField;
-    const isInlineMode = hasInlineIntent && inlinePrompt.trim().length > 0;
-    // Reject empty/whitespace inline prompt with explicit error BEFORE any side effects
-    if (hasInlineIntent && !inlinePrompt?.trim()) {
-        return singleErrorBlock('Inline prompt is empty. Provide a non-empty prompt string.');
-    }
-    // Reject oversized inline prompts before any persistence
-    const MAX_INLINE_PROMPT_BYTES = 256 * 1024; // 256 KB
-    if (isInlineMode && Buffer.byteLength(inlinePrompt, 'utf-8') > MAX_INLINE_PROMPT_BYTES) {
-        return singleErrorBlock(`Inline prompt exceeds maximum size (${MAX_INLINE_PROMPT_BYTES} bytes). Use prompt_file for large prompts.`);
-    }
-    // Inline mode is foreground only - check BEFORE any file persistence to avoid leaks
-    if (isInlineMode && args.background) {
-        return singleErrorBlock('Inline prompt mode is foreground only. Use prompt_file for background execution.');
-    }
-    // Explicit type error for non-string prompt_file (e.g., null, number, object)
-    if (hasPromptFileField && !promptFileInput) {
-        return singleErrorBlock('prompt_file must be a non-empty string when provided. Received non-string or empty value.');
-    }
-    let inlineRequestId;
-    if (isInlineMode) {
-        inlineRequestId = generatePromptId();
-        // Auto-persist inline prompt to file
-        try {
-            const promptsDir = getPromptsDir(baseDir);
-            mkdirSync(promptsDir, { recursive: true });
-            const slug = slugify(inlinePrompt);
-            const inlinePromptPath = join(promptsDir, `gemini-inline-${slug}-${inlineRequestId}.md`);
-            writeFileSync(inlinePromptPath, inlinePrompt, { encoding: 'utf-8', mode: 0o600 });
-            const resolvedPromptFileLocal = inlinePromptPath;
-            const resolvedOutputFileLocal = (!resolvedOutputFile || !resolvedOutputFile.trim())
-                ? join(promptsDir, `gemini-inline-response-${slug}-${inlineRequestId}.md`)
-                : resolvedOutputFile;
-            resolvedPromptFile = resolvedPromptFileLocal;
-            resolvedOutputFile = resolvedOutputFileLocal;
-        }
-        catch (err) {
-            const reason = err instanceof Error ? err.message : 'unknown error';
-            return singleErrorBlock(`Failed to persist inline prompt (${reason}). Check working directory permissions and disk space.`);
-        }
-    }
-    // Validate that at least one prompt source is provided.
-    // Use type-guarded promptFileInput to avoid .trim() TypeError on non-string values.
-    const effectivePromptFile = resolvedPromptFile;
-    if (!effectivePromptFile || !effectivePromptFile.trim()) {
-        return singleErrorBlock("Either 'prompt' (inline) or 'prompt_file' (file path) is required.");
-    }
-    // Validate output_file is provided after prompt source validation.
-    // Use resolved inline/file output path to avoid args mutation.
-    const effectiveOutputFile = resolvedOutputFile;
-    if (!effectiveOutputFile || !effectiveOutputFile.trim()) {
-        return singleErrorBlock('output_file is required. Specify a path where the response should be written.');
-    }
-    // Resolve prompt from prompt_file (validated non-empty above)
-    let resolvedPrompt;
-    const promptFile = effectivePromptFile;
-    const resolvedPath = resolve(baseDir, promptFile);
-    const cwdReal = realpathSync(baseDir);
-    const relPath = relative(cwdReal, resolvedPath);
-    if (!isExternalPromptAllowed() && (relPath === '..' || relPath.startsWith('..' + sep) || isAbsolute(relPath))) {
-        return singleErrorBlock(`E_PATH_OUTSIDE_WORKDIR_PROMPT: prompt_file '${promptFile}' resolves outside working_directory '${baseDirReal}'.\nRequested: ${promptFile}\nWorking directory: ${baseDirReal}\nResolved working directory: ${baseDirReal}\nPath policy: ${pathPolicy}\nSuggested: place the prompt file within the working directory or set working_directory to a common ancestor`);
-    }
-    // Symlink-safe check: resolve and validate BEFORE reading
-    let resolvedReal;
-    try {
-        resolvedReal = realpathSync(resolvedPath);
-    }
-    catch (err) {
-        return singleErrorBlock(`Failed to resolve prompt_file '${promptFile}': ${err.message}`);
-    }
-    const relReal = relative(cwdReal, resolvedReal);
-    if (!isExternalPromptAllowed() && (relReal === '..' || relReal.startsWith('..' + sep) || isAbsolute(relReal))) {
-        return singleErrorBlock(`E_PATH_OUTSIDE_WORKDIR_PROMPT: prompt_file '${promptFile}' resolves to a path outside working_directory '${baseDirReal}'.\nRequested: ${promptFile}\nResolved path: ${resolvedReal}\nWorking directory: ${baseDirReal}\nResolved working directory: ${baseDirReal}\nPath policy: ${pathPolicy}\nSuggested: place the prompt file within the working directory or set working_directory to a common ancestor`);
-    }
-    // Now safe to read from the validated real path
-    try {
-        resolvedPrompt = readFileSync(resolvedReal, 'utf-8');
-    }
-    catch (err) {
-        return singleErrorBlock(`Failed to read prompt_file '${promptFile}': ${err.message}`);
-    }
-    // Check for empty prompt
-    if (!resolvedPrompt.trim()) {
-        return singleErrorBlock(`prompt_file '${promptFile}' is empty.`);
-    }
-    // Add headless execution context so Gemini produces comprehensive output
-    const userPrompt = `[HEADLESS SESSION] You are running non-interactively in a headless pipeline. Produce your FULL, comprehensive analysis directly in your response. Do NOT ask for clarification or confirmation - work thoroughly with all provided context. Do NOT write brief acknowledgments - your response IS the deliverable.
-
-${resolvedPrompt}`;
-    // Check CLI availability
-    const detection = detectGeminiCli();
-    if (!detection.available) {
-        return singleErrorBlock(`Gemini CLI is not available: ${detection.error}\n\n${detection.installHint}`);
-    }
-    // Resolve system prompt from agent role
-    const resolvedSystemPrompt = resolveSystemPrompt(undefined, agent_role, 'gemini');
-    // Build file context — validate paths first to prevent path traversal and prompt injection
-    let fileContext;
-    if (files && files.length > 0) {
-        const { validPaths, errors } = validateContextFilePaths(files, baseDirReal, isExternalPromptAllowed());
-        if (errors.length > 0) {
-            console.warn('[gemini-core] files validation rejected paths:', errors.join('; '));
-        }
-        if (validPaths.length > 0) {
-            fileContext = `The following files are available for reference. Use your file tools to read them as needed:\n${validPaths.map(f => `- ${f}`).join('\n')}`;
-        }
-    }
-    // Combine: system prompt > file context > user prompt
-    const fullPrompt = buildPromptWithSystemContext(userPrompt, fileContext, resolvedSystemPrompt);
-    // Persist prompt for audit trail (once, before fallback loop)
-    const promptResult = persistPrompt({
-        provider: 'gemini',
-        agentRole: agent_role,
-        model: resolvedModel,
-        files,
-        prompt: resolvedPrompt,
-        fullPrompt,
-        workingDirectory: baseDir,
-    });
-    // Compute expected response path for immediate return
-    const expectedResponsePath = promptResult
-        ? getExpectedResponsePath('gemini', promptResult.slug, promptResult.id, baseDir)
-        : undefined;
-    // Background mode: return immediately with job metadata
-    if (args.background) {
-        if (!promptResult) {
-            return singleErrorBlock('Failed to persist prompt for background execution');
-        }
-        const statusFilePath = getStatusFilePath('gemini', promptResult.slug, promptResult.id, baseDir);
-        // Build fallback chain for display (executeGeminiBackground builds its own internally)
-        const fallbackChainBg = buildFallbackChain('gemini', resolvedModel, config.externalModels);
-        const result = executeGeminiBackground(fullPrompt, args.model, {
-            provider: 'gemini',
-            jobId: promptResult.id,
-            slug: promptResult.slug,
-            agentRole: agent_role,
-            model: resolvedModel,
-            promptFile: promptResult.filePath,
-            responseFile: expectedResponsePath,
-        }, baseDir);
-        if ('error' in result) {
-            return singleErrorBlock(`Failed to spawn background job: ${result.error}`);
-        }
-        return {
-            content: [{
-                    type: 'text',
-                    text: [
-                        `**Mode:** Background (non-blocking)`,
-                        `**Job ID:** ${promptResult.id}`,
-                        `**Agent Role:** ${agent_role}`,
-                        `**Model (attempting):** ${fallbackChainBg[0]}`,
-                        `**Fallback chain:** ${fallbackChainBg.join(' -> ')}`,
-                        `**PID:** ${result.pid}`,
-                        `**Prompt File:** ${promptResult.filePath}`,
-                        `**Response File:** ${expectedResponsePath}`,
-                        `**Partial Output:** ${expectedResponsePath}.partial  (tail -f to stream live)`,
-                        `**Status File:** ${statusFilePath}`,
-                        ``,
-                        `Job dispatched. Will automatically try fallback models on 429/rate-limit or model errors.`,
-                    ].join('\n')
-                }]
-        };
-    }
-    // Build parameter visibility block
-    const paramLines = [
-        `**Agent Role:** ${agent_role}`,
-        files?.length ? `**Files:** ${files.join(', ')}` : null,
-        promptResult ? `**Prompt File:** ${promptResult.filePath}` : null,
-        expectedResponsePath ? `**Response File:** ${expectedResponsePath}` : null,
-        `**Resolved Working Directory:** ${baseDirReal}`,
-        `**Path Policy:** ${pathPolicy}`,
-    ].filter(Boolean).join('\n');
-    // Build fallback chain using the resolver
-    const fallbackChain = buildFallbackChain('gemini', resolvedModel, config.externalModels);
-    let resolvedOutputPath;
-    if (effectiveOutputFile) {
-        resolvedOutputPath = resolve(baseDirReal, effectiveOutputFile);
-    }
-    const errors = [];
-    for (const tryModel of fallbackChain) {
-        try {
-            const response = await executeGemini(fullPrompt, tryModel, baseDir);
-            const usedFallback = tryModel !== resolvedModel;
-            const fallbackLine = usedFallback ? `Fallback: used model ${tryModel}` : undefined;
-            // Persist response to disk (audit trail)
-            if (promptResult) {
-                persistResponse({
-                    provider: 'gemini',
-                    agentRole: agent_role,
-                    model: tryModel,
-                    promptId: promptResult.id,
-                    slug: promptResult.slug,
-                    response,
-                    usedFallback,
-                    fallbackModel: usedFallback ? tryModel : undefined,
-                    workingDirectory: baseDir,
-                });
-            }
-            // Always write response to output_file.
-            if (effectiveOutputFile && resolvedOutputPath) {
-                const writeResult = safeWriteOutputFile(effectiveOutputFile, response, baseDirReal, '[gemini-core]');
-                if (!writeResult.success) {
-                    return singleErrorBlock(`${paramLines}\n\n---\n\n${writeResult.errorMessage}\n\nresolved_working_directory: ${baseDirReal}\npath_policy: ${pathPolicy}`);
-                }
-            }
-            // Build success response metadata (match Codex inline assembly pattern)
-            const responseLines = [paramLines];
-            if (fallbackLine) {
-                responseLines.push(fallbackLine);
-            }
-            // In inline mode, return metadata + raw response as separate content blocks
-            if (isInlineMode) {
-                responseLines.push(`**Request ID:** ${inlineRequestId}`);
-                const metadataText = responseLines.join('\n');
-                const wrappedResponse = wrapUntrustedCliResponse(response, { source: 'inline-cli-response', tool: 'ask_gemini' });
-                return inlineSuccessBlocks(metadataText, wrappedResponse);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: responseLines.join('\n')
-                    }]
-            };
-        }
-        catch (err) {
-            const errMsg = err.message;
-            errors.push(`${tryModel}: ${errMsg}`);
-            // Only retry on retryable errors (model not found, 429/rate limit)
-            if (!/model error|model.?not.?found|model is not supported|429|rate.?limit|too many requests|quota.?exceeded|resource.?exhausted/i.test(errMsg)) {
-                // Non-retryable error — stop immediately
-                return singleErrorBlock(`${paramLines}\n\n---\n\nGemini CLI error: ${errMsg}`);
-            }
-            // Continue to next model in chain
-        }
-    }
-    return singleErrorBlock(`${paramLines}\n\n---\n\nGemini CLI error: all models in fallback chain failed.\n${errors.join('\n')}`);
-}
-//# sourceMappingURL=gemini-core.js.map