@kbediako/codex-orchestrator 0.1.38 → 0.2.0

package/dist/scripts/lib/review-launch-attempt.js

@@ -0,0 +1,601 @@
+import { spawn } from 'node:child_process';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { createRuntimeCodexCommandContext, parseRuntimeMode, resolveRuntimeCodexCommand } from '../../orchestrator/src/cli/runtime/index.js';
+import { runDoctor } from '../../orchestrator/src/cli/doctor.js';
+import { formatDoctorIssueLogSummary, writeDoctorIssueLog } from '../../orchestrator/src/cli/doctorIssueLog.js';
+import { ReviewExecutionState } from './review-execution-state.js';
+import { formatCommandIntentViolationLabel } from './review-command-intent-classification.js';
+import { CodexReviewError, signalChildProcess } from './review-execution-runtime.js';
+import { formatReviewOutcomeSummary } from './review-execution-telemetry.js';
+const REVIEW_COMMAND_CHECK_TIMEOUT_MS = 30_000;
+const REVIEW_ARTIFACTS_DIRNAME = 'review';
+const REVIEW_DISABLE_DELEGATION_CONFIG_OVERRIDE = 'mcp_servers.delegation.enabled=false';
+const REVIEW_READ_ONLY_SANDBOX_CONFIG_OVERRIDE = 'sandbox_mode="read-only"';
+const REVIEW_PARTIAL_OUTPUT_HINT_BOUNDARY_KINDS = new Set(['timeout', 'stall', 'startup-loop']);
+const COMMAND_INTENT_RETRY_PROMPT_PREFIX = [
+    'Strict bounded review retry.',
+    'A previous bounded review attempt crossed the command-intent boundary by trying to run validation or another disallowed orchestration command.',
+    'Do not run validation commands, nested review/pipeline commands, or delegation control commands in this retry.',
+    'Use read-only inspection only. If validation would improve confidence, list the command as a follow-up instead of executing it.',
+    'Return a review verdict: start with concrete findings, or state that you found no actionable issues.'
+].join('\n');
+export async function resolveReviewRuntimeContext(params) {
+    const runId = await resolveReviewRunId(params.manifestPath);
+    const requestedMode = params.options.runtimeMode ??
+        parseRuntimeMode(params.env.CODEX_ORCHESTRATOR_RUNTIME_MODE_ACTIVE ??
+            params.env.CODEX_ORCHESTRATOR_RUNTIME_MODE ??
+            null);
+    return await createRuntimeCodexCommandContext({
+        requestedMode,
+        executionMode: 'mcp',
+        repoRoot: params.repoRoot,
+        env: params.env,
+        runId: runId ?? `review-${Date.now()}`
+    });
+}
+export async function prepareReviewArtifacts(manifestPath, prompt, repoRoot) {
+    const reviewDir = resolveReviewArtifactsDir(manifestPath, repoRoot);
+    await mkdir(reviewDir, { recursive: true });
+    const promptPath = path.join(reviewDir, 'prompt.txt');
+    const outputLogPath = path.join(reviewDir, 'output.log');
+    const telemetryPath = path.join(reviewDir, 'telemetry.json');
+    await writeFile(promptPath, `${prompt}\n`, 'utf8');
+    return { reviewDir, promptPath, outputLogPath, telemetryPath };
+}
+export async function runReviewLaunchAttemptShell(options) {
+    // Keep review launch retries centralized here while run-review, non-interactive handoff,
+    // and execution-boundary preflight still share the same launch semantics.
+    const ensureCommandAvailable = options.ensureReviewCommandAvailableFn ?? ensureReviewCommandAvailable;
+    const resolveCommand = options.resolveReviewCommandFn ?? resolveReviewCommand;
+    const captureReviewFailureIssueLog = options.captureReviewFailureIssueLogFn ?? maybeCaptureReviewFailureIssueLog;
+    await ensureCommandAvailable(options.runtimeContext);
+    const disableDelegationMcp = options.cliOptions.disableDelegationMcp ??
+        (options.cliOptions.enableDelegationMcp === undefined ? false : !options.cliOptions.enableDelegationMcp);
+    if (disableDelegationMcp) {
+        console.log('[run-review] delegation MCP disabled for this review (explicit opt-out via --disable-delegation-mcp or CODEX_REVIEW_DISABLE_DELEGATION_MCP=1).');
+    }
+    else {
+        console.log('[run-review] delegation MCP enabled for this review (default; set --disable-delegation-mcp or CODEX_REVIEW_DISABLE_DELEGATION_MCP=1 to disable).');
+    }
+    const scopedReviewArgs = buildReviewArgs(options.cliOptions, options.prompt, {
+        includeScopeFlags: true,
+        disableDelegationMcp
+    });
+    const scopedLaunchContext = buildReviewLaunchContext(options.cliOptions, {
+        includeScopeFlags: true
+    });
+    const resolvedScoped = resolveCommand(scopedReviewArgs, options.runtimeContext);
+    const launchedWithExplicitScope = scopedReviewArgs.some((arg) => arg === '--base' || arg === '--commit' || arg === '--uncommitted');
+    console.log(`Review prompt saved to: ${path.relative(options.repoRoot, options.artifactPaths.promptPath)}`);
+    console.log(`Review output log: ${path.relative(options.repoRoot, options.artifactPaths.outputLogPath)}`);
+    console.log(`Launching Codex review (evidence: ${path.relative(options.repoRoot, options.manifestPath)})`);
+    if (scopedLaunchContext.prompt_delivery === 'artifact-only' &&
+        scopedLaunchContext.scope_flag_mode !== null) {
+        if (scopedLaunchContext.reviewer_visible_context_transport === 'scoped-title') {
+            const titleSourceLabel = scopedLaunchContext.reviewer_visible_title_source === 'user'
+                ? 'user-provided --title'
+                : 'bounded NOTES+surface title';
+            console.log(`[run-review] explicit ${scopedLaunchContext.scope_flag_mode} scope keeps full prompt context in the saved artifact; current codex review still rejects inline prompt transport under scope flags, so this launch omits any prompt argument and uses ${titleSourceLabel} for reviewer-visible context.`);
+        }
+        else {
+            console.log(`[run-review] explicit ${scopedLaunchContext.scope_flag_mode} scope keeps prompt context in the saved artifact only; current codex review still treats stdin ("-") as [PROMPT], so this launch omits any prompt argument.`);
+        }
+    }
+    const reportSuccess = async (execution, launchContext, preservedTerminationBoundary) => {
+        const telemetryPayload = await options.writeTelemetry(execution.state, 'succeeded', null, preservedTerminationBoundary ?? execution.terminationBoundary ?? null, launchContext);
+        console.log(`Review output saved to: ${path.relative(options.repoRoot, options.artifactPaths.outputLogPath)}`);
+        if (telemetryPayload) {
+            console.log(`[run-review] review outcome: ${formatReviewOutcomeSummary(telemetryPayload)}.`);
+            console.log(`Review telemetry saved to: ${path.relative(options.repoRoot, options.artifactPaths.telemetryPath)}`);
+        }
+        else {
+            console.warn('[run-review] review telemetry unavailable (persistence failed); see earlier telemetry error logs.');
+        }
+    };
+    const reportFailure = async (error, launchContext) => {
+        await captureReviewFailureIssueLog({
+            enabled: options.autoIssueLogEnabled,
+            error,
+            taskFilter: options.cliOptions.task ?? null,
+            manifestPath: options.manifestPath,
+            outputLogPath: options.artifactPaths.outputLogPath,
+            repoRoot: options.repoRoot
+        });
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const failureState = error instanceof CodexReviewError &&
+            'reviewState' in error &&
+            error.reviewState instanceof ReviewExecutionState
+            ? error.reviewState
+            : null;
+        const failureTerminationBoundary = error instanceof CodexReviewError ? error.terminationBoundary : null;
+        const telemetryPayload = failureState
+            ? await options.writeTelemetry(failureState, 'failed', errorMessage, failureTerminationBoundary, launchContext)
+            : null;
+        if (telemetryPayload) {
+            options.logTelemetrySummary(telemetryPayload, path.relative(options.repoRoot, options.artifactPaths.telemetryPath), {
+                debugTelemetry: options.telemetryDebugEnabled,
+                telemetryDebugEnvKey: options.telemetryDebugEnvKey
+            });
+        }
+        else if (failureState) {
+            options.logTerminationBoundaryFallback(failureTerminationBoundary ?? failureState.getTerminationBoundaryRecord(errorMessage));
+        }
+        if (shouldLogPartialReviewOutput(failureTerminationBoundary)) {
+            console.error(`Review output log (partial): ${path.relative(options.repoRoot, options.artifactPaths.outputLogPath)}`);
+        }
+    };
+    const maybeRetryAfterCommandIntentBoundary = async (error, launchContext, resolvedFailedLaunch) => {
+        if (!shouldRetryAfterCommandIntentBoundary(error, launchContext)) {
+            return false;
+        }
+        const commandIntentBoundary = error instanceof CodexReviewError ? error.terminationBoundary : null;
+        const commandIntentFailureState = error instanceof CodexReviewError && error.reviewState instanceof ReviewExecutionState
+            ? error.reviewState
+            : null;
+        const commandIntentRetryOptions = buildCommandIntentRetryOptions(options.cliOptions);
+        const commandIntentRetryPrompt = buildCommandIntentRetryPrompt(options.prompt, commandIntentFailureState, options.cliOptions);
+        const commandIntentRetryArgs = buildReviewArgs(commandIntentRetryOptions, commandIntentRetryPrompt, {
+            includeScopeFlags: false,
+            disableDelegationMcp,
+            inlineReadOnlySandbox: true
+        });
+        const commandIntentRetryLaunchContext = buildReviewLaunchContext(commandIntentRetryOptions, {
+            includeScopeFlags: false
+        });
+        const resolvedCommandIntentRetry = resolveCommand(commandIntentRetryArgs, options.runtimeContext);
+        if (resolvedReviewCommandsEqual(resolvedFailedLaunch, resolvedCommandIntentRetry)) {
+            await reportFailure(error, launchContext);
+            throw error;
+        }
+        console.log('[run-review] bounded review blocked a validation command; retrying once with reviewer-visible inline no-validation context so the reviewer can produce a verdict without running validation.');
+        console.log('[run-review] command-intent retry keeps the original scope in the inline prompt and adds a read-only sandbox override; another validation command remains a fail-closed boundary.');
+        try {
+            const retryExecution = await options.runReview(resolvedCommandIntentRetry);
+            if (commandIntentFailureState) {
+                retryExecution.state.recordCommandIntentViolationsFrom(commandIntentFailureState);
+            }
+            await reportSuccess(retryExecution, commandIntentRetryLaunchContext, commandIntentBoundary);
+            return true;
+        }
+        catch (retryError) {
+            await reportFailure(retryError, commandIntentRetryLaunchContext);
+            throw retryError;
+        }
+    };
+    try {
+        const execution = await options.runReview(resolvedScoped);
+        await reportSuccess(execution, scopedLaunchContext);
+        return;
+    }
+    catch (error) {
+        if (await maybeRetryAfterCommandIntentBoundary(error, scopedLaunchContext, resolvedScoped)) {
+            return;
+        }
+        if (shouldRetryScopedWithoutSynthesizedTitle(error, options.cliOptions)) {
+            const scopedArtifactOnlyOptions = {
+                ...options.cliOptions,
+                title: undefined,
+                titleSource: undefined
+            };
+            const scopedArtifactOnlyArgs = buildReviewArgs(scopedArtifactOnlyOptions, options.prompt, {
+                includeScopeFlags: true,
+                disableDelegationMcp
+            });
+            const scopedArtifactOnlyLaunchContext = buildReviewLaunchContext(scopedArtifactOnlyOptions, {
+                includeScopeFlags: true
+            });
+            const resolvedScopedArtifactOnly = resolveCommand(scopedArtifactOnlyArgs, options.runtimeContext);
+            if (resolvedReviewCommandsEqual(resolvedScoped, resolvedScopedArtifactOnly)) {
+                await reportFailure(error, scopedLaunchContext);
+                throw error;
+            }
+            console.log('[run-review] codex CLI rejected synthesized scoped --title transport; retrying the same explicit scope without --title and falling back to artifact-only reviewer-visible context.');
+            try {
+                const retryExecution = await options.runReview(resolvedScopedArtifactOnly);
+                await reportSuccess(retryExecution, scopedArtifactOnlyLaunchContext);
+                return;
+            }
+            catch (retryError) {
+                if (await maybeRetryAfterCommandIntentBoundary(retryError, scopedArtifactOnlyLaunchContext, resolvedScopedArtifactOnly)) {
+                    return;
+                }
+                await reportFailure(retryError, scopedArtifactOnlyLaunchContext);
+                throw retryError;
+            }
+        }
+        if (scopedLaunchContext.prompt_delivery !== 'inline' &&
+            isPromptScopeIncompatibility(error)) {
+            await reportFailure(error, scopedLaunchContext);
+            throw error;
+        }
+        if (shouldRetryWithoutScopeFlags(error)) {
+            if (launchedWithExplicitScope) {
+                if (options.retryWithoutScopeFlagsGateError &&
+                    shouldRewriteRetryFailureAsScopeGate(error, options.cliOptions)) {
+                    const retryGateError = buildRetryWithoutScopeFlagsGateError(error, options.repoRoot, options.retryWithoutScopeFlagsGateError);
+                    await reportFailure(retryGateError, scopedLaunchContext);
+                    throw retryGateError;
+                }
+                await reportFailure(error, scopedLaunchContext);
+                throw error;
+            }
+            if (options.retryWithoutScopeFlagsGateError &&
+                shouldRewriteRetryFailureAsScopeGate(error, options.cliOptions)) {
+                const retryGateError = buildRetryWithoutScopeFlagsGateError(error, options.repoRoot, options.retryWithoutScopeFlagsGateError);
+                await reportFailure(retryGateError, scopedLaunchContext);
+                throw retryGateError;
+            }
+            const unscopedArgs = buildReviewArgs(options.cliOptions, options.prompt, {
+                includeScopeFlags: false,
+                disableDelegationMcp
+            });
+            const unscopedLaunchContext = buildReviewLaunchContext(options.cliOptions, {
+                includeScopeFlags: false
+            });
+            const resolvedUnscoped = resolveCommand(unscopedArgs, options.runtimeContext);
+            if (resolvedReviewCommandsEqual(resolvedScoped, resolvedUnscoped)) {
+                await reportFailure(error, scopedLaunchContext);
+                throw error;
+            }
+            console.log('[run-review] codex CLI rejected scope flags with a custom prompt; retrying without flags.');
+            try {
+                const retryExecution = await options.runReview(resolvedUnscoped);
+                await reportSuccess(retryExecution, unscopedLaunchContext);
+                return;
+            }
+            catch (retryError) {
+                await reportFailure(retryError, unscopedLaunchContext);
+                throw retryError;
+            }
+        }
+        await reportFailure(error, scopedLaunchContext);
+        throw error;
+    }
+}
+async function ensureReviewCommandAvailable(context) {
+    const resolved = resolveRuntimeCodexCommand(['--help'], context);
+    const hasReview = await new Promise((resolve, reject) => {
+        const detached = process.platform !== 'win32';
+        const child = spawn(resolved.command, resolved.args, { stdio: ['ignore', 'pipe', 'pipe'], detached });
+        let output = '';
+        let settled = false;
+        let hardKillArmed = false;
+        let killHandle;
+        const timeoutHandle = setTimeout(() => {
+            if (settled) {
+                return;
+            }
+            signalChildProcess(child, 'SIGTERM', detached);
+            hardKillArmed = true;
+            killHandle = setTimeout(() => {
+                if (child.exitCode === null) {
+                    signalChildProcess(child, 'SIGKILL', detached);
+                }
+            }, 5000);
+            killHandle.unref();
+            settled = true;
+            reject(new Error('codex --help timed out while checking the review subcommand.'));
+        }, REVIEW_COMMAND_CHECK_TIMEOUT_MS);
+        timeoutHandle.unref();
+        const finalize = (outcome) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeoutHandle);
+            if (killHandle && !hardKillArmed) {
+                clearTimeout(killHandle);
+            }
+            if ('error' in outcome) {
+                reject(outcome.error);
+            }
+            else {
+                resolve(outcome.ok);
+            }
+        };
+        child.stdout?.on('data', (chunk) => {
+            output += chunk.toString();
+        });
+        child.stderr?.on('data', (chunk) => {
+            output += chunk.toString();
+        });
+        child.once('error', (error) => finalize({ error: error instanceof Error ? error : new Error(String(error)) }));
+        child.once('close', () => {
+            finalize({ ok: output.includes(' review') });
+        });
+    });
+    if (!hasReview) {
+        throw new Error('codex CLI is missing the `review` subcommand (or is not installed).');
+    }
+}
+async function resolveReviewRunId(manifestPath) {
+    try {
+        const raw = await readFile(manifestPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed.run_id === 'string' && parsed.run_id.trim().length > 0
+            ? parsed.run_id.trim()
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveScopeFlag(options) {
+    if (options.commit) {
+        return { mode: 'commit', args: ['--commit', options.commit] };
+    }
+    if (options.base) {
+        return { mode: 'base', args: ['--base', options.base] };
+    }
+    if (options.uncommitted) {
+        return { mode: 'uncommitted', args: ['--uncommitted'] };
+    }
+    return null;
+}
+function buildReviewArgs(options, prompt, opts) {
+    const args = [];
+    if (opts.disableDelegationMcp) {
+        args.push('-c', REVIEW_DISABLE_DELEGATION_CONFIG_OVERRIDE);
+    }
+    if (opts.inlineReadOnlySandbox) {
+        args.push('-c', REVIEW_READ_ONLY_SANDBOX_CONFIG_OVERRIDE);
+    }
+    args.push('review');
+    const reviewTitle = resolveReviewTitle(options);
+    if (reviewTitle.title) {
+        args.push('--title', reviewTitle.title);
+    }
+    const scopeFlag = resolveScopeFlag(options);
+    if (opts.includeScopeFlags && scopeFlag) {
+        args.push(...scopeFlag.args);
+    }
+    const launchContext = buildReviewLaunchContext(options, opts);
+    if (launchContext.prompt_delivery === 'inline') {
+        args.push(prompt);
+    }
+    return args;
+}
+function buildReviewLaunchContext(options, opts) {
+    const scopedFlag = opts.includeScopeFlags ? resolveScopeFlag(options) : null;
+    const reviewTitle = resolveReviewTitle(options);
+    return {
+        scope_flag_mode: scopedFlag?.mode ?? null,
+        prompt_delivery: scopedFlag ? 'artifact-only' : 'inline',
+        reviewer_visible_context_transport: scopedFlag
+            ? reviewTitle.source
+                ? 'scoped-title'
+                : 'artifact-only'
+            : 'inline-prompt',
+        reviewer_visible_title_source: scopedFlag ? reviewTitle.source : null
+    };
+}
+function resolveReviewTitle(options) {
+    const rawTitle = typeof options.title === 'string' ? options.title.trim() : '';
+    if (rawTitle.length === 0) {
+        return { title: null, source: null };
+    }
+    return {
+        title: rawTitle,
+        source: options.titleSource ?? 'user'
+    };
+}
+function resolveReviewCommand(reviewArgs, context) {
+    return resolveRuntimeCodexCommand(reviewArgs, context);
+}
+function resolveReviewArtifactsDir(manifestPath, repoRoot) {
+    const configuredRunDir = process.env.CODEX_ORCHESTRATOR_RUN_DIR?.trim();
+    if (configuredRunDir && configuredRunDir.length > 0) {
+        const resolvedRunDir = path.resolve(repoRoot, configuredRunDir);
+        const configuredManifestPath = path.join(resolvedRunDir, 'manifest.json');
+        if (configuredManifestPath === path.resolve(manifestPath)) {
+            return path.join(resolvedRunDir, REVIEW_ARTIFACTS_DIRNAME);
+        }
+    }
+    return path.join(path.dirname(manifestPath), REVIEW_ARTIFACTS_DIRNAME);
+}
+async function maybeCaptureReviewFailureIssueLog(options) {
+    if (!options.enabled) {
+        return null;
+    }
+    const errorMessage = options.error instanceof Error ? options.error.message : String(options.error);
+    const issueNotes = [
+        'Automatic failure capture for standalone review wrapper.',
+        `Error: ${errorMessage}`,
+        `Manifest: ${path.relative(options.repoRoot, options.manifestPath)}`,
+        `Output log: ${path.relative(options.repoRoot, options.outputLogPath)}`
+    ].join(' | ');
+    try {
+        const issueLog = await writeDoctorIssueLog({
+            doctor: runDoctor(),
+            issueTitle: 'Auto issue log: standalone review failed',
+            issueNotes,
+            taskFilter: options.taskFilter
+        });
+        console.error('[run-review] captured review failure issue log:');
+        for (const line of formatDoctorIssueLogSummary(issueLog)) {
+            console.error(`[run-review] ${line}`);
+        }
+        return issueLog;
+    }
+    catch (issueError) {
+        const message = issueError instanceof Error ? issueError.message : String(issueError);
+        console.error(`[run-review] failed to capture review issue log: ${message}`);
+        return null;
+    }
+}
+function shouldLogPartialReviewOutput(terminationBoundary) {
+    return (terminationBoundary !== null &&
+        REVIEW_PARTIAL_OUTPUT_HINT_BOUNDARY_KINDS.has(terminationBoundary.kind));
+}
+function resolvedReviewCommandsEqual(left, right) {
+    return (left.command === right.command &&
+        left.args.length === right.args.length &&
+        left.args.every((arg, index) => arg === right.args[index]));
+}
+function shouldRetryAfterCommandIntentBoundary(error, launchContext) {
+    return (error instanceof CodexReviewError &&
+        error.terminationBoundary?.kind === 'command-intent' &&
+        launchContext.prompt_delivery === 'artifact-only' &&
+        launchContext.scope_flag_mode !== null);
+}
+function buildCommandIntentRetryOptions(options) {
+    return {
+        ...options,
+        title: undefined,
+        titleSource: undefined
+    };
+}
+function buildCommandIntentRetryPrompt(prompt, failureState, options) {
+    const boundaryState = failureState?.getCommandIntentBoundaryState() ?? null;
+    const blockedAttemptLine = boundaryState?.violationKind
+        ? `Blocked attempt: ${formatCommandIntentViolationLabel(boundaryState.violationKind)}.`
+        : 'Blocked attempt: bounded command-intent boundary.';
+    const blockedSampleLine = boundaryState?.violationSample
+        ? `Treat this as a follow-up command only, not something to rerun: ${boundaryState.violationSample}`
+        : 'Treat any validation or nested review command you considered as a follow-up command only, not something to rerun.';
+    const scopeLine = formatCommandIntentRetryScopeLine(options);
+    return [
+        COMMAND_INTENT_RETRY_PROMPT_PREFIX,
+        scopeLine,
+        blockedAttemptLine,
+        blockedSampleLine,
+        '',
+        prompt
+    ].join('\n');
+}
+function formatCommandIntentRetryScopeLine(options) {
+    const scopeFlag = resolveScopeFlag(options);
+    if (!scopeFlag) {
+        return 'Retry review scope: wrapper default review scope.';
+    }
+    return `Retry review scope: ${scopeFlag.args.join(' ')}. Use this same logical scope while inspecting the diff.`;
+}
+function shouldRetryWithoutScopeFlags(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const preview = 'outputPreview' in error ? String(error.outputPreview ?? '') : '';
+    const message = 'message' in error ? String(error.message ?? '') : '';
+    const combined = `${message}\n${preview}`.toLowerCase();
+    return (combined.includes('unknown option') ||
+        combined.includes('unknown flag') ||
+        combined.includes('unrecognized option') ||
+        combined.includes('cannot be used with') ||
+        combined.includes('cannot be combined') ||
+        combined.includes('incompatible with') ||
+        combined.includes('prompt cannot') ||
+        combined.includes('custom prompt') ||
+        combined.includes('with a prompt'));
+}
+function shouldRetryScopedWithoutSynthesizedTitle(error, cliOptions) {
+    if (cliOptions.titleSource !== 'notes-surface') {
+        return false;
+    }
+    if (!resolveScopeFlag(cliOptions)) {
+        return false;
+    }
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const preview = 'outputPreview' in error ? String(error.outputPreview ?? '') : '';
+    const message = 'message' in error ? String(error.message ?? '') : '';
+    const combined = `${message}\n${preview}`.toLowerCase();
+    const lines = combined
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    return (hasExplicitScopeFlagRejectionSignal(lines, '--title') ||
+        lines.some((line) => line.includes('--title') && hasPromptScopeFlagRejectionSignal(line)));
+}
+function isPromptScopeIncompatibility(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const preview = 'outputPreview' in error ? String(error.outputPreview ?? '') : '';
+    const message = 'message' in error ? String(error.message ?? '') : '';
+    const combined = `${message}\n${preview}`.toLowerCase();
+    return (combined.includes('prompt cannot') ||
+        combined.includes('custom prompt') ||
+        combined.includes('with a prompt'));
+}
+function shouldRewriteRetryFailureAsScopeGate(error, cliOptions) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const scopeFlag = resolveScopeFlag(cliOptions);
+    const scopeFlagToken = scopeFlag?.args[0]?.toLowerCase() ?? null;
+    if (!scopeFlagToken) {
+        return false;
+    }
+    const preview = 'outputPreview' in error ? String(error.outputPreview ?? '') : '';
+    const message = 'message' in error ? String(error.message ?? '') : '';
+    const combined = `${message}\n${preview}`.toLowerCase();
+    const lines = combined
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    return (hasExplicitScopeFlagRejectionSignal(lines, scopeFlagToken) ||
+        lines.some((line) => line.includes(scopeFlagToken) &&
+            hasPromptScopeFlagRejectionSignal(line)) ||
+        hasPromptScopeIncompatibilitySignal(lines, scopeFlagToken));
+}
+function hasExplicitScopeFlagRejectionSignal(lines, scopeFlagToken) {
+    const escapedScopeFlagToken = escapeForRegExp(scopeFlagToken);
+    const quotedOrBareScopeFlagToken = `(?:['"]${escapedScopeFlagToken}['"]|${escapedScopeFlagToken})`;
+    const tokenBoundary = `(?=$|\\s|[),.:;])`;
+    const directScopeRejectionPatterns = [
+        new RegExp(`(?:unknown option|unknown flag|unrecognized option)\\s+${quotedOrBareScopeFlagToken}${tokenBoundary}`),
+        new RegExp(`^(?:option\\s+)?${quotedOrBareScopeFlagToken}\\s+(?:cannot be used with|cannot be combined|is incompatible with)`),
+        new RegExp(`^(?:flag\\s+)?${quotedOrBareScopeFlagToken}\\s+(?:cannot be used with|cannot be combined|is incompatible with)`),
+        new RegExp(`.+(?:cannot be used with|cannot be combined|incompatible with)\\s+${quotedOrBareScopeFlagToken}${tokenBoundary}`)
+    ];
+    return lines.some((line) => directScopeRejectionPatterns.some((pattern) => pattern.test(line)));
+}
+function hasPromptScopeFlagRejectionSignal(line) {
+    const mentionsPrompt = line.includes('prompt cannot') ||
+        line.includes('custom prompt') ||
+        line.includes('with a prompt');
+    if (!mentionsPrompt) {
+        return false;
+    }
+    return (line.includes('unknown option') ||
+        line.includes('unknown flag') ||
+        line.includes('unrecognized option') ||
+        line.includes('cannot be used with') ||
+        line.includes('cannot be combined') ||
+        line.includes('incompatible with') ||
+        line.includes('prompt cannot') ||
+        line.includes('custom prompt') ||
+        line.includes('with a prompt'));
+}
+function hasPromptScopeIncompatibilitySignal(lines, _scopeFlagToken) {
+    return lines.some((line) => {
+        const mentionsPrompt = line.includes('prompt cannot') ||
+            line.includes('custom prompt') ||
+            line.includes('with a prompt');
+        if (!mentionsPrompt) {
+            return false;
+        }
+        return (line.includes('diff scoping') ||
+            line.includes('diff-scoping') ||
+            line.includes('review scope') ||
+            line.includes('scope flags'));
+    });
+}
+function buildRetryWithoutScopeFlagsGateError(error, repoRoot, retryWithoutScopeFlagsGateError) {
+    const originalError = error instanceof CodexReviewError ? error : null;
+    return new CodexReviewError(`codex CLI rejected the explicit review scope flags, and retrying without them would remove explicit review scope. ${retryWithoutScopeFlagsGateError}`, {
+        exitCode: typeof originalError?.exitCode === 'number' && originalError.exitCode > 0
+            ? originalError.exitCode
+            : 1,
+        signal: originalError?.signal ?? null,
+        timedOut: false,
+        outputPreview: originalError?.outputPreview ?? '',
+        reviewState: originalError?.reviewState ?? new ReviewExecutionState({ repoRoot }),
+        terminationBoundary: originalError?.terminationBoundary ?? null
+    });
+}
+function escapeForRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}