vgxness 1.20.4 → 1.20.6

package/dist/runs/run-service.js

@@ -1,1439 +1 @@
-import { createHash } from 'node:crypto';
-import { evaluatePermission } from '../permissions/policy-evaluator.js';
-import { isRiskyPermissionCategory } from '../permissions/schema.js';
-import { normalizeSddPhaseInput } from '../sdd/schema.js';
-import { planExecutionIsolation, recommendWorkspaceStrategyForExecution } from './execution-planning.js';
-import { evaluateOperationRetry as evaluateOperationRetryPolicy } from './operation-retry.js';
-import { AllowlistedApplyProgressCommandExecutor } from '../workflows/command-allowlist-adapter.js';
-import { RunRepository, } from './repositories/runs.js';
-import { buildRunInsights, buildRunOperatorResumePlan } from './run-insights.js';
-import { buildResumeAfterApprovalResult } from './resume-after-approval-result.js';
-import { grantEvaluationPayload, TaskScopedCommandGrantService } from './task-scoped-command-grant-service.js';
-const preflightSafety = {
-    operationExecuted: false,
-    executorInvoked: false,
-    executesProvider: false,
-    writesProviderConfig: false,
-    createsSandbox: false,
-    createsWorktree: false,
-};
-const resumeGateSafety = {
-    readOnly: true,
-    preflightExecuted: false,
-    retryAdmitted: false,
-    executorInvoked: false,
-    operationExecuted: false,
-    writesProviderConfig: false,
-    createsSandbox: false,
-    createsWorktree: false,
-};
-export class RunService {
-    runs;
-    taskScopedCommandGrants;
-    constructor(database) {
-        this.runs = new RunRepository(database);
-        this.taskScopedCommandGrants = new TaskScopedCommandGrantService(database);
-    }
-    createRun(input) {
-        return this.runs.create({ ...input, phase: canonicalRunPhase(input.workflow, input.phase) ?? input.phase });
-    }
-    getRun(id) {
-        return this.runs.getDetails(id);
-    }
-    getRunInsights(id) {
-        const details = this.runs.getDetails(id);
-        return details.ok ? { ok: true, value: buildRunInsights(details.value) } : details;
-    }
-    getRunOperatorResumePlan(id) {
-        const details = this.runs.getDetails(id);
-        return details.ok ? { ok: true, value: buildRunOperatorResumePlan(details.value) } : details;
-    }
-    listRuns(filters = {}) {
-        return this.runs.list(filters);
-    }
-    getSddOperationalEvidence(input) {
-        const runs = this.runs.list({ project: input.project, limit: input.limit ?? 50 });
-        if (!runs.ok)
-            return runs;
-        const evidenceByPhase = {};
-        for (const run of runs.value) {
-            if (!isSddWorkflow(run.workflow))
-                continue;
-            const phase = normalizeSddPhaseInput(run.phase);
-            if (phase === undefined || evidenceByPhase[phase] !== undefined)
-                continue;
-            const details = this.runs.getDetails(run.id);
-            if (!details.ok)
-                return details;
-            const matchingCheckpoints = details.value.checkpoints.filter((checkpoint) => checkpointHasChangeId(checkpoint.state, input.change));
-            if (matchingCheckpoints.length === 0)
-                continue;
-            const latestMatchingCheckpoint = matchingCheckpoints.at(-1);
-            evidenceByPhase[phase] = {
-                latestRun: {
-                    id: details.value.id,
-                    status: details.value.status,
-                    workflow: details.value.workflow,
-                    phase: details.value.phase,
-                    ...(details.value.outcome === undefined ? {} : { outcome: details.value.outcome }),
-                    createdAt: details.value.createdAt,
-                    updatedAt: details.value.updatedAt,
-                    ...(details.value.completedAt === undefined ? {} : { completedAt: details.value.completedAt }),
-                },
-                approvalCounts: countByStatus(details.value.approvals.map((approval) => approval.status)),
-                attemptCounts: countByStatus(details.value.operationAttempts.map((attempt) => attempt.status)),
-                ...(latestMatchingCheckpoint === undefined
-                    ? {}
-                    : {
-                        latestCheckpoint: {
-                            id: latestMatchingCheckpoint.id,
-                            label: latestMatchingCheckpoint.label,
-                            sequence: latestMatchingCheckpoint.sequence,
-                            createdAt: latestMatchingCheckpoint.createdAt,
-                        },
-                    }),
-            };
-        }
-        return { ok: true, value: evidenceByPhase };
-    }
-    listRecentInterruptedRuns(input) {
-        const runs = this.runs.list({ project: input.project, statuses: ['failed', 'blocked', 'needs-human'], limit: input.limit ?? 5 });
-        if (!runs.ok)
-            return runs;
-        const candidates = [];
-        for (const run of runs.value) {
-            const details = this.runs.getDetails(run.id);
-            if (!details.ok)
-                return details;
-            const latestCheckpoint = details.value.checkpoints.at(-1);
-            const userIntent = details.value.userIntent.trim();
-            candidates.push({
-                runId: details.value.id,
-                status: details.value.status,
-                workflow: details.value.workflow,
-                phase: details.value.phase,
-                ...(userIntent.length === 0 ? {} : { userIntent }),
-                ...(latestCheckpoint === undefined ? {} : { latestCheckpointLabel: latestCheckpoint.label }),
-            });
-        }
-        return { ok: true, value: candidates };
-    }
-    findRelatedInterruptedSddRun(input) {
-        const runs = this.runs.list({ project: input.project, statuses: ['failed', 'blocked', 'needs-human'], limit: input.limit ?? 25 });
-        if (!runs.ok)
-            return runs;
-        for (const run of runs.value) {
-            const details = this.runs.getDetails(run.id);
-            if (!details.ok)
-                return details;
-            const hasMatchingCheckpoint = details.value.checkpoints.some((checkpoint) => checkpointHasChangeId(checkpoint.state, input.change));
-            if (!hasMatchingCheckpoint)
-                continue;
-            const latestCheckpoint = details.value.checkpoints.at(-1);
-            return {
-                ok: true,
-                value: {
-                    runId: details.value.id,
-                    status: details.value.status,
-                    workflow: details.value.workflow,
-                    phase: details.value.phase,
-                    ...(latestCheckpoint === undefined ? {} : { latestCheckpointLabel: latestCheckpoint.label }),
-                },
-            };
-        }
-        return { ok: true, value: undefined };
-    }
-    appendEvent(input) {
-        return this.runs.appendEvent(input);
-    }
-    appendEvidence(input) {
-        return this.runs.appendEvent({ ...input, kind: 'evidence' });
-    }
-    appendCheckpoint(input) {
-        return this.runs.appendCheckpoint(input);
-    }
-    updateFinalStatus(input) {
-        return this.runs.updateFinalStatus(input);
-    }
-    listApprovals(runId) {
-        return this.runs.listApprovals(runId);
-    }
-    listOperationAttempts(runId) {
-        return this.runs.listOperationAttempts(runId);
-    }
-    getApproval(id) {
-        return this.runs.getApproval(id);
-    }
-    resolveApproval(input) {
-        return this.runs.resolveApproval(input);
-    }
-    taskScopedCommandGrantService() {
-        return this.taskScopedCommandGrants;
-    }
-    abandonReservedOperationAttempt(input) {
-        return this.runs.abandonOperationAttempt(input);
-    }
-    evaluateOperationRetry(input) {
-        const approval = this.runs.getApproval(input.approvalId);
-        if (!approval.ok)
-            return { ok: false, error: approval.error };
-        const details = this.runs.getDetails(approval.value.runId);
-        if (!details.ok)
-            return { ok: false, error: details.error };
-        const attempts = details.value.operationAttempts.filter((attempt) => attempt.approvalId === input.approvalId);
-        return {
-            ok: true,
-            value: evaluateOperationRetryPolicy(input.policy === undefined ? { attempts } : { attempts, policy: input.policy }),
-        };
-    }
-    getRunResumeOrchestrationPlan(input) {
-        const approval = this.runs.getApproval(input.approvalId);
-        if (!approval.ok)
-            return approval;
-        const details = this.runs.getDetails(approval.value.runId);
-        if (!details.ok)
-            return details;
-        const blockers = [];
-        if (approval.value.status !== 'approved') {
-            blockers.push({
-                code: 'approval-not-approved',
-                message: `Approval must be approved before manual continuation guidance is available: ${approval.value.status}`,
-                relatedId: approval.value.id,
-            });
-        }
-        const permissionEvent = details.value.events.find((event) => event.id === approval.value.decisionEventId);
-        if (permissionEvent === undefined || !isAskPermissionEvent(permissionEvent)) {
-            blockers.push({
-                code: 'missing-permission-event',
-                message: 'Approval permission-decision event is missing or is not an ask decision',
-                relatedId: approval.value.decisionEventId,
-            });
-        }
-        const pendingExecutionEvent = details.value.events.find((event) => isPendingExecutionEventForApproval(event, approval.value.id));
-        let operation;
-        if (pendingExecutionEvent === undefined) {
-            blockers.push({
-                code: 'missing-pending-operation',
-                message: 'Approval has no pending operation-execution event to reconstruct',
-                relatedId: approval.value.id,
-            });
-        }
-        else {
-            operation = operationFromPendingExecution(pendingExecutionEvent.payload);
-            if (operation === undefined) {
-                blockers.push({
-                    code: 'operation-metadata-incomplete',
-                    message: 'Pending operation metadata is incomplete and cannot be planned',
-                    relatedId: pendingExecutionEvent.id,
-                });
-            }
-        }
-        const retryDecision = operation === undefined
-            ? null
-            : evaluateOperationRetryPolicy(input.policy === undefined
-                ? { attempts: details.value.operationAttempts.filter((attempt) => attempt.approvalId === approval.value.id) }
-                : { attempts: details.value.operationAttempts.filter((attempt) => attempt.approvalId === approval.value.id), policy: input.policy });
-        if (retryDecision !== null && !retryDecision.allowed) {
-            const relatedId = retryDecision.latestAttempt?.id ?? retryDecision.activeAttempt?.id;
-            blockers.push({
-                code: 'retry-blocked',
-                message: retryDecision.reason,
-                ...(relatedId === undefined ? {} : { relatedId }),
-            });
-        }
-        return {
-            ok: true,
-            value: {
-                kind: 'run-resume-orchestration-plan',
-                version: 1,
-                run: {
-                    id: details.value.id,
-                    project: details.value.project,
-                    status: details.value.status,
-                    workflow: details.value.workflow,
-                    phase: details.value.phase,
-                },
-                approval: {
-                    id: approval.value.id,
-                    runId: approval.value.runId,
-                    status: approval.value.status,
-                    decisionEventId: approval.value.decisionEventId,
-                },
-                operation: operation === undefined ? null : summarizeOperation(operation),
-                retryDecision,
-                blockers,
-                nextAction: resumeGateNextAction(approval.value, details.value, blockers),
-                manualNextCommands: resumeGateManualNextCommands(approval.value, details.value, operation),
-                safety: resumeGateSafety,
-            },
-        };
-    }
-    admitOperationRetryAttempt(input) {
-        const approval = this.runs.getApproval(input.approvalId);
-        if (!approval.ok)
-            return approval;
-        if (approval.value.status !== 'approved')
-            return validationFailure(`Only approved approvals can admit retry attempts: ${approval.value.status}`);
-        const details = this.runs.getDetails(approval.value.runId);
-        if (!details.ok)
-            return details;
-        const permissionEvent = details.value.events.find((event) => event.id === approval.value.decisionEventId);
-        if (permissionEvent === undefined)
-            return validationFailure('Approval permission-decision event is missing');
-        if (!isAskPermissionEvent(permissionEvent))
-            return validationFailure('Approval is not linked to an ask permission decision');
-        const pendingExecutionEvent = details.value.events.find((event) => isPendingExecutionEventForApproval(event, approval.value.id));
-        if (pendingExecutionEvent === undefined)
-            return validationFailure('Approved approval has no retryable pending operation event');
-        const operation = operationFromPendingExecution(pendingExecutionEvent.payload);
-        if (operation === undefined)
-            return validationFailure('Pending operation metadata is incomplete and cannot be retried');
-        const replayGuard = replayGuardForApprovedOperation(approval.value, permissionEvent, pendingExecutionEvent, operation);
-        const attempts = details.value.operationAttempts.filter((attempt) => attempt.approvalId === approval.value.id);
-        const retryDecision = evaluateOperationRetryPolicy(input.policy === undefined ? { attempts } : { attempts, policy: input.policy });
-        if (!retryDecision.allowed || retryDecision.reasonCode !== 'status_allowed_by_policy')
-            return validationFailure(retryDecision.reason);
-        const reserved = this.runs.reserveOperationAttempt({
-            runId: approval.value.runId,
-            approvalId: approval.value.id,
-            decisionEventId: permissionEvent.id,
-            pendingExecutionEventId: pendingExecutionEvent.id,
-            category: operation.category,
-            operation: operation.operation,
-            operationMetadata: operationMetadataWithReplayGuard(operation, replayGuard),
-            executorName: input.executorName ?? 'retry-admission',
-        });
-        if (!reserved.ok)
-            return reserved;
-        const admissionEvent = this.runs.appendEvent({
-            runId: approval.value.runId,
-            kind: 'operation-execution',
-            title: `Retry attempt admitted: ${operation.category} ${operation.operation}`,
-            payload: executionPayload(operation, reserved.value.executorName, 'pending-approval', {
-                admissionStatus: 'reserved',
-                retryAdmission: true,
-                attemptId: reserved.value.id,
-                attemptSequence: reserved.value.attemptSequence,
-                approvalId: approval.value.id,
-                decisionEventId: permissionEvent.id,
-                originalPendingExecutionEventId: pendingExecutionEvent.id,
-                retryPolicy: retryDecision.policy,
-                retryReasonCode: retryDecision.reasonCode,
-                retryReason: retryDecision.reason,
-                evaluatedAttemptCount: retryDecision.evaluatedAttemptCount,
-                retryableStatuses: [...retryDecision.retryableStatuses],
-                replayGuard,
-                operationFingerprint: replayGuard.operationFingerprint,
-                executorInvoked: false,
-                operationExecuted: false,
-            }),
-            relatedType: 'operation-attempt',
-            relatedId: reserved.value.id,
-        });
-        if (!admissionEvent.ok)
-            return { ok: false, error: admissionEvent.error };
-        return {
-            ok: true,
-            value: { approval: approval.value, retryDecision, permissionEvent, pendingExecutionEvent, attempt: reserved.value, admissionEvent: admissionEvent.value },
-        };
-    }
-    planOperationExecution(input) {
-        const resolved = this.buildPermissionContextForRun(input);
-        if (!resolved.ok)
-            return resolved;
-        const permission = this.evaluatePermissionForRun(resolved.value);
-        if (!permission.ok)
-            return permission;
-        const plan = planExecutionIsolation({
-            operation: resolved.value,
-            decision: permission.value.decision,
-            ...(resolved.value.gitBoundaryInspector === undefined ? {} : { gitBoundaryInspector: resolved.value.gitBoundaryInspector }),
-        });
-        const workspaceStrategy = recommendWorkspaceStrategyForExecution({
-            operation: resolved.value,
-            decision: permission.value.decision,
-            ...(resolved.value.gitBoundaryInspector === undefined ? {} : { gitBoundaryInspector: resolved.value.gitBoundaryInspector }),
-        });
-        const sandboxDecision = sandboxDecisionSummary(plan.sandbox);
-        const planEvent = this.runs.appendEvent({
-            runId: resolved.value.runId,
-            kind: 'execution-plan',
-            title: `Execution plan: ${resolved.value.category} ${resolved.value.operation}`,
-            payload: {
-                runId: resolved.value.runId,
-                requestedOperation: operationMetadata(resolved.value),
-                decisionEventId: permission.value.event.id,
-                approvalId: permission.value.approval?.id ?? null,
-                plan: plan,
-                workspaceStrategy: workspaceStrategy,
-                ...(sandboxDecision === undefined ? {} : { sandboxDecision: sandboxDecision }),
-                operationExecuted: false,
-                executorInvoked: false,
-                executesProvider: false,
-                writesProviderConfig: false,
-                createsSandbox: false,
-                createsWorktree: false,
-                timestamp: new Date().toISOString(),
-            },
-            relatedType: 'operation',
-            relatedId: resolved.value.operation,
-        });
-        if (!planEvent.ok)
-            return { ok: false, error: planEvent.error };
-        return { ok: true, value: { ...permission.value, plan, workspaceStrategy, planEvent: planEvent.value } };
-    }
-    preflightOperation(input) {
-        const resolved = this.buildPermissionContextForRun(input);
-        if (!resolved.ok)
-            return resolved;
-        const metadataValidation = this.validateVgxManagedPreflightMetadata(resolved.value);
-        if (!metadataValidation.ok)
-            return metadataValidation;
-        const planned = this.planOperationExecution(resolved.value);
-        if (!planned.ok)
-            return planned;
-        const { decision, event, approval, plan, workspaceStrategy, planEvent } = planned.value;
-        const audit = { permissionEventId: event.id, planEventId: planEvent.id };
-        if (approval !== undefined)
-            audit.approvalId = approval.id;
-        const sandbox = plan.sandbox;
-        const sandboxRejected = sandbox?.decision === 'rejected';
-        const sandboxReason = sandboxRejected ? [{ code: sandbox.reason ?? 'sandbox_boundary', message: sandbox.audit.validationSummary }] : [];
-        const outcome = sandboxRejected ? 'blocked' : preflightOutcome(decision);
-        this.appendPreflightAuditEvent(resolved.value, outcome, {
-            permissionEventId: event.id,
-            planEventId: planEvent.id,
-            ...(approval === undefined ? {} : { approvalId: approval.id }),
-        });
-        return {
-            ok: true,
-            value: {
-                outcome,
-                decision,
-                reasons: [...sandboxReason, { code: decision.reason, message: decision.message }],
-                permissionEvent: event,
-                ...(approval === undefined ? {} : { approval }),
-                plan,
-                workspaceStrategy,
-                planEvent,
-                audit,
-                eligibleForFutureExecution: plan.executable && !sandboxRejected,
-                safety: preflightSafety,
-            },
-        };
-    }
-    resumeApprovedOperation(input) {
-        const approval = this.runs.getApproval(input.approvalId);
-        if (!approval.ok)
-            return approval;
-        if (approval.value.status !== 'approved')
-            return validationFailure(`Only approved approvals can be resumed: ${approval.value.status}`);
-        const details = this.runs.getDetails(approval.value.runId);
-        if (!details.ok)
-            return details;
-        const pendingExecutionEvent = details.value.events.find((event) => isPendingExecutionEventForApproval(event, approval.value.id));
-        if (pendingExecutionEvent === undefined)
-            return validationFailure('Approved approval has no resumable pending operation event');
-        const permissionEvent = permissionEventForPendingExecution(details.value, approval.value, pendingExecutionEvent);
-        if (permissionEvent === undefined)
-            return validationFailure('Approval permission-decision event is missing');
-        if (!isAskPermissionEvent(permissionEvent))
-            return validationFailure('Approval is not linked to an ask permission decision');
-        const operation = operationFromPendingExecution(pendingExecutionEvent.payload);
-        if (operation === undefined)
-            return validationFailure('Pending operation metadata is incomplete and cannot be resumed');
-        const replayGuard = replayGuardForApprovedOperation(approval.value, permissionEvent, pendingExecutionEvent, operation);
-        const replayValidation = validateReplayGuard(pendingExecutionEvent, replayGuard, input.expectedOperationFingerprint);
-        if (!replayValidation.ok)
-            return replayValidation;
-        const retry = this.evaluateOperationRetry({ approvalId: approval.value.id });
-        if (!retry.ok)
-            return retry;
-        if (!retry.value.allowed)
-            return validationFailure(retry.value.reason);
-        const reserved = this.runs.reserveOperationAttempt({
-            runId: approval.value.runId,
-            approvalId: approval.value.id,
-            decisionEventId: permissionEvent.id,
-            pendingExecutionEventId: pendingExecutionEvent.id,
-            category: operation.category,
-            operation: operation.operation,
-            operationMetadata: operationMetadataWithReplayGuard(operation, replayGuard),
-            executorName: input.executor.name,
-        });
-        if (!reserved.ok)
-            return reserved;
-        const executed = input.executor.execute({ runId: approval.value.runId, operation });
-        if (!executed.ok) {
-            const error = { code: executed.error.code, message: executed.error.message };
-            const result = buildResumeAfterApprovalResult({
-                runId: approval.value.runId,
-                approvalId: approval.value.id,
-                attemptId: reserved.value.id,
-                permissionEventId: permissionEvent.id,
-                pendingExecutionEventId: pendingExecutionEvent.id,
-                operationFingerprint: replayGuard.operationFingerprint,
-                executorName: input.executor.name,
-                operation,
-                status: 'failed',
-                error,
-            });
-            const attempt = this.runs.completeOperationAttempt({ attemptId: reserved.value.id, status: 'failed', output: result, error });
-            if (!attempt.ok)
-                return attempt;
-            const executionEvent = this.runs.appendEvent({
-                runId: approval.value.runId,
-                kind: 'operation-execution',
-                title: `Approved operation failed: ${operation.category} ${operation.operation}`,
-                payload: executionPayload(operation, input.executor.name, 'failed', {
-                    attemptId: attempt.value.id,
-                    decisionEventId: permissionEvent.id,
-                    approvalId: approval.value.id,
-                    originalPendingExecutionEventId: pendingExecutionEvent.id,
-                    originalDecision: 'ask',
-                    approvalStatus: 'approved',
-                    policyReevaluated: false,
-                    replayGuard,
-                    operationFingerprint: replayGuard.operationFingerprint,
-                    resumedFromApprovalId: approval.value.id,
-                    executorInvoked: true,
-                    result,
-                    error,
-                }),
-                relatedType: 'approval',
-                relatedId: approval.value.id,
-            });
-            if (!executionEvent.ok)
-                return { ok: false, error: executionEvent.error };
-            const linkedAttempt = this.runs.attachAttemptResultEvent(attempt.value.id, executionEvent.value.id);
-            const evidence = appendApplyProgressAllowlistEvidenceIfNeeded(this.runs, approval.value.id, permissionEvent, pendingExecutionEvent, linkedAttempt.ok ? linkedAttempt.value : attempt.value, executionEvent.value, replayGuard.operationFingerprint, input.executor.name, operation, result);
-            if (!evidence.ok)
-                return { ok: false, error: evidence.error };
-            return {
-                ok: true,
-                value: {
-                    approval: approval.value,
-                    permissionEvent,
-                    pendingExecutionEvent,
-                    attempt: linkedAttempt.ok ? linkedAttempt.value : attempt.value,
-                    executionEvent: executionEvent.value,
-                    status: 'failed',
-                    output: result,
-                    ...(evidence.value === undefined ? {} : evidence.value),
-                },
-            };
-        }
-        const output = executed.value.output;
-        const result = buildResumeAfterApprovalResult({
-            runId: approval.value.runId,
-            approvalId: approval.value.id,
-            attemptId: reserved.value.id,
-            permissionEventId: permissionEvent.id,
-            pendingExecutionEventId: pendingExecutionEvent.id,
-            operationFingerprint: replayGuard.operationFingerprint,
-            executorName: input.executor.name,
-            operation,
-            status: 'succeeded',
-            ...(output === undefined ? {} : { executorOutput: output }),
-        });
-        const attempt = this.runs.completeOperationAttempt({ attemptId: reserved.value.id, status: 'succeeded', output: result });
-        if (!attempt.ok)
-            return attempt;
-        const executionEvent = this.runs.appendEvent({
-            runId: approval.value.runId,
-            kind: 'operation-execution',
-            title: `Approved operation executed: ${operation.category} ${operation.operation}`,
-            payload: executionPayload(operation, input.executor.name, 'succeeded', {
-                attemptId: attempt.value.id,
-                decisionEventId: permissionEvent.id,
-                approvalId: approval.value.id,
-                originalPendingExecutionEventId: pendingExecutionEvent.id,
-                originalDecision: 'ask',
-                approvalStatus: 'approved',
-                policyReevaluated: false,
-                replayGuard,
-                operationFingerprint: replayGuard.operationFingerprint,
-                resumedFromApprovalId: approval.value.id,
-                executorInvoked: true,
-                result,
-            }),
-            relatedType: 'approval',
-            relatedId: approval.value.id,
-        });
-        if (!executionEvent.ok)
-            return { ok: false, error: executionEvent.error };
-        const linkedAttempt = this.runs.attachAttemptResultEvent(attempt.value.id, executionEvent.value.id);
-        const evidence = appendApplyProgressAllowlistEvidenceIfNeeded(this.runs, approval.value.id, permissionEvent, pendingExecutionEvent, linkedAttempt.ok ? linkedAttempt.value : attempt.value, executionEvent.value, replayGuard.operationFingerprint, input.executor.name, operation, result);
-        if (!evidence.ok)
-            return { ok: false, error: evidence.error };
-        return {
-            ok: true,
-            value: {
-                approval: approval.value,
-                permissionEvent,
-                pendingExecutionEvent,
-                attempt: linkedAttempt.ok ? linkedAttempt.value : attempt.value,
-                executionEvent: executionEvent.value,
-                status: 'succeeded',
-                output: result,
-                ...(evidence.value === undefined ? {} : evidence.value),
-            },
-        };
-    }
-    resumeApprovedAllowlistedApplyProgressCommand(input) {
-        return this.resumeApprovedOperation({
-            approvalId: input.approvalId,
-            executor: new AllowlistedApplyProgressCommandExecutor(input.executorOptions),
-            ...(input.expectedOperationFingerprint === undefined ? {} : { expectedOperationFingerprint: input.expectedOperationFingerprint }),
-        });
-    }
-    executeOperation(input) {
-        const permission = this.evaluatePermissionForRun({ runId: input.runId, ...input.operation, reusePendingApproval: true });
-        if (!permission.ok)
-            return permission;
-        const preflightGate = this.evaluateVgxManagedExecutionPreflightGate(input);
-        if (!preflightGate.ok)
-            return preflightGate;
-        if (preflightGate.value.blocked) {
-            const blockedDecision = {
-                ...permission.value.decision,
-                decision: 'deny',
-                reason: 'sdd_phase_policy',
-                message: preflightGate.value.message,
-                requiresPreflight: true,
-            };
-            this.appendPreflightGateAuditEvent(input.runId, input.operation, preflightGate.value.status, preflightGate.value.message);
-            const executionEvent = this.runs.appendEvent({
-                runId: input.runId,
-                kind: 'operation-execution',
-                title: `Operation blocked by preflight gate: ${input.operation.category} ${input.operation.operation}`,
-                payload: executionPayload(input.operation, input.executor.name, 'blocked', {
-                    decisionEventId: permission.value.event.id,
-                    decision: 'deny',
-                    reason: blockedDecision.reason,
-                    message: blockedDecision.message,
-                    preflightRequired: true,
-                    preflightStatus: preflightGate.value.status,
-                    executorInvoked: false,
-                    operationExecuted: false,
-                }),
-                relatedType: 'operation',
-                relatedId: input.operation.operation,
-            });
-            return executionEvent.ok
-                ? { ok: true, value: { decision: blockedDecision, permissionEvent: permission.value.event, executionEvent: executionEvent.value, status: 'blocked' } }
-                : { ok: false, error: executionEvent.error };
-        }
-        if (permission.value.decision.decision === 'deny') {
-            const executionEvent = this.runs.appendEvent({
-                runId: input.runId,
-                kind: 'operation-execution',
-                title: `Operation blocked: ${input.operation.category} ${input.operation.operation}`,
-                payload: executionPayload(input.operation, input.executor.name, 'blocked', {
-                    decisionEventId: permission.value.event.id,
-                    decision: 'deny',
-                    reason: permission.value.decision.reason,
-                    message: permission.value.decision.message,
-                    executorInvoked: false,
-                }),
-                relatedType: 'operation',
-                relatedId: input.operation.operation,
-            });
-            return executionEvent.ok
-                ? {
-                    ok: true,
-                    value: { decision: permission.value.decision, permissionEvent: permission.value.event, executionEvent: executionEvent.value, status: 'blocked' },
-                }
-                : { ok: false, error: executionEvent.error };
-        }
-        if (permission.value.decision.decision === 'ask') {
-            const replayGuard = permission.value.approval === undefined ? undefined : replayGuardForApprovedOperation(permission.value.approval, permission.value.event, undefined, input.operation);
-            const executionEvent = this.runs.appendEvent({
-                runId: input.runId,
-                kind: 'operation-execution',
-                title: `Operation pending approval: ${input.operation.category} ${input.operation.operation}`,
-                payload: executionPayload(input.operation, input.executor.name, 'pending-approval', {
-                    decisionEventId: permission.value.event.id,
-                    approvalId: permission.value.approval?.id ?? null,
-                    decision: 'ask',
-                    reason: permission.value.decision.reason,
-                    message: permission.value.decision.message,
-                    ...(replayGuard === undefined ? {} : { replayGuard, operationFingerprint: replayGuard.operationFingerprint }),
-                    executorInvoked: false,
-                    operationExecuted: false,
-                }),
-                relatedType: 'operation',
-                relatedId: input.operation.operation,
-            });
-            return executionEvent.ok
-                ? {
-                    ok: true,
-                    value: {
-                        decision: permission.value.decision,
-                        permissionEvent: permission.value.event,
-                        executionEvent: executionEvent.value,
-                        status: 'pending-approval',
-                        ...(permission.value.approval === undefined ? {} : { approval: permission.value.approval }),
-                    },
-                }
-                : { ok: false, error: executionEvent.error };
-        }
-        const executed = input.executor.execute({ runId: input.runId, operation: input.operation });
-        if (!executed.ok) {
-            const executionEvent = this.runs.appendEvent({
-                runId: input.runId,
-                kind: 'operation-execution',
-                title: `Operation failed: ${input.operation.category} ${input.operation.operation}`,
-                payload: executionPayload(input.operation, input.executor.name, 'failed', {
-                    decisionEventId: permission.value.event.id,
-                    decision: 'allow',
-                    executorInvoked: true,
-                    error: { code: executed.error.code, message: executed.error.message },
-                }),
-                relatedType: 'operation',
-                relatedId: input.operation.operation,
-            });
-            return executionEvent.ok
-                ? {
-                    ok: true,
-                    value: { decision: permission.value.decision, permissionEvent: permission.value.event, executionEvent: executionEvent.value, status: 'failed' },
-                }
-                : { ok: false, error: executionEvent.error };
-        }
-        const output = executed.value.output;
-        const executionEvent = this.runs.appendEvent({
-            runId: input.runId,
-            kind: 'operation-execution',
-            title: `Operation executed: ${input.operation.category} ${input.operation.operation}`,
-            payload: executionPayload(input.operation, input.executor.name, 'succeeded', {
-                decisionEventId: permission.value.event.id,
-                decision: 'allow',
-                executorInvoked: true,
-                output: output ?? null,
-            }),
-            relatedType: 'operation',
-            relatedId: input.operation.operation,
-        });
-        return executionEvent.ok
-            ? {
-                ok: true,
-                value: {
-                    decision: permission.value.decision,
-                    permissionEvent: permission.value.event,
-                    executionEvent: executionEvent.value,
-                    status: 'succeeded',
-                    ...(output === undefined ? {} : { output }),
-                },
-            }
-            : { ok: false, error: executionEvent.error };
-    }
-    evaluatePermissionForRun(input) {
-        const resolved = this.buildPermissionContextForRun(input);
-        if (!resolved.ok)
-            return resolved;
-        const inputWithRunContext = resolved.value;
-        const run = this.runs.getById(inputWithRunContext.runId);
-        if (!run.ok)
-            return { ok: false, error: run.error };
-        const contextConflict = workflowConflictDecision(inputWithRunContext, run.value.workflow);
-        const decision = contextConflict ?? evaluatePermission(inputWithRunContext);
-        const timestamp = new Date().toISOString();
-        const agent = inputWithRunContext.agent === undefined ? { id: run.value.selectedAgentId } : { id: inputWithRunContext.agent.id, name: inputWithRunContext.agent.name, mode: inputWithRunContext.agent.mode };
-        if (decision.decision === 'ask') {
-            const prior = this.findMatchingApproval(inputWithRunContext, agent, inputWithRunContext.reusePendingApproval === true);
-            if (!prior.ok)
-                return prior;
-            if (prior.value !== undefined) {
-                const reusedDecision = prior.value.approval.status === 'pending'
-                    ? decision
-                    : prior.value.approval.status === 'approved'
-                        ? { ...decision, decision: 'allow', message: `Previously approved approval ${prior.value.approval.id} authorizes this exact operation.` }
-                        : {
-                            ...decision,
-                            decision: 'deny',
-                            reason: 'default_policy',
-                            message: `Previously ${prior.value.approval.status} approval ${prior.value.approval.id} denies this exact operation.`,
-                        };
-                const event = this.runs.appendEvent({
-                    runId: inputWithRunContext.runId,
-                    kind: 'permission-decision',
-                    title: `Permission ${reusedDecision.decision}: ${inputWithRunContext.category} ${inputWithRunContext.operation}`,
-                    payload: {
-                        runId: inputWithRunContext.runId,
-                        category: inputWithRunContext.category,
-                        operation: inputWithRunContext.operation,
-                        workflow: inputWithRunContext.workflow ?? null,
-                        phase: inputWithRunContext.phase ?? null,
-                        requestedOperation: operationMetadata(inputWithRunContext),
-                        agent,
-                        decision: reusedDecision.decision,
-                        reasons: [{ code: reusedDecision.reason, message: reusedDecision.message }],
-                        riskTier: reusedDecision.riskTier ?? null,
-                        riskReasonCodes: reusedDecision.riskReasonCodes ?? [],
-                        boundary: (reusedDecision.boundary ?? null),
-                        auditEvidence: reusedDecision.auditEvidence ?? [],
-                        requiresHumanApproval: reusedDecision.decision === 'ask',
-                        approvalStatus: prior.value.approval.status,
-                        reusedApprovalId: prior.value.approval.id,
-                        originalDecisionEventId: prior.value.event.id,
-                        approvalMatched: true,
-                        timestamp,
-                    },
-                    relatedType: 'approval',
-                    relatedId: prior.value.approval.id,
-                });
-                return event.ok
-                    ? { ok: true, value: { decision: reusedDecision, event: event.value, approval: prior.value.approval } }
-                    : { ok: false, error: event.error };
-            }
-        }
-        const grantAuthorization = decision.decision === 'ask' ? this.taskScopedCommandGrants.tryAuthorizeAsk({ run: run.value, request: inputWithRunContext, baseDecision: decision }) : undefined;
-        if (grantAuthorization !== undefined) {
-            if (!grantAuthorization.ok)
-                return grantAuthorization;
-            if (grantAuthorization.value.authorized) {
-                const grantedDecision = grantAuthorization.value.decision;
-                const event = this.runs.appendEvent({
-                    runId: inputWithRunContext.runId,
-                    kind: 'permission-decision',
-                    title: `Permission ${grantedDecision.decision}: ${inputWithRunContext.category} ${inputWithRunContext.operation}`,
-                    payload: {
-                        runId: inputWithRunContext.runId,
-                        category: inputWithRunContext.category,
-                        operation: inputWithRunContext.operation,
-                        workflow: inputWithRunContext.workflow ?? null,
-                        phase: inputWithRunContext.phase ?? null,
-                        requestedOperation: operationMetadata(inputWithRunContext),
-                        agent,
-                        decision: grantedDecision.decision,
-                        reasons: [{ code: grantedDecision.reason, message: grantedDecision.message }],
-                        riskTier: grantedDecision.riskTier ?? null,
-                        riskReasonCodes: grantedDecision.riskReasonCodes ?? [],
-                        boundary: (grantedDecision.boundary ?? null),
-                        auditEvidence: grantedDecision.auditEvidence ?? [],
-                        requiresHumanApproval: false,
-                        approvalStatus: 'not-required',
-                        grantEvaluation: grantEvaluationPayload(grantAuthorization.value.evaluation),
-                        grantUseEventId: grantAuthorization.value.event.id,
-                        timestamp,
-                    },
-                    relatedType: 'task-scoped-command-grant',
-                    relatedId: grantAuthorization.value.grant.id,
-                });
-                return event.ok ? { ok: true, value: { decision: grantedDecision, event: event.value } } : { ok: false, error: event.error };
-            }
-        }
-        const event = this.runs.appendEvent({
-            runId: inputWithRunContext.runId,
-            kind: 'permission-decision',
-            title: `Permission ${decision.decision}: ${inputWithRunContext.category} ${inputWithRunContext.operation}`,
-            payload: {
-                runId: inputWithRunContext.runId,
-                category: inputWithRunContext.category,
-                operation: inputWithRunContext.operation,
-                workflow: inputWithRunContext.workflow ?? null,
-                phase: inputWithRunContext.phase ?? null,
-                requestedOperation: operationMetadata(inputWithRunContext),
-                agent,
-                decision: decision.decision,
-                reasons: [{ code: decision.reason, message: decision.message }],
-                riskTier: decision.riskTier ?? null,
-                riskReasonCodes: decision.riskReasonCodes ?? [],
-                boundary: (decision.boundary ?? null),
-                auditEvidence: decision.auditEvidence ?? [],
-                requiresHumanApproval: decision.decision === 'ask',
-                approvalStatus: decision.decision === 'ask' ? 'pending' : 'not-required',
-                ...(grantAuthorization === undefined ? {} : { grantEvaluation: grantEvaluationPayload(grantAuthorization.value.evaluation) }),
-                timestamp,
-            },
-            relatedType: 'permission',
-            relatedId: inputWithRunContext.category,
-        });
-        if (!event.ok)
-            return { ok: false, error: event.error };
-        if (decision.decision !== 'ask')
-            return { ok: true, value: { decision, event: event.value } };
-        const approval = this.runs.createApproval({ runId: inputWithRunContext.runId, decisionEventId: event.value.id });
-        return approval.ok ? { ok: true, value: { decision, event: event.value, approval: approval.value } } : { ok: false, error: approval.error };
-    }
-    validateVgxManagedPreflightMetadata(input) {
-        const run = this.runs.getById(input.runId);
-        if (!run.ok)
-            return { ok: false, error: run.error };
-        if (!isVgxManagedWorkflow(run.value.workflow) || !isRiskyPermissionCategory(input.category))
-            return { ok: true, value: undefined };
-        const missing = [];
-        if (input.phase === undefined || input.phase.trim().length === 0)
-            missing.push('phase');
-        const agentId = input.agentId ?? input.agent?.id;
-        if (agentId === undefined || agentId.trim().length === 0)
-            missing.push('agentId');
-        if (missing.length > 0) {
-            this.runs.appendEvent({
-                runId: input.runId,
-                kind: 'timeline',
-                title: 'Audit: preflight-missing',
-                payload: {
-                    eventType: 'preflight-missing',
-                    runId: input.runId,
-                    category: input.category,
-                    operation: input.operation,
-                    missing,
-                    requestedOperation: operationMetadata(input),
-                    executorInvoked: false,
-                    operationExecuted: false,
-                    timestamp: new Date().toISOString(),
-                },
-                relatedType: 'preflight',
-                relatedId: input.category,
-            });
-            return validationFailure(`VGX-managed preflight for risky category ${input.category} requires metadata: ${missing.join(', ')}`);
-        }
-        return { ok: true, value: undefined };
-    }
-    buildPermissionContextForRun(input) {
-        const run = this.runs.getById(input.runId);
-        if (!run.ok)
-            return { ok: false, error: run.error };
-        const workflow = input.workflow ?? run.value.workflow;
-        const phase = canonicalRunPhase(workflow, input.phase) ?? canonicalRunPhase(run.value.workflow, run.value.phase);
-        const merged = {
-            ...input,
-            workflow,
-            ...(phase === undefined ? {} : { phase }),
-            agentId: input.agentId ?? input.agent?.id ?? run.value.selectedAgentId,
-        };
-        return { ok: true, value: merged };
-    }
-    appendPreflightAuditEvent(input, outcome, audit) {
-        const run = this.runs.getById(input.runId);
-        if (!run.ok || !isVgxManagedWorkflow(run.value.workflow) || !isRiskyPermissionCategory(input.category))
-            return;
-        this.runs.appendEvent({
-            runId: input.runId,
-            kind: 'timeline',
-            title: 'Audit: preflight-required',
-            payload: {
-                eventType: 'preflight-required',
-                runId: input.runId,
-                category: input.category,
-                operation: input.operation,
-                phase: input.phase ?? null,
-                agentId: input.agentId ?? input.agent?.id ?? null,
-                outcome,
-                permissionEventId: audit.permissionEventId,
-                planEventId: audit.planEventId,
-                approvalId: audit.approvalId ?? null,
-                executorInvoked: false,
-                operationExecuted: false,
-                timestamp: new Date().toISOString(),
-            },
-            relatedType: 'preflight',
-            relatedId: input.category,
-        });
-    }
-    appendPreflightGateAuditEvent(runId, operation, status, message) {
-        this.runs.appendEvent({
-            runId,
-            kind: 'timeline',
-            title: `Audit: preflight-${status}`,
-            payload: {
-                eventType: status === 'missing' ? 'preflight-missing' : 'preflight-blocked',
-                runId,
-                category: operation.category,
-                operation: operation.operation,
-                preflightStatus: status,
-                message,
-                requestedOperation: operationMetadata(operation),
-                executorInvoked: false,
-                operationExecuted: false,
-                timestamp: new Date().toISOString(),
-            },
-            relatedType: 'preflight',
-            relatedId: operation.category,
-        });
-    }
-    evaluateVgxManagedExecutionPreflightGate(input) {
-        const details = this.runs.getDetails(input.runId);
-        if (!details.ok)
-            return details;
-        if (!isVgxManagedWorkflow(details.value.workflow) || !isRiskyPermissionCategory(input.operation.category))
-            return { ok: true, value: { blocked: false } };
-        const matchingPreflight = [...details.value.events].reverse().find((event) => isMatchingPreflightPlanEvent(event, input.operation));
-        if (matchingPreflight === undefined) {
-            return {
-                ok: true,
-                value: {
-                    blocked: true,
-                    status: 'missing',
-                    message: `VGX-managed risky operation ${input.operation.category} ${input.operation.operation} requires a valid preflight before executor invocation.`,
-                },
-            };
-        }
-        const status = preflightPlanStatus(matchingPreflight);
-        if (status === 'blocked') {
-            return {
-                ok: true,
-                value: {
-                    blocked: true,
-                    status,
-                    message: `VGX-managed risky operation ${input.operation.category} ${input.operation.operation} was blocked by its latest preflight.`,
-                },
-            };
-        }
-        return { ok: true, value: { blocked: false } };
-    }
-    findMatchingApproval(input, agent, includePending) {
-        const details = this.runs.getDetails(input.runId);
-        if (!details.ok)
-            return details;
-        const requestedOperation = operationMetadata(input);
-        const resolved = details.value.approvals
-            .filter((approval) => approval.status === 'approved' ||
-            approval.status === 'rejected' ||
-            approval.status === 'cancelled' ||
-            (includePending && approval.status === 'pending'))
-            .map((approval) => ({ approval, event: details.value.events.find((event) => event.id === approval.decisionEventId) }))
-            .filter((entry) => entry.event !== undefined && isAskPermissionEvent(entry.event))
-            .filter((entry) => approvalEventMatches(entry.event, input, requestedOperation, agent))
-            .sort((left, right) => (right.approval.resolvedAt ?? right.approval.requestedAt).localeCompare(left.approval.resolvedAt ?? left.approval.requestedAt));
-        return { ok: true, value: resolved[0] };
-    }
-}
-export function calculateStableOperationFingerprint(input) {
-    const canonical = {
-        runId: input.runId,
-        approvalId: input.approvalId,
-        category: input.category,
-        operation: input.operation,
-    };
-    if (input.phase !== undefined)
-        canonical.phase = input.phase;
-    if (input.agentId !== undefined)
-        canonical.agentId = input.agentId;
-    if (input.workspaceRoot !== undefined)
-        canonical.workspaceRoot = input.workspaceRoot;
-    if (input.targetPath !== undefined)
-        canonical.targetPath = input.targetPath;
-    if (input.input !== undefined)
-        canonical.input = input.input;
-    return `sha256:${createHash('sha256').update(stableJson(canonical)).digest('hex')}`;
-}
-function checkpointHasChangeId(state, change) {
-    return typeof state === 'object' && state !== null && !Array.isArray(state) && (state.changeId === change || state.change === change);
-}
-function countByStatus(statuses) {
-    const counts = { total: statuses.length };
-    for (const status of statuses) {
-        if (status === 'pending')
-            counts.pending = (counts.pending ?? 0) + 1;
-        else if (status === 'approved')
-            counts.approved = (counts.approved ?? 0) + 1;
-        else if (status === 'rejected')
-            counts.rejected = (counts.rejected ?? 0) + 1;
-        else if (status === 'cancelled')
-            counts.cancelled = (counts.cancelled ?? 0) + 1;
-        else if (status === 'reserved')
-            counts.reserved = (counts.reserved ?? 0) + 1;
-        else if (status === 'succeeded')
-            counts.succeeded = (counts.succeeded ?? 0) + 1;
-        else if (status === 'failed')
-            counts.failed = (counts.failed ?? 0) + 1;
-        else if (status === 'abandoned')
-            counts.abandoned = (counts.abandoned ?? 0) + 1;
-    }
-    return counts;
-}
-function preflightOutcome(decision) {
-    if (decision.decision === 'allow')
-        return 'allowed';
-    if (decision.decision === 'deny')
-        return 'blocked';
-    return 'approval-needed';
-}
-function isVgxManagedWorkflow(workflow) {
-    const normalized = workflow.toLowerCase();
-    return normalized === 'sdd' || normalized.startsWith('sdd-') || normalized.includes('sdd') || normalized.includes('vgx');
-}
-function workflowConflictDecision(input, runWorkflow) {
-    if (input.workflow === undefined || input.workflow === runWorkflow)
-        return undefined;
-    const eitherSdd = input.workflow === 'sdd' || runWorkflow === 'sdd' || input.workflow.includes('sdd') || runWorkflow.includes('sdd');
-    if (!eitherSdd)
-        return undefined;
-    return {
-        decision: 'ask',
-        category: input.category,
-        operation: input.operation,
-        reason: 'workflow_context',
-        message: `Explicit workflow ${input.workflow} conflicts with run workflow ${runWorkflow}; human validation is required before crossing SDD/non-SDD context.`,
-        workflow: input.workflow,
-        warnings: [`workflow-conflict:${runWorkflow}->${input.workflow}`],
-        auditEvidence: [`runWorkflow:${runWorkflow}`, `explicitWorkflow:${input.workflow}`],
-    };
-}
-function appendApplyProgressAllowlistEvidenceIfNeeded(runs, approvalId, permissionEvent, pendingExecutionEvent, attempt, executionEvent, operationFingerprint, executorName, operation, result) {
-    if (!isApplyProgressAllowlistedCommandOperation(operation))
-        return { ok: true, value: undefined };
-    const base = {
-        ...result,
-        executionEventId: executionEvent.id,
-        audit: {
-            metadataOnly: true,
-            operationFingerprint,
-            executor: executorName,
-            approvalId,
-            pendingExecutionEventId: pendingExecutionEvent.id,
-            permissionEventId: permissionEvent.id,
-            attemptId: attempt.id,
-        },
-    };
-    const evidence = runs.appendEvent({
-        runId: attempt.runId,
-        kind: 'evidence',
-        title: `Apply-progress allowlisted command ${attempt.status}: ${operation.operation}`,
-        payload: base,
-        relatedType: 'operation-attempt',
-        relatedId: attempt.id,
-    });
-    if (!evidence.ok)
-        return { ok: false, error: evidence.error };
-    const checkpoint = runs.appendCheckpoint({
-        runId: attempt.runId,
-        label: 'apply-progress-allowlisted-command-executed',
-        state: { ...base, evidenceEventId: evidence.value.id },
-    });
-    if (!checkpoint.ok)
-        return { ok: false, error: checkpoint.error };
-    return { ok: true, value: { checkpoint: checkpoint.value, evidenceEvent: evidence.value } };
-}
-function isApplyProgressAllowlistedCommandOperation(operation) {
-    if (operation.input === undefined)
-        return false;
-    if (!isObject(operation.input))
-        return false;
-    return (operation.phase === 'apply-progress' &&
-        operation.input.kind === 'apply-progress-operation' &&
-        operation.input.operationKind === 'allowlisted-command' &&
-        /^command-allowlist:[A-Za-z0-9._/-]+$/u.test(operation.operation));
-}
-function executionPayload(operation, executorName, status, extra) {
-    return {
-        status,
-        executorName,
-        requestedOperation: operationMetadata(operation),
-        input: operation.input ?? null,
-        timestamp: new Date().toISOString(),
-        ...extra,
-    };
-}
-function operationMetadataWithReplayGuard(operation, replayGuard) {
-    const metadata = operationMetadata(operation);
-    if (!isObject(metadata))
-        return metadata;
-    return { ...metadata, replayGuard };
-}
-function replayGuardForApprovedOperation(approval, permissionEvent, pendingExecutionEvent, operation) {
-    const fingerprintInput = fingerprintInputForApprovedOperation(approval, permissionEvent, operation);
-    const operationFingerprint = calculateStableOperationFingerprint(fingerprintInput);
-    return {
-        version: 1,
-        operationFingerprint,
-        fingerprintAlgorithm: 'sha256:stable-json:v1',
-        expectedPendingExecutionEventId: pendingExecutionEvent?.id ?? null,
-        associated: fingerprintInput,
-    };
-}
-function fingerprintInputForApprovedOperation(approval, permissionEvent, operation) {
-    const permissionPayload = isObject(permissionEvent.payload) ? permissionEvent.payload : {};
-    const requestedOperation = permissionPayload.requestedOperation !== undefined && isObject(permissionPayload.requestedOperation) ? permissionPayload.requestedOperation : {};
-    const agent = permissionPayload.agent !== undefined && isObject(permissionPayload.agent) ? permissionPayload.agent : undefined;
-    const phase = stringField(operation.phase) ?? stringField(requestedOperation.phase) ?? stringField(permissionPayload.phase);
-    const agentId = stringField(operation.agentId) ?? stringField(requestedOperation.agentId) ?? stringField(agent?.id);
-    const workspaceRoot = stringField(operation.workspaceRoot) ?? stringField(requestedOperation.workspaceRoot);
-    const targetPath = stringField(operation.targetPath) ?? stringField(requestedOperation.targetPath);
-    const fingerprintInput = {
-        runId: approval.runId,
-        approvalId: approval.id,
-        category: operation.category,
-        operation: operation.operation,
-    };
-    if (phase !== undefined)
-        fingerprintInput.phase = phase;
-    if (agentId !== undefined)
-        fingerprintInput.agentId = agentId;
-    if (workspaceRoot !== undefined)
-        fingerprintInput.workspaceRoot = workspaceRoot;
-    if (targetPath !== undefined)
-        fingerprintInput.targetPath = targetPath;
-    if (operation.input !== undefined)
-        fingerprintInput.input = operation.input;
-    return fingerprintInput;
-}
-function validateReplayGuard(pendingExecutionEvent, replayGuard, expectedOperationFingerprint) {
-    const actualFingerprint = replayGuard.operationFingerprint;
-    if (expectedOperationFingerprint !== undefined && expectedOperationFingerprint !== actualFingerprint) {
-        return validationFailure(`Operation fingerprint mismatch: expected ${expectedOperationFingerprint}, calculated ${actualFingerprint}`);
-    }
-    if (isObject(pendingExecutionEvent.payload)) {
-        const stored = typeof pendingExecutionEvent.payload.operationFingerprint === 'string' ? pendingExecutionEvent.payload.operationFingerprint : undefined;
-        const storedReplayGuard = pendingExecutionEvent.payload.replayGuard !== undefined && isObject(pendingExecutionEvent.payload.replayGuard) ? pendingExecutionEvent.payload.replayGuard : undefined;
-        const storedReplayFingerprint = typeof storedReplayGuard?.operationFingerprint === 'string' ? storedReplayGuard.operationFingerprint : undefined;
-        const storedFingerprint = stored ?? storedReplayFingerprint;
-        if (storedFingerprint !== undefined && storedFingerprint !== actualFingerprint) {
-            return validationFailure(`Stored operation fingerprint mismatch: stored ${storedFingerprint}, calculated ${actualFingerprint}`);
-        }
-    }
-    return { ok: true, value: undefined };
-}
-function summarizeOperation(operation) {
-    return {
-        category: operation.category,
-        operation: operation.operation,
-        ...(operation.input === undefined ? {} : { input: operation.input }),
-    };
-}
-function resumeGateNextAction(approval, details, blockers) {
-    const approvalBlocker = blockers.find((blocker) => blocker.code === 'approval-not-approved');
-    if (approvalBlocker !== undefined) {
-        return {
-            type: 'resolve-approval',
-            command: `runs approve --approval ${approval.id}`,
-            reason: approvalBlocker.message,
-        };
-    }
-    const missingContext = blockers.find((blocker) => blocker.code === 'missing-permission-event' || blocker.code === 'missing-pending-operation' || blocker.code === 'operation-metadata-incomplete');
-    if (missingContext !== undefined) {
-        return {
-            type: 'inspect-run',
-            command: `runs resume-inspect --id ${details.id}`,
-            reason: missingContext.message,
-        };
-    }
-    const retryBlocker = blockers.find((blocker) => blocker.code === 'retry-blocked');
-    if (retryBlocker !== undefined) {
-        return {
-            type: 'retry-check',
-            command: `runs retry-check --approval ${approval.id}`,
-            reason: retryBlocker.message,
-        };
-    }
-    return {
-        type: 'manual-recovery',
-        command: `runs retry-check --approval ${approval.id}`,
-        reason: 'The operator may manually continue after reviewing retry-check guidance; no execution is performed by this plan.',
-    };
-}
-function resumeGateManualNextCommands(approval, details, operation) {
-    const commands = [`runs resume-inspect --id ${details.id}`, `runs retry-check --approval ${approval.id}`];
-    if (approval.status !== 'approved')
-        commands.unshift(`runs approve --approval ${approval.id}`);
-    if (operation !== undefined)
-        commands.push(`Review operation manually: ${operation.category} ${operation.operation}`);
-    return commands;
-}
-function canonicalRunPhase(workflow, phase) {
-    if (phase === undefined || phase.trim().length === 0)
-        return undefined;
-    if (!isSddWorkflow(workflow))
-        return phase;
-    return normalizeSddPhaseInput(phase) ?? phase;
-}
-function isSddWorkflow(workflow) {
-    return workflow?.trim().toLowerCase() === 'sdd';
-}
-function operationMetadata(input) {
-    const metadata = { category: input.category, name: input.operation };
-    if (input.workspaceRoot !== undefined)
-        metadata.workspaceRoot = input.workspaceRoot;
-    if (input.targetPath !== undefined)
-        metadata.targetPath = input.targetPath;
-    if (input.providerToolName !== undefined)
-        metadata.providerToolName = input.providerToolName;
-    if (input.sandboxStrategy !== undefined)
-        metadata.sandboxStrategy = input.sandboxStrategy;
-    if (input.workflow !== undefined)
-        metadata.workflow = input.workflow;
-    if (input.phase !== undefined)
-        metadata.phase = input.phase;
-    if (input.agentId !== undefined)
-        metadata.agentId = input.agentId;
-    if (input.taskFingerprint !== undefined)
-        metadata.taskFingerprint = input.taskFingerprint;
-    if (input.commandId !== undefined)
-        metadata.commandId = input.commandId;
-    if (input.cwd !== undefined)
-        metadata.cwd = input.cwd;
-    if (input.targetPaths !== undefined)
-        metadata.targetPaths = input.targetPaths;
-    if (input.destructive !== undefined)
-        metadata.destructive = input.destructive;
-    if (input.external !== undefined)
-        metadata.external = input.external;
-    if (input.privileged !== undefined)
-        metadata.privileged = input.privileged;
-    if (input.ambiguous !== undefined)
-        metadata.ambiguous = input.ambiguous;
-    if (input.input !== undefined)
-        metadata.input = input.input;
-    return metadata;
-}
-function approvalEventMatches(event, input, requestedOperation, agent) {
-    if (!isObject(event.payload))
-        return false;
-    if (event.payload.runId !== input.runId)
-        return false;
-    if (event.payload.category !== input.category || event.payload.operation !== input.operation)
-        return false;
-    if (!operationMetadataCompatible(event.payload.requestedOperation, requestedOperation))
-        return false;
-    if (!jsonEqual(event.payload.agent, agent))
-        return false;
-    return true;
-}
-function isMatchingPreflightPlanEvent(event, operation) {
-    if (event.kind !== 'execution-plan' || !isObject(event.payload))
-        return false;
-    const requestedOperation = event.payload.requestedOperation;
-    return requestedOperation !== undefined && operationMetadataCompatible(requestedOperation, operationMetadata(operation));
-}
-function operationMetadataCompatible(preflightOperation, requestedOperation) {
-    if (preflightOperation === undefined || requestedOperation === undefined)
-        return jsonEqual(preflightOperation, requestedOperation);
-    if (!isObject(preflightOperation) || !isObject(requestedOperation))
-        return jsonEqual(preflightOperation, requestedOperation);
-    if (preflightOperation.category !== requestedOperation.category || preflightOperation.name !== requestedOperation.name)
-        return false;
-    const strictKeys = ['workspaceRoot', 'targetPath', 'providerToolName', 'sandboxStrategy', 'taskFingerprint', 'commandId', 'cwd', 'targetPaths', 'destructive', 'external', 'privileged', 'ambiguous'];
-    for (const key of strictKeys) {
-        if (key in preflightOperation && key in requestedOperation && !jsonEqual(preflightOperation[key], requestedOperation[key]))
-            return false;
-    }
-    if ('input' in preflightOperation && 'input' in requestedOperation && !jsonEqual(preflightOperation.input, requestedOperation.input))
-        return false;
-    return true;
-}
-function preflightPlanStatus(event) {
-    if (!isObject(event.payload))
-        return 'blocked';
-    const sandboxDecision = event.payload.sandboxDecision;
-    if (sandboxDecision !== undefined && isObject(sandboxDecision) && sandboxDecision.decision === 'rejected')
-        return 'blocked';
-    const plan = event.payload.plan;
-    if (plan !== undefined && isObject(plan) && plan.executable === true)
-        return 'allowed';
-    if (typeof event.payload.approvalId === 'string' && event.payload.approvalId.length > 0)
-        return 'approval-needed';
-    return 'blocked';
-}
-function jsonEqual(left, right) {
-    return stableJson(left ?? null) === stableJson(right ?? null);
-}
-function stableJson(value) {
-    if (Array.isArray(value))
-        return `[${value.map(stableJson).join(',')}]`;
-    if (isObject(value))
-        return `{${Object.keys(value)
-            .sort()
-            .map((key) => `${JSON.stringify(key)}:${stableJson(value[key] ?? null)}`)
-            .join(',')}}`;
-    return JSON.stringify(value);
-}
-function sandboxDecisionSummary(sandbox) {
-    if (sandbox === undefined)
-        return undefined;
-    return {
-        strategy: sandbox.strategy,
-        decision: sandbox.decision,
-        workspaceRoot: sandbox.workspaceRoot,
-        targetPath: sandbox.targetPath ?? null,
-        reason: sandbox.reason ?? null,
-        validationSummary: sandbox.audit.validationSummary,
-        gitBoundary: sandbox.gitBoundary,
-        providerConfigMutation: sandbox.providerConfigMutation,
-        createsWorktree: sandbox.createsWorktree,
-        executesProvider: sandbox.executesProvider,
-    };
-}
-function isAskPermissionEvent(event) {
-    return event.kind === 'permission-decision' && isObject(event.payload) && event.payload.decision === 'ask';
-}
-function isPendingExecutionEventForApproval(event, approvalId) {
-    return (event.kind === 'operation-execution' && isObject(event.payload) && event.payload.status === 'pending-approval' && event.payload.approvalId === approvalId);
-}
-function permissionEventForPendingExecution(details, approval, pendingExecutionEvent) {
-    const decisionEventId = isObject(pendingExecutionEvent.payload) && typeof pendingExecutionEvent.payload.decisionEventId === 'string'
-        ? pendingExecutionEvent.payload.decisionEventId
-        : approval.decisionEventId;
-    return details.events.find((event) => event.id === decisionEventId) ?? details.events.find((event) => event.id === approval.decisionEventId);
-}
-function operationFromPendingExecution(payload) {
-    if (!isObject(payload))
-        return undefined;
-    const requestedOperation = payload.requestedOperation;
-    if (requestedOperation === undefined || !isObject(requestedOperation))
-        return undefined;
-    const requested = requestedOperation;
-    if (!isPermissionCategory(requested.category) || typeof requested.name !== 'string')
-        return undefined;
-    const operation = { category: requested.category, operation: requested.name };
-    if (typeof requested.workspaceRoot === 'string')
-        operation.workspaceRoot = requested.workspaceRoot;
-    if (typeof requested.targetPath === 'string')
-        operation.targetPath = requested.targetPath;
-    if (typeof requested.providerToolName === 'string')
-        operation.providerToolName = requested.providerToolName;
-    if (typeof requested.phase === 'string')
-        operation.phase = requested.phase;
-    if (typeof requested.agentId === 'string')
-        operation.agentId = requested.agentId;
-    if (typeof requested.taskFingerprint === 'string')
-        operation.taskFingerprint = requested.taskFingerprint;
-    if (typeof requested.commandId === 'string')
-        operation.commandId = requested.commandId;
-    if (typeof requested.cwd === 'string')
-        operation.cwd = requested.cwd;
-    if (Array.isArray(requested.targetPaths) && requested.targetPaths.every((item) => typeof item === 'string'))
-        operation.targetPaths = requested.targetPaths;
-    if (typeof requested.destructive === 'boolean')
-        operation.destructive = requested.destructive;
-    if (typeof requested.external === 'boolean')
-        operation.external = requested.external;
-    if (typeof requested.privileged === 'boolean')
-        operation.privileged = requested.privileged;
-    if (typeof requested.ambiguous === 'boolean')
-        operation.ambiguous = requested.ambiguous;
-    if ('input' in requested)
-        operation.input = requested.input;
-    if ('input' in payload && payload.input !== null)
-        operation.input = payload.input;
-    return operation;
-}
-function stringField(value) {
-    return typeof value === 'string' && value.length > 0 ? value : undefined;
-}
-function isObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isPermissionCategory(value) {
-    return (value === 'read' ||
-        value === 'edit' ||
-        value === 'implementation-edit' ||
-        value === 'spec-write' ||
-        value === 'design-write' ||
-        value === 'task-write' ||
-        value === 'shell' ||
-        value === 'test-run' ||
-        value === 'install' ||
-        value === 'network' ||
-        value === 'git' ||
-        value === 'git-write' ||
-        value === 'memory' ||
-        value === 'memory-write' ||
-        value === 'external-directory' ||
-        value === 'provider-tool' ||
-        value === 'secrets');
-}
-function validationFailure(message) {
-    return { ok: false, error: { code: 'validation_failed', message } };
-}
+export * from '../application/runs/run-service.js';