@kbediako/codex-orchestrator 0.1.38 → 0.2.1

package/dist/orchestrator/src/cli/control/providerOperatorAutopilotLocalRolloutExecution.js

@@ -0,0 +1,1006 @@
+import { execFile } from 'node:child_process';
+import { access, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import process from 'node:process';
+import { promisify } from 'node:util';
+import { acquireLockWithRetry } from '../../persistence/lockFile.js';
+import { isoTimestamp } from '../utils/time.js';
+const execFileAsync = promisify(execFile);
+export const PROVIDER_OPERATOR_AUTOPILOT_LOCAL_ROLLOUT_EXECUTION_FILENAME = 'provider-operator-autopilot-local-rollout-executions.json';
+const LOCAL_ROLLOUT_EXECUTION_LOCK_RETRY = {
+    maxAttempts: 450,
+    initialDelayMs: 10,
+    backoffFactor: 1.2,
+    maxDelayMs: 100,
+    staleMs: 30_000
+};
+const DEFAULT_LOCAL_ROLLOUT_EXECUTION_TIMEOUT_MS = 15_000;
+const SUPPORTED_NODE_PLATFORMS = new Set([
+    'aix',
+    'android',
+    'darwin',
+    'freebsd',
+    'haiku',
+    'linux',
+    'openbsd',
+    'sunos',
+    'win32',
+    'cygwin',
+    'netbsd'
+]);
+export function resolveProviderOperatorAutopilotLocalRolloutExecutionPath(runDir) {
+    return join(runDir, PROVIDER_OPERATOR_AUTOPILOT_LOCAL_ROLLOUT_EXECUTION_FILENAME);
+}
+export async function readProviderOperatorAutopilotLocalRolloutExecutionRecords(executionPath) {
+    let raw;
+    try {
+        raw = await readFile(executionPath, 'utf8');
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+    const parsed = JSON.parse(raw);
+    return parseExecutionStore(parsed).records;
+}
+export async function appendProviderOperatorAutopilotLocalRolloutExecutionRecord(executionPath, record) {
+    return withExecutionWriteLock(executionPath, async () => {
+        const records = await readProviderOperatorAutopilotLocalRolloutExecutionRecords(executionPath);
+        const nextStore = {
+            version: 1,
+            records: [...records, cloneLocalRolloutExecutionAttempt(record)]
+        };
+        await writeExecutionStore(executionPath, nextStore);
+        return {
+            version: 1,
+            records: nextStore.records.map(cloneLocalRolloutExecutionAttempt)
+        };
+    });
+}
+export function cloneLocalRolloutExecutionAttempt(record) {
+    return {
+        record_kind: record.record_kind ?? 'terminal',
+        action_instance_id: record.action_instance_id,
+        action_id: record.action_id,
+        issue_id: record.issue_id,
+        issue_identifier: record.issue_identifier,
+        preflight: { ...record.preflight },
+        started_at: record.started_at,
+        ended_at: record.ended_at,
+        terminal_state: record.terminal_state,
+        reason: record.reason,
+        summary: record.summary,
+        command: {
+            runner: record.command.runner,
+            command: record.command.command,
+            args: [...record.command.args],
+            cwd: record.command.cwd,
+            timeout_ms: record.command.timeout_ms
+        },
+        exit_code: record.exit_code,
+        stdout: record.stdout,
+        stderr: record.stderr
+    };
+}
+export function resolveProviderOperatorAutopilotLocalRolloutExecutionConfig(value) {
+    const postMergeRollout = asRecord(value);
+    const execution = asRecord(postMergeRollout?.execution ?? postMergeRollout?.local_rollout_execution);
+    const enabled = readBoolean(execution, 'enabled') ?? false;
+    const actionValues = Array.isArray(execution?.actions) ? execution.actions : [];
+    const actions = actionValues
+        .map(parseActionConfig)
+        .filter((action) => Boolean(action))
+        .sort(compareActionConfig);
+    return { enabled, actions };
+}
+export function resolveEnabledLocalRolloutExecutionActionIds(config) {
+    if (!config.enabled) {
+        return [];
+    }
+    return uniqueStrings(config.actions.filter((action) => action.enabled).sort(compareActionConfig).map((action) => action.id));
+}
+export async function executeProviderOperatorAutopilotLocalRolloutActions(input, deps = {}) {
+    const now = deps.now ?? isoTimestamp;
+    const platform = deps.platform ?? process.platform;
+    const runCommand = deps.runCommand ?? runLocalRolloutCommand;
+    const fileExists = deps.fileExists ?? defaultFileExists;
+    const actionMap = buildActionConfigMap(input.config.actions);
+    const priorAttempts = (input.priorAttempts ?? []).map(cloneLocalRolloutExecutionAttempt);
+    const relevantAttempts = [];
+    const lifecycleRecords = [];
+    if (!input.config.enabled) {
+        return { attempts: [], lifecycle_records: [] };
+    }
+    const priorByActionKey = new Map();
+    const priorAttemptsByActionKey = new Map();
+    const priorByActionKeyForEmptyProjection = new Map();
+    for (const attempt of priorAttempts) {
+        const attemptKey = executionAttemptKey(attempt);
+        priorByActionKey.set(attemptKey, selectPriorExecutionAttempt(priorByActionKey.get(attemptKey), attempt));
+        priorAttemptsByActionKey.set(attemptKey, [
+            ...(priorAttemptsByActionKey.get(attemptKey) ?? []),
+            cloneLocalRolloutExecutionAttempt(attempt)
+        ]);
+        priorByActionKeyForEmptyProjection.set(attemptKey, selectPriorExecutionAttemptForProjection(priorByActionKeyForEmptyProjection.get(attemptKey), attempt));
+    }
+    for (const pendingAction of input.pendingActions) {
+        const actionIds = uniqueStrings(pendingAction.executable_action_ids ?? []);
+        const succeededActionIds = new Set();
+        let sawNonSuccess = false;
+        if (actionIds.length === 0) {
+            appendPriorAttemptsForActionInstance({
+                target: relevantAttempts,
+                priorByActionKey: priorByActionKeyForEmptyProjection,
+                priorAttemptsByActionKey,
+                actionInstanceId: pendingAction.action_instance_id
+            });
+            continue;
+        }
+        for (const actionId of actionIds) {
+            const actionKey = `${pendingAction.action_instance_id}\u0000${actionId}`;
+            const priorAttempt = priorByActionKey.get(actionKey);
+            const priorAttemptCandidates = priorAttemptsByActionKey.get(actionKey) ?? [];
+            if (priorAttempt && shouldReusePriorExecutionAttempt(priorAttempt, priorAttemptCandidates)) {
+                relevantAttempts.push(...selectPriorExecutionAttemptsForReuse(priorAttemptCandidates, priorAttempt));
+                if (isSucceededTerminalAttempt(priorAttempt)) {
+                    succeededActionIds.add(actionId);
+                }
+                else {
+                    sawNonSuccess = true;
+                    break;
+                }
+                continue;
+            }
+            const actionResult = await runSingleLocalRolloutAction({
+                action: actionMap.get(actionId) ?? null,
+                actionId,
+                pendingAction,
+                repoRoot: input.repoRoot,
+                now,
+                platform,
+                runCommand,
+                fileExists,
+                appendExecutionAttempt: deps.appendExecutionAttempt
+            });
+            const shouldAppendTerminalAttempt = Boolean(deps.appendExecutionAttempt) && actionResult.appendTerminalAttempt;
+            const recordsReadyForProjection = shouldAppendTerminalAttempt
+                ? actionResult.records.filter((record) => record !== actionResult.terminalAttempt)
+                : actionResult.records;
+            for (const record of recordsReadyForProjection) {
+                relevantAttempts.push(cloneLocalRolloutExecutionAttempt(record));
+            }
+            const attempt = actionResult.terminalAttempt;
+            let terminalAttemptPersisted = false;
+            if (!actionResult.appendTerminalAttempt) {
+                terminalAttemptPersisted = false;
+            }
+            if (deps.appendExecutionAttempt && actionResult.appendTerminalAttempt) {
+                try {
+                    await deps.appendExecutionAttempt(attempt);
+                    terminalAttemptPersisted = true;
+                    relevantAttempts.push(cloneLocalRolloutExecutionAttempt(attempt));
+                }
+                catch {
+                    const failedAttempt = buildSyntheticAttempt({
+                        pendingAction,
+                        actionId,
+                        now,
+                        state: 'failed',
+                        reason: 'execution_audit_failed',
+                        summary: 'Local rollout command finished, but terminal execution audit persistence failed.'
+                    });
+                    relevantAttempts.push(cloneLocalRolloutExecutionAttempt(failedAttempt));
+                }
+            }
+            if (isSucceededTerminalAttempt(attempt) && terminalAttemptPersisted) {
+                succeededActionIds.add(actionId);
+            }
+            else {
+                sawNonSuccess = true;
+                break;
+            }
+        }
+        if (!sawNonSuccess && succeededActionIds.size === actionIds.length) {
+            if (!deps.appendLifecycleRecord) {
+                const failedAttempt = buildSyntheticAttempt({
+                    pendingAction,
+                    actionId: actionIds.at(-1) ?? 'unknown',
+                    now,
+                    state: 'failed',
+                    reason: 'lifecycle_record_failed',
+                    summary: 'Local rollout actions succeeded, but lifecycle clear persistence is unavailable.'
+                });
+                relevantAttempts.push(cloneLocalRolloutExecutionAttempt(failedAttempt));
+                continue;
+            }
+            const lifecycleRecord = {
+                action_instance_id: pendingAction.action_instance_id,
+                kind: 'local_rollout',
+                issue_id: pendingAction.issue_id,
+                issue_identifier: pendingAction.issue_identifier,
+                state: 'cleared',
+                actor: 'operator-autopilot',
+                reason: `unattended local rollout actions succeeded: ${actionIds.join(', ')}`,
+                recorded_at: now(),
+                source: 'operator-autopilot'
+            };
+            try {
+                await deps.appendLifecycleRecord(lifecycleRecord);
+                lifecycleRecords.push(lifecycleRecord);
+            }
+            catch {
+                const failedAttempt = buildSyntheticAttempt({
+                    pendingAction,
+                    actionId: actionIds.at(-1) ?? 'unknown',
+                    now,
+                    state: 'failed',
+                    reason: 'lifecycle_record_failed',
+                    summary: 'Local rollout actions succeeded, but lifecycle clear persistence failed.'
+                });
+                relevantAttempts.push(cloneLocalRolloutExecutionAttempt(failedAttempt));
+            }
+        }
+    }
+    return {
+        attempts: relevantAttempts.map(cloneLocalRolloutExecutionAttempt),
+        lifecycle_records: lifecycleRecords
+    };
+}
+function appendPriorAttemptsForActionInstance(input) {
+    for (const [actionKey, attempt] of input.priorByActionKey.entries()) {
+        if (attempt.action_instance_id !== input.actionInstanceId) {
+            continue;
+        }
+        input.target.push(...selectPriorExecutionAttemptsForReuse(input.priorAttemptsByActionKey.get(actionKey) ?? [], attempt));
+    }
+}
+function parseActionConfig(value) {
+    const record = asRecord(value);
+    if (!record) {
+        return null;
+    }
+    const id = readNonEmptyString(record, 'id');
+    const runner = normalizeRunnerKind(record.runner);
+    if (!id || !runner) {
+        return null;
+    }
+    const platformConfig = readPlatformArray(record, 'supported_platforms', 'supportedPlatforms');
+    return {
+        id,
+        enabled: readBoolean(record, 'enabled') ?? false,
+        order: readInteger(record, 'order') ?? Number.MAX_SAFE_INTEGER,
+        runner,
+        args: readStringArray(record, 'args') ?? [],
+        script: readNonEmptyString(record, 'script'),
+        timeout_ms: readPositiveInteger(record, 'timeout_ms', 'timeoutMs') ??
+            DEFAULT_LOCAL_ROLLOUT_EXECUTION_TIMEOUT_MS,
+        require_clean_repo: readBoolean(record, 'require_clean_repo', 'requireCleanRepo') ?? true,
+        required_branch: readNonEmptyString(record, 'required_branch', 'requiredBranch'),
+        supported_platforms: platformConfig?.supported ?? [],
+        invalid_supported_platforms: platformConfig?.invalid ?? [],
+        deploy_class: readBoolean(record, 'deploy_class', 'deployClass') ?? false,
+        deploy_opt_in: readBoolean(record, 'deploy_opt_in', 'deployOptIn') ?? false,
+        requires_issue_identifier: readBoolean(record, 'requires_issue_identifier', 'requiresIssueIdentifier') ?? false
+    };
+}
+function compareActionConfig(left, right) {
+    if (left.order !== right.order) {
+        return left.order - right.order;
+    }
+    return left.id.localeCompare(right.id);
+}
+function buildActionConfigMap(actions) {
+    const actionMap = new Map();
+    for (const action of [...actions].sort(compareActionConfig)) {
+        const existing = actionMap.get(action.id);
+        if (!existing || (!existing.enabled && action.enabled)) {
+            actionMap.set(action.id, action);
+        }
+    }
+    return actionMap;
+}
+async function runSingleLocalRolloutAction(input) {
+    const checkedAt = input.now();
+    if (!input.appendExecutionAttempt) {
+        const failedAttempt = buildAttempt({
+            pendingAction: input.pendingAction,
+            actionId: input.actionId,
+            preflight: {
+                status: 'failed',
+                reason: 'execution_audit_failed',
+                checked_at: checkedAt,
+                summary: 'Local rollout action was not launched because execution audit persistence is unavailable.'
+            },
+            startedAt: null,
+            endedAt: input.now(),
+            terminalState: 'failed',
+            reason: 'execution_audit_failed',
+            summary: 'Local rollout action was not launched because execution audit persistence is unavailable.',
+            command: {
+                runner: input.action?.runner ?? null,
+                command: null,
+                args: [],
+                cwd: input.repoRoot,
+                timeout_ms: input.action?.timeout_ms ?? null
+            },
+            exitCode: null,
+            stdout: null,
+            stderr: null
+        });
+        return {
+            records: [failedAttempt],
+            terminalAttempt: failedAttempt,
+            appendTerminalAttempt: false
+        };
+    }
+    const preflight = await preflightLocalRolloutAction(input);
+    if (preflight.status !== 'passed' || !preflight.command) {
+        const attempt = buildAttempt({
+            pendingAction: input.pendingAction,
+            actionId: input.actionId,
+            preflight: {
+                status: preflight.status,
+                reason: preflight.reason,
+                checked_at: checkedAt,
+                summary: preflight.summary
+            },
+            startedAt: null,
+            endedAt: input.now(),
+            terminalState: preflight.status === 'failed' ? 'failed' : 'skipped',
+            reason: preflight.reason,
+            summary: preflight.summary,
+            command: preflight.command,
+            exitCode: null,
+            stdout: null,
+            stderr: null
+        });
+        return { records: [attempt], terminalAttempt: attempt, appendTerminalAttempt: true };
+    }
+    const command = preflight.command;
+    if (!command.command || !command.cwd || command.timeout_ms === null) {
+        const attempt = buildAttempt({
+            pendingAction: input.pendingAction,
+            actionId: input.actionId,
+            preflight: {
+                status: 'skipped',
+                reason: 'missing_binary',
+                checked_at: checkedAt,
+                summary: `Local rollout action ${input.actionId} could not resolve its runner binary.`
+            },
+            startedAt: null,
+            endedAt: input.now(),
+            terminalState: 'skipped',
+            reason: 'missing_binary',
+            summary: `Local rollout action ${input.actionId} could not resolve its runner binary.`,
+            command,
+            exitCode: null,
+            stdout: null,
+            stderr: null
+        });
+        return { records: [attempt], terminalAttempt: attempt, appendTerminalAttempt: true };
+    }
+    const startedAt = input.now();
+    const startedAttempt = buildAttempt({
+        pendingAction: input.pendingAction,
+        actionId: input.actionId,
+        recordKind: 'started',
+        preflight: {
+            status: 'passed',
+            reason: null,
+            checked_at: checkedAt,
+            summary: 'Local rollout action preflight passed.'
+        },
+        startedAt,
+        endedAt: startedAt,
+        terminalState: 'failed',
+        reason: 'execution_interrupted',
+        summary: `Local rollout action ${input.actionId} started; terminal result has not been recorded.`,
+        command: preflight.command,
+        exitCode: null,
+        stdout: null,
+        stderr: null
+    });
+    try {
+        await input.appendExecutionAttempt?.(startedAttempt);
+    }
+    catch {
+        const failedAttempt = buildAttempt({
+            pendingAction: input.pendingAction,
+            actionId: input.actionId,
+            preflight: {
+                status: 'failed',
+                reason: 'execution_audit_failed',
+                checked_at: checkedAt,
+                summary: 'Local rollout action preflight passed, but started audit persistence failed.'
+            },
+            startedAt: null,
+            endedAt: input.now(),
+            terminalState: 'failed',
+            reason: 'execution_audit_failed',
+            summary: 'Local rollout action was not launched because started audit persistence failed.',
+            command: preflight.command,
+            exitCode: null,
+            stdout: null,
+            stderr: null
+        });
+        return {
+            records: [failedAttempt],
+            terminalAttempt: failedAttempt,
+            appendTerminalAttempt: false
+        };
+    }
+    const result = await input.runCommand({
+        command: command.command,
+        args: command.args,
+        cwd: command.cwd,
+        timeoutMs: command.timeout_ms
+    });
+    const endedAt = input.now();
+    const terminalAttempt = buildAttempt({
+        pendingAction: input.pendingAction,
+        actionId: input.actionId,
+        preflight: {
+            status: 'passed',
+            reason: null,
+            checked_at: checkedAt,
+            summary: 'Local rollout action preflight passed.'
+        },
+        startedAt,
+        endedAt,
+        terminalState: result.ok ? 'succeeded' : 'failed',
+        reason: result.ok ? null : 'command_failed',
+        summary: result.ok
+            ? `Executed local rollout action ${input.actionId}.`
+            : `Local rollout action ${input.actionId} failed.`,
+        command: preflight.command,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr
+    });
+    return {
+        records: [startedAttempt, terminalAttempt],
+        terminalAttempt,
+        appendTerminalAttempt: true
+    };
+}
+async function preflightLocalRolloutAction(input) {
+    const action = input.action;
+    if (!action) {
+        return preflightSkip('undeclared_action', `Local rollout action ${input.actionId} is not declared.`);
+    }
+    if (!action.enabled) {
+        return preflightSkip('missing_config', `Local rollout action ${action.id} is disabled.`);
+    }
+    if (action.deploy_class && !action.deploy_opt_in) {
+        return preflightSkip('deploy_class_not_opted_in', `Deploy-class local rollout action ${action.id} is not explicitly opted in.`);
+    }
+    if (action.invalid_supported_platforms.length > 0) {
+        return preflightSkip('unsupported_host', `Local rollout action ${action.id} has unsupported platform entries: ${action.invalid_supported_platforms.join(', ')}.`);
+    }
+    if (action.supported_platforms.length > 0 &&
+        !action.supported_platforms.includes(input.platform)) {
+        return preflightSkip('unsupported_host', `Local rollout action ${action.id} does not support host platform ${input.platform}.`);
+    }
+    if (action.requires_issue_identifier && !input.pendingAction.issue_identifier) {
+        return preflightSkip('ambiguous_target', `Local rollout action ${action.id} requires an issue identifier.`);
+    }
+    if (action.require_clean_repo) {
+        const statusResult = await input.runCommand({
+            command: 'git',
+            args: ['-C', input.repoRoot, 'status', '--porcelain'],
+            cwd: input.repoRoot,
+            timeoutMs: DEFAULT_LOCAL_ROLLOUT_EXECUTION_TIMEOUT_MS
+        });
+        if (!statusResult.ok) {
+            return preflightSkip('command_failed', normalizeCommandText(statusResult.stderr) ||
+                `Local rollout action ${action.id} could not verify repository cleanliness.`);
+        }
+        if (normalizeCommandText(statusResult.stdout)) {
+            return preflightSkip('dirty_repo', `Local rollout action ${action.id} requires a clean repository.`);
+        }
+    }
+    if (action.required_branch) {
+        const branchResult = await input.runCommand({
+            command: 'git',
+            args: ['-C', input.repoRoot, 'branch', '--show-current'],
+            cwd: input.repoRoot,
+            timeoutMs: DEFAULT_LOCAL_ROLLOUT_EXECUTION_TIMEOUT_MS
+        });
+        if (!branchResult.ok) {
+            return preflightSkip('command_failed', normalizeCommandText(branchResult.stderr) ||
+                `Local rollout action ${action.id} could not verify the current branch.`);
+        }
+        const currentBranch = normalizeCommandText(branchResult.stdout);
+        if (currentBranch !== action.required_branch) {
+            return preflightSkip('wrong_branch', `Local rollout action ${action.id} requires branch ${action.required_branch}; current branch is ${currentBranch || 'detached'}.`);
+        }
+    }
+    const command = await resolveActionCommand({
+        action,
+        repoRoot: input.repoRoot,
+        platform: input.platform,
+        fileExists: input.fileExists
+    });
+    if (!command) {
+        return preflightSkip('missing_binary', `Local rollout action ${action.id} could not resolve its runner binary.`);
+    }
+    return {
+        status: 'passed',
+        reason: null,
+        summary: 'Local rollout action preflight passed.',
+        command
+    };
+}
+function preflightSkip(reason, summary) {
+    return {
+        status: reason === 'command_failed' || reason === 'lifecycle_record_failed' ? 'failed' : 'skipped',
+        reason,
+        summary,
+        command: null
+    };
+}
+async function resolveActionCommand(input) {
+    if (input.action.runner === 'codex_orchestrator') {
+        const cliPath = join(input.repoRoot, 'bin', 'codex-orchestrator.js');
+        if (!(await input.fileExists(cliPath))) {
+            return null;
+        }
+        return {
+            runner: 'codex_orchestrator',
+            command: process.execPath,
+            args: [cliPath, ...input.action.args],
+            cwd: input.repoRoot,
+            timeout_ms: input.action.timeout_ms
+        };
+    }
+    if (input.action.runner === 'npm_script') {
+        if (!input.action.script) {
+            return null;
+        }
+        const packageJsonPath = join(input.repoRoot, 'package.json');
+        if (!(await input.fileExists(packageJsonPath))) {
+            return null;
+        }
+        return {
+            runner: 'npm_script',
+            command: input.platform === 'win32' ? 'npm.cmd' : 'npm',
+            args: [
+                'run',
+                input.action.script,
+                ...(input.action.args.length > 0 ? ['--', ...input.action.args] : [])
+            ],
+            cwd: input.repoRoot,
+            timeout_ms: input.action.timeout_ms
+        };
+    }
+    return null;
+}
+function buildSyntheticAttempt(input) {
+    const at = input.now();
+    return buildAttempt({
+        pendingAction: input.pendingAction,
+        actionId: input.actionId,
+        preflight: {
+            status: 'failed',
+            reason: input.reason,
+            checked_at: at,
+            summary: input.summary
+        },
+        startedAt: null,
+        endedAt: at,
+        terminalState: input.state,
+        reason: input.reason,
+        summary: input.summary,
+        command: null,
+        exitCode: null,
+        stdout: null,
+        stderr: null
+    });
+}
+function buildAttempt(input) {
+    return {
+        record_kind: input.recordKind ?? 'terminal',
+        action_instance_id: input.pendingAction.action_instance_id,
+        action_id: input.actionId,
+        issue_id: input.pendingAction.issue_id,
+        issue_identifier: input.pendingAction.issue_identifier,
+        preflight: input.preflight,
+        started_at: input.startedAt,
+        ended_at: input.endedAt,
+        terminal_state: input.terminalState,
+        reason: input.reason,
+        summary: input.summary,
+        command: input.command ?? {
+            runner: null,
+            command: null,
+            args: [],
+            cwd: null,
+            timeout_ms: null
+        },
+        exit_code: input.exitCode,
+        stdout: input.stdout,
+        stderr: input.stderr
+    };
+}
+function selectPriorExecutionAttemptsForReuse(candidates, selected) {
+    if (selected.record_kind !== 'terminal' || selected.reason !== 'execution_audit_failed') {
+        return [cloneLocalRolloutExecutionAttempt(selected)];
+    }
+    const started = candidates
+        .filter((candidate) => candidate.record_kind === 'started')
+        .reduce((current, candidate) => current
+        ? selectPriorExecutionAttemptForProjection(current, candidate)
+        : candidate, null);
+    return [
+        ...(started ? [cloneLocalRolloutExecutionAttempt(started)] : []),
+        cloneLocalRolloutExecutionAttempt(selected)
+    ];
+}
+function selectPriorExecutionAttempt(existing, candidate) {
+    if (!existing) {
+        return candidate;
+    }
+    const recency = compareExecutionAttemptRecency(candidate, existing);
+    if (recency > 0 && candidate.record_kind === 'started') {
+        return candidate;
+    }
+    if (recency < 0 && existing.record_kind === 'started') {
+        return existing;
+    }
+    if (candidate.reason === 'lifecycle_record_failed' &&
+        isSucceededTerminalAttempt(existing)) {
+        return existing;
+    }
+    if (existing.reason === 'lifecycle_record_failed' &&
+        isSucceededTerminalAttempt(candidate)) {
+        return candidate;
+    }
+    if (recency > 0) {
+        return candidate;
+    }
+    if (recency < 0) {
+        return existing;
+    }
+    if (candidate.record_kind === 'terminal') {
+        return candidate;
+    }
+    if (existing.record_kind === 'terminal') {
+        return existing;
+    }
+    return candidate;
+}
+function selectPriorExecutionAttemptForProjection(existing, candidate) {
+    if (!existing) {
+        return candidate;
+    }
+    const recency = compareExecutionAttemptRecency(candidate, existing);
+    if (recency > 0) {
+        return candidate;
+    }
+    if (recency < 0) {
+        return existing;
+    }
+    if (candidate.record_kind === 'terminal') {
+        return candidate;
+    }
+    if (existing.record_kind === 'terminal') {
+        return existing;
+    }
+    return candidate;
+}
+function shouldReusePriorExecutionAttempt(attempt, candidates) {
+    if (attempt.record_kind === 'started') {
+        return true;
+    }
+    if (attempt.reason === 'execution_audit_failed') {
+        return candidates.some((candidate) => candidate.record_kind === 'started');
+    }
+    return attempt.terminal_state !== 'skipped';
+}
+function isSucceededTerminalAttempt(attempt) {
+    return attempt.record_kind === 'terminal' && attempt.terminal_state === 'succeeded';
+}
+function compareExecutionAttemptRecency(left, right) {
+    const leftTime = executionAttemptRecordedAtMs(left);
+    const rightTime = executionAttemptRecordedAtMs(right);
+    if (leftTime !== null && rightTime !== null && leftTime !== rightTime) {
+        return leftTime > rightTime ? 1 : -1;
+    }
+    if (leftTime !== null && rightTime === null) {
+        return 1;
+    }
+    if (leftTime === null && rightTime !== null) {
+        return -1;
+    }
+    return 0;
+}
+function executionAttemptRecordedAtMs(attempt) {
+    return parseExecutionAttemptTimestamp(attempt.ended_at || attempt.started_at || attempt.preflight.checked_at);
+}
+function parseExecutionAttemptTimestamp(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+async function runLocalRolloutCommand(input) {
+    try {
+        const { stdout, stderr } = await execFileAsync(input.command, input.args, {
+            cwd: input.cwd,
+            timeout: input.timeoutMs,
+            maxBuffer: 10 * 1024 * 1024,
+            shell: shouldUseShellForLocalRolloutCommand(input.command)
+        });
+        return { ok: true, exitCode: 0, stdout, stderr };
+    }
+    catch (error) {
+        const execError = error;
+        return {
+            ok: false,
+            exitCode: typeof execError.code === 'number' ? execError.code : null,
+            stdout: execError.stdout ?? '',
+            stderr: execError.stderr ?? execError.message
+        };
+    }
+}
+export function shouldUseShellForLocalRolloutCommand(command, platform = process.platform) {
+    return platform === 'win32' && /\.(?:cmd|bat)$/i.test(command);
+}
+function executionAttemptKey(attempt) {
+    return `${attempt.action_instance_id}\u0000${attempt.action_id}`;
+}
+async function defaultFileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeCommandText(value) {
+    return (value ?? '').trim();
+}
+async function writeExecutionStore(executionPath, store) {
+    await mkdir(dirname(executionPath), { recursive: true });
+    const tempPath = `${executionPath}.${process.pid}.${Date.now()}.${Math.random()
+        .toString(16)
+        .slice(2)}.tmp`;
+    try {
+        await writeFile(tempPath, `${JSON.stringify(store, null, 2)}\n`, 'utf8');
+        await rename(tempPath, executionPath);
+    }
+    catch (error) {
+        await rm(tempPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+async function withExecutionWriteLock(executionPath, body) {
+    const lockPath = `${executionPath}.lock`;
+    const lock = await acquireLockWithRetry({
+        taskId: 'provider-operator-autopilot-local-rollout-execution',
+        lockPath,
+        retry: LOCAL_ROLLOUT_EXECUTION_LOCK_RETRY,
+        ensureDirectory: async () => {
+            await mkdir(dirname(lockPath), { recursive: true });
+        },
+        createError: (_taskId, attempts) => new Error(`Timed out waiting for local rollout execution store lock after ${attempts} attempts.`)
+    });
+    try {
+        return await body();
+    }
+    finally {
+        await lock.release();
+    }
+}
+function parseExecutionStore(value) {
+    const record = asRecord(value);
+    if (!record || record.version !== 1 || !Array.isArray(record.records)) {
+        throw new Error('Operator autopilot local rollout execution store is malformed.');
+    }
+    const records = record.records.map(parseExecutionAttemptRecord);
+    if (records.some((entry) => entry === null)) {
+        throw new Error('Operator autopilot local rollout execution store contains malformed records.');
+    }
+    return {
+        version: 1,
+        records: records.map((entry) => cloneLocalRolloutExecutionAttempt(entry))
+    };
+}
+function parseExecutionAttemptRecord(value) {
+    const record = asRecord(value);
+    const preflight = asRecord(record?.preflight);
+    const command = asRecord(record?.command);
+    if (!record || !preflight || !command) {
+        return null;
+    }
+    const actionInstanceId = readNonEmptyString(record, 'action_instance_id');
+    const actionId = readNonEmptyString(record, 'action_id');
+    const issueId = readNonEmptyString(record, 'issue_id');
+    const checkedAt = readNonEmptyString(preflight, 'checked_at');
+    const endedAt = readNonEmptyString(record, 'ended_at');
+    const terminalState = normalizeTerminalState(record.terminal_state);
+    const preflightStatus = normalizePreflightStatus(preflight.status);
+    const preflightReason = normalizePreflightReason(preflight.reason);
+    const reason = normalizePreflightReason(record.reason);
+    if (!actionInstanceId || !actionId || !issueId || !checkedAt || !endedAt || !terminalState || !preflightStatus) {
+        return null;
+    }
+    return {
+        record_kind: normalizeExecutionRecordKind(record.record_kind),
+        action_instance_id: actionInstanceId,
+        action_id: actionId,
+        issue_id: issueId,
+        issue_identifier: readOptionalString(record, 'issue_identifier'),
+        preflight: {
+            status: preflightStatus,
+            reason: preflightReason,
+            checked_at: checkedAt,
+            summary: readNonEmptyString(preflight, 'summary') ?? ''
+        },
+        started_at: readOptionalString(record, 'started_at'),
+        ended_at: endedAt,
+        terminal_state: terminalState,
+        reason,
+        summary: readNonEmptyString(record, 'summary') ?? '',
+        command: {
+            runner: normalizeRunnerKind(command.runner),
+            command: readOptionalString(command, 'command'),
+            args: readStringArray(command, 'args') ?? [],
+            cwd: readOptionalString(command, 'cwd'),
+            timeout_ms: readInteger(command, 'timeout_ms')
+        },
+        exit_code: readInteger(record, 'exit_code'),
+        stdout: readRawOptionalString(record, 'stdout'),
+        stderr: readRawOptionalString(record, 'stderr')
+    };
+}
+function normalizeRunnerKind(value) {
+    return value === 'codex_orchestrator' || value === 'npm_script' ? value : null;
+}
+function normalizeTerminalState(value) {
+    return value === 'succeeded' || value === 'skipped' || value === 'failed'
+        ? value
+        : null;
+}
+function normalizeExecutionRecordKind(value) {
+    return value === 'started' || value === 'terminal' ? value : 'terminal';
+}
+function normalizePreflightStatus(value) {
+    return value === 'passed' || value === 'skipped' || value === 'failed' ? value : null;
+}
+function normalizePreflightReason(value) {
+    return value === 'missing_config' ||
+        value === 'undeclared_action' ||
+        value === 'dirty_repo' ||
+        value === 'wrong_branch' ||
+        value === 'missing_binary' ||
+        value === 'unsupported_host' ||
+        value === 'ambiguous_target' ||
+        value === 'deploy_class_not_opted_in' ||
+        value === 'execution_audit_failed' ||
+        value === 'execution_interrupted' ||
+        value === 'command_failed' ||
+        value === 'lifecycle_record_failed'
+        ? value
+        : null;
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : null;
+}
+function readBoolean(record, ...keys) {
+    for (const key of keys) {
+        const value = record?.[key];
+        if (typeof value === 'boolean') {
+            return value;
+        }
+    }
+    return null;
+}
+function readNonEmptyString(record, ...keys) {
+    for (const key of keys) {
+        const value = record?.[key];
+        if (typeof value === 'string' && value.trim()) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+function readOptionalString(record, ...keys) {
+    for (const key of keys) {
+        const value = record?.[key];
+        if (typeof value === 'string' && value.trim()) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+function readRawOptionalString(record, ...keys) {
+    for (const key of keys) {
+        const value = record?.[key];
+        if (typeof value === 'string') {
+            return value;
+        }
+    }
+    return null;
+}
+function readStringArray(record, ...keys) {
+    for (const key of keys) {
+        const value = record?.[key];
+        if (!Array.isArray(value)) {
+            continue;
+        }
+        const strings = value
+            .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
+            .filter((entry) => entry.length > 0);
+        return strings;
+    }
+    return null;
+}
+function readPlatformArray(record, ...keys) {
+    for (const key of keys) {
+        if (!record || !(key in record)) {
+            continue;
+        }
+        const values = record[key];
+        if (!Array.isArray(values)) {
+            return { supported: [], invalid: [formatInvalidPlatformEntry(values)] };
+        }
+        const supported = [];
+        const invalid = [];
+        for (const value of values) {
+            if (typeof value !== 'string') {
+                invalid.push(formatInvalidPlatformEntry(value));
+                continue;
+            }
+            const platform = value.trim();
+            if (!platform) {
+                invalid.push(formatInvalidPlatformEntry(value));
+            }
+            else if (SUPPORTED_NODE_PLATFORMS.has(platform)) {
+                supported.push(platform);
+            }
+            else {
+                invalid.push(platform);
+            }
+        }
+        return { supported, invalid };
+    }
+    return null;
+}
+function formatInvalidPlatformEntry(value) {
+    if (typeof value === 'string') {
+        return value.trim() || '<blank>';
+    }
+    if (value === null) {
+        return 'null';
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        typeof value === 'bigint') {
+        return String(value);
+    }
+    return '<non-string>';
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+function readInteger(record, ...keys) {
+    for (const key of keys) {
+        const value = record?.[key];
+        if (typeof value === 'number' && Number.isInteger(value)) {
+            return value;
+        }
+    }
+    return null;
+}
+function readPositiveInteger(record, ...keys) {
+    const value = readInteger(record, ...keys);
+    return value !== null && value > 0 ? value : null;
+}