@resolveio/server-lib 22.3.149 → 22.3.150

package/util/ai-runner-manager-policy.js

@@ -1,1763 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildResolveIOAIManagerHotfixFirstReleasePolicy = buildResolveIOAIManagerHotfixFirstReleasePolicy;
-exports.isResolveIOAIManagerSafeAutoDispatch = isResolveIOAIManagerSafeAutoDispatch;
-exports.normalizeResolveIOAIManagerFailureClass = normalizeResolveIOAIManagerFailureClass;
-exports.fingerprintResolveIOAIManagerBlocker = fingerprintResolveIOAIManagerBlocker;
-exports.hashResolveIOAIManagerEvidence = hashResolveIOAIManagerEvidence;
-exports.buildResolveIOAIManagerRecoveryCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint;
-exports.buildResolveIOAIManagerRecoveryEvidenceProbe = buildResolveIOAIManagerRecoveryEvidenceProbe;
-exports.buildResolveIOAIManagerRecoveryActionPacket = buildResolveIOAIManagerRecoveryActionPacket;
-exports.decideResolveIOAIManagerRecoveryActionDispatch = decideResolveIOAIManagerRecoveryActionDispatch;
-exports.appendResolveIOAIManagerRecoveryActionDispatch = appendResolveIOAIManagerRecoveryActionDispatch;
-exports.buildResolveIOAIManagerRecoveryExecutionDirective = buildResolveIOAIManagerRecoveryExecutionDirective;
-exports.assessResolveIOAIManagerEvidenceChange = assessResolveIOAIManagerEvidenceChange;
-exports.decideResolveIOAIManagerRecoveryGate = decideResolveIOAIManagerRecoveryGate;
-exports.buildResolveIOAIManagerRecoveryPlan = buildResolveIOAIManagerRecoveryPlan;
-exports.decideResolveIOAIManagerPolicy = decideResolveIOAIManagerPolicy;
-exports.buildResolveIOAIManagerRecoveryReplayMatrix = buildResolveIOAIManagerRecoveryReplayMatrix;
-function cleanText(value, max) {
-    if (max === void 0) { max = 2000; }
-    return String(value || '').replace(/\s+/g, ' ').trim().slice(0, max);
-}
-function cleanList(values, limit, max) {
-    var e_1, _a;
-    if (limit === void 0) { limit = 40; }
-    if (max === void 0) { max = 500; }
-    if (!Array.isArray(values)) {
-        return [];
-    }
-    var result = [];
-    try {
-        for (var values_1 = __values(values), values_1_1 = values_1.next(); !values_1_1.done; values_1_1 = values_1.next()) {
-            var value = values_1_1.value;
-            var normalized = cleanText(value, max);
-            if (normalized && !result.includes(normalized)) {
-                result.push(normalized);
-            }
-            if (result.length >= limit) {
-                break;
-            }
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (values_1_1 && !values_1_1.done && (_a = values_1.return)) _a.call(values_1);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    return result;
-}
-function releaseStatusIsBlocked(value) {
-    return /fail|error|blocked|missing|empty|not ready|not_ready|denied|invalid|timeout|stale/i.test(value);
-}
-function releaseStatusIsTerminalDeploy(value) {
-    return /requested|queued|in.?progress|completed|complete|success|succeeded|pass|passed|published|deployed|failed|error|blocked/i.test(value);
-}
-function buildReleaseAllowedActions(action) {
-    if (action === 'wait_for_active_deploy') {
-        return ['wait_for_current_deploy_result', 'collect_current_deploy_log', 'refresh_release_snapshot'];
-    }
-    if (action === 'block_duplicate_deploy') {
-        return ['collect_existing_deploy_evidence', 'hotfix_release_artifact', 'request_force_deploy_with_reason'];
-    }
-    if (action === 'block_duplicate_publish') {
-        return ['collect_existing_publish_evidence', 'hotfix_release_artifact', 'request_force_publish_with_reason'];
-    }
-    if (action === 'review_force_deploy') {
-        return ['verify_force_deploy_reason', 'rerun_failed_release_gate_once', 'record_force_deploy_evidence'];
-    }
-    if (action === 'deploy_new_artifact_after_release_gate') {
-        return ['verify_new_artifact_fingerprint', 'run_release_gate_once', 'record_publish_deploy_evidence'];
-    }
-    if (action === 'build_artifact_first') {
-        return ['build_missing_release_artifact', 'record_artifact_fingerprint', 'run_release_gate_once'];
-    }
-    return ['hotfix_live_runner_or_release_artifact', 'rerun_failed_release_gate_only', 'record_release_evidence'];
-}
-function hotfixStep(id, label, channel, options) {
-    if (options === void 0) { options = {}; }
-    return {
-        id: id,
-        label: label,
-        channel: channel,
-        safeToAutoRun: options.safeToAutoRun === true,
-        requiresFullDeploy: options.requiresFullDeploy === true,
-        requiredEvidence: options.requiredEvidence || [],
-        successEvidence: options.successEvidence || [],
-        blockedBy: options.blockedBy || []
-    };
-}
-function buildHotfixFirstReleasePlan(input) {
-    var surface = cleanText(input.surface || 'runner', 80)
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '_')
-        .replace(/^_+|_+$/g, '') || 'runner';
-    var commonAcceptance = [
-        'failed release gate is rerun once and passes',
-        'artifact fingerprint or hotfix evidence is recorded',
-        'operator console shows no active duplicate deploy blocker'
-    ];
-    if (input.action === 'wait_for_active_deploy') {
-        return {
-            planId: "".concat(surface, ":wait_for_active_deploy"),
-            label: 'Wait For Active Deploy',
-            recommendedChannel: 'release_artifact',
-            reason: input.reason,
-            fullDeployAvoided: true,
-            steps: [
-                hotfixStep('collect_active_deploy_log', 'Collect active deploy log', 'release_artifact', {
-                    safeToAutoRun: true,
-                    requiredEvidence: ['active deploy id or release operation id'],
-                    successEvidence: ['terminal deploy status and release log captured']
-                })
-            ],
-            acceptanceEvidence: commonAcceptance,
-            escalationTriggers: ['active deploy exceeds timeout', 'active deploy fails without a release log']
-        };
-    }
-    if (input.action === 'deploy_new_artifact_after_release_gate') {
-        return {
-            planId: "".concat(surface, ":deploy_new_artifact_after_release_gate"),
-            label: 'Deploy New Artifact After Release Gate',
-            recommendedChannel: 'new_artifact_deploy',
-            reason: input.reason,
-            fullDeployAvoided: false,
-            steps: [
-                hotfixStep('verify_new_artifact_fingerprint', 'Verify new artifact fingerprint', 'new_artifact_deploy', {
-                    safeToAutoRun: true,
-                    requiresFullDeploy: true,
-                    requiredEvidence: ['current artifact fingerprint differs from last deployed fingerprint'],
-                    successEvidence: ['release gate permits one full deploy']
-                })
-            ],
-            acceptanceEvidence: [
-                'new artifact fingerprint recorded',
-                'release gate passed before full deploy',
-                'deploy/publish result recorded'
-            ],
-            escalationTriggers: ['artifact fingerprint matches last deploy', 'release gate fails']
-        };
-    }
-    if (input.action === 'build_artifact_first') {
-        return {
-            planId: "".concat(surface, ":build_artifact_first"),
-            label: 'Build Artifact First',
-            recommendedChannel: 'artifact_build',
-            reason: input.reason,
-            fullDeployAvoided: true,
-            steps: [
-                hotfixStep('build_once_record_fingerprint', 'Build once and record fingerprint', 'artifact_build', {
-                    safeToAutoRun: false,
-                    requiredEvidence: ['missing artifact fingerprint', 'release gate reason for building'],
-                    successEvidence: ['artifact fingerprint recorded before any deploy']
-                })
-            ],
-            acceptanceEvidence: ['artifact fingerprint exists', 'no deploy queued before release gate'],
-            escalationTriggers: ['build repeats without a new fingerprint', 'build failure lacks compile log']
-        };
-    }
-    if (input.action === 'review_force_deploy') {
-        return {
-            planId: "".concat(surface, ":review_force_deploy"),
-            label: 'Review Force Deploy',
-            recommendedChannel: 'force_deploy_review',
-            reason: input.reason,
-            fullDeployAvoided: false,
-            steps: [
-                hotfixStep('verify_force_deploy_reason', 'Verify force deploy reason', 'force_deploy_review', {
-                    requiredEvidence: ['explicit force_deploy reason', 'why hotfix cannot resolve the release blocker'],
-                    successEvidence: ['one allowed deploy attempt is recorded with reason']
-                })
-            ],
-            acceptanceEvidence: ['force deploy evidence recorded', 'duplicate fingerprint exception is auditable'],
-            escalationTriggers: ['force deploy reason is empty', 'same force deploy fails twice']
-        };
-    }
-    return {
-        planId: "".concat(surface, ":").concat(input.action),
-        label: input.action === 'block_duplicate_deploy'
-            ? 'Hotfix Or Force Deploy'
-            : input.action === 'block_duplicate_publish'
-                ? 'Hotfix Or Force Publish'
-                : 'Hotfix Release Artifact',
-        recommendedChannel: input.action === 'block_duplicate_publish'
-            ? 'release_artifact'
-            : input.releaseBlocked ? 'release_artifact' : 'static_ui',
-        reason: input.reason,
-        fullDeployAvoided: true,
-        steps: [
-            hotfixStep('static_ui_hotfix', 'Static UI hotfix', 'static_ui', {
-                safeToAutoRun: true,
-                requiredEvidence: ['built dist path', 'target S3 bucket and CloudFront distribution', 'changed frontend bundle or asset list'],
-                successEvidence: ['S3 upload result', 'CloudFront invalidation id', 'public bundle contains expected hotfix marker']
-            }),
-            hotfixStep('backend_js_hotfix', 'Backend JS hotfix', 'backend_js', {
-                requiredEvidence: ['compiled JS artifact path', 'target backend host', 'diff limited to runner/operator code'],
-                successEvidence: ['remote file checksum', 'service restart or process reload evidence', 'self-test passes']
-            }),
-            hotfixStep('config_seed_cache_restart', 'Config, seed, cache, or restart repair', 'config', {
-                safeToAutoRun: true,
-                requiredEvidence: ['exact config/seed/cache key or process name', 'why no product artifact changed'],
-                successEvidence: ['release gate rerun result', 'operator console release snapshot refreshed']
-            })
-        ],
-        acceptanceEvidence: commonAcceptance,
-        escalationTriggers: [
-            'hotfix changes customer-facing product code outside the release artifact',
-            'same release gate fails twice after hotfix evidence',
-            'same publish fingerprint is retried without force_publish evidence',
-            'force deploy is requested without a reason'
-        ]
-    };
-}
-function buildResolveIOAIManagerHotfixFirstReleasePolicy(input) {
-    if (input === void 0) { input = {}; }
-    var surface = cleanText(input.surface || 'runner', 120);
-    var deployStatus = cleanText(input.deployStatus, 160);
-    var publishStatus = cleanText(input.publishStatus, 160);
-    var sampleDataStatus = cleanText(input.sampleDataStatus, 160);
-    var deployFingerprint = cleanText(input.deployFingerprint, 240);
-    var lastDeployFingerprint = cleanText(input.lastDeployFingerprint, 240);
-    var publishFingerprint = cleanText(input.publishFingerprint, 240);
-    var lastPublishFingerprint = cleanText(input.lastPublishFingerprint, 240);
-    var fingerprintMatchesLast = !!deployFingerprint && !!lastDeployFingerprint && deployFingerprint === lastDeployFingerprint;
-    var publishFingerprintMatchesLast = !!publishFingerprint && !!lastPublishFingerprint && publishFingerprint === lastPublishFingerprint;
-    var releaseBlocked = [deployStatus, publishStatus, sampleDataStatus].some(releaseStatusIsBlocked);
-    var duplicateDeployBlocked = fingerprintMatchesLast
-        && input.forceDeploy !== true
-        && releaseStatusIsTerminalDeploy([deployStatus, publishStatus].filter(Boolean).join(' '));
-    var duplicatePublishBlocked = publishFingerprintMatchesLast
-        && input.forcePublish !== true
-        && releaseStatusIsBlocked(publishStatus)
-        && releaseStatusIsTerminalDeploy(publishStatus);
-    var recommendedAction = 'hotfix_release_artifact';
-    var label = 'Hotfix Release Artifact';
-    var reason = 'Repair the live runner/operator code, release config, domain, seed-data, or release artifact and rerun only the failed release gate.';
-    var fullDeployAllowed = false;
-    if (input.activeDeploy === true) {
-        recommendedAction = 'wait_for_active_deploy';
-        label = 'Wait For Active Deploy';
-        reason = 'A deploy is already queued or running; collect that result before spending another deploy cycle.';
-    }
-    else if (duplicateDeployBlocked) {
-        recommendedAction = 'block_duplicate_deploy';
-        label = 'Block Duplicate Deploy';
-        reason = 'The same artifact fingerprint already has release status; hotfix or provide explicit force_deploy evidence before rerunning it.';
-    }
-    else if (duplicatePublishBlocked) {
-        recommendedAction = 'block_duplicate_publish';
-        label = 'Block Duplicate Publish';
-        reason = 'The same publish fingerprint already has release status; hotfix the release artifact or provide explicit force_publish evidence before rerunning publish.';
-    }
-    else if ((fingerprintMatchesLast && input.forceDeploy === true) || (publishFingerprintMatchesLast && input.forcePublish === true)) {
-        recommendedAction = 'review_force_deploy';
-        label = 'Review Force Deploy';
-        reason = input.forcePublish === true
-            ? 'force_publish was explicitly requested for a repeated publish artifact; require a reason and rerun only the failed release gate.'
-            : 'force_deploy was explicitly requested for a repeated artifact; require a reason and rerun only the failed release gate.';
-        fullDeployAllowed = true;
-    }
-    else if (input.hasNewArtifact === false && !releaseBlocked) {
-        recommendedAction = 'build_artifact_first';
-        label = 'Build Artifact First';
-        reason = 'No release artifact fingerprint is available yet; build once, record the fingerprint, and avoid repeated deploys.';
-    }
-    else if (input.hasNewArtifact === true && !releaseBlocked) {
-        recommendedAction = 'deploy_new_artifact_after_release_gate';
-        label = 'Deploy New Artifact After Release Gate';
-        reason = 'A new artifact can be deployed after the release gate proves the artifact is new and ready.';
-        fullDeployAllowed = true;
-    }
-    var allowedActions = buildReleaseAllowedActions(recommendedAction);
-    var hotfixPlan = buildHotfixFirstReleasePlan({
-        action: recommendedAction,
-        surface: surface,
-        reason: reason,
-        releaseBlocked: releaseBlocked
-    });
-    return {
-        policy: 'hotfix_first',
-        surface: surface,
-        recommendedAction: recommendedAction,
-        label: label,
-        reason: reason,
-        hotfixPreferred: recommendedAction !== 'deploy_new_artifact_after_release_gate' && recommendedAction !== 'review_force_deploy',
-        fullDeployAllowed: fullDeployAllowed,
-        duplicateDeployBlocked: duplicateDeployBlocked,
-        duplicatePublishBlocked: duplicatePublishBlocked,
-        forceDeployRequiredToRepeat: true,
-        forcePublishRequiredToRepeat: true,
-        statuses: {
-            deploy: deployStatus,
-            publish: publishStatus,
-            sampleData: sampleDataStatus
-        },
-        fingerprints: {
-            current: deployFingerprint,
-            last: lastDeployFingerprint,
-            matchesLast: fingerprintMatchesLast,
-            publishCurrent: publishFingerprint,
-            publishLast: lastPublishFingerprint,
-            publishMatchesLast: publishFingerprintMatchesLast
-        },
-        hotfixPlan: hotfixPlan,
-        allowedActions: allowedActions,
-        forbiddenActions: [
-            'rerun full builder loop for a release-only blocker',
-            'queue duplicate deploy without force_deploy evidence',
-            'queue duplicate publish without force_publish evidence',
-            'publish/deploy again before reading the failed release log',
-            'change core workflow after business proof passed unless release evidence proves it is required'
-        ],
-        requiredEvidence: [
-            'failed release gate log or active deploy result',
-            'deploy artifact fingerprint comparison',
-            'publish artifact fingerprint comparison when publish is the failed gate',
-            'hotfix/config/seed/domain change evidence when no new product artifact is needed',
-            'force_deploy or force_publish reason when repeating the same fingerprint'
-        ]
-    };
-}
-function isResolveIOAIManagerSafeAutoDispatch(input) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-    var normalizedInput = typeof input === 'string'
-        ? { dispatchAction: input }
-        : (input || {});
-    var dispatchAction = cleanText(normalizedInput.dispatchAction || ((_a = normalizedInput.directive) === null || _a === void 0 ? void 0 : _a.dispatchAction), 120);
-    var directiveAllowed = (_b = normalizedInput.directive) === null || _b === void 0 ? void 0 : _b.allowed;
-    var actionAutoRunnable = (_c = normalizedInput.action) === null || _c === void 0 ? void 0 : _c.autoRunnable;
-    var productRepairAllowed = ((_d = normalizedInput.directive) === null || _d === void 0 ? void 0 : _d.canRunProductRepair) === true
-        || ((_e = normalizedInput.directive) === null || _e === void 0 ? void 0 : _e.productRepairAllowed) === true
-        || ((_f = normalizedInput.action) === null || _f === void 0 ? void 0 : _f.productRepairAllowed) === true;
-    var expensiveModelAllowed = ((_g = normalizedInput.directive) === null || _g === void 0 ? void 0 : _g.canRunExpensiveModel) === true
-        || ((_h = normalizedInput.directive) === null || _h === void 0 ? void 0 : _h.expensiveModelAllowed) === true
-        || ((_j = normalizedInput.action) === null || _j === void 0 ? void 0 : _j.expensiveModelAllowed) === true;
-    if (!dispatchAction || dispatchAction === 'park_manual') {
-        return false;
-    }
-    if (directiveAllowed === false || actionAutoRunnable === false) {
-        return false;
-    }
-    if ([
-        'run_evidence_probe',
-        'run_read_only_diagnosis',
-        'run_infra_repair',
-        'run_compile_repair'
-    ].includes(dispatchAction)) {
-        return true;
-    }
-    if (dispatchAction === 'run_release_repair') {
-        return normalizedInput.includeReleaseRepair !== false;
-    }
-    if (dispatchAction === 'run_journey_contract_repair') {
-        return normalizedInput.includeJourneyContractRepair !== false && productRepairAllowed !== true;
-    }
-    if (dispatchAction === 'run_business_assertion_repair') {
-        return normalizedInput.includeBusinessProofRepair === true
-            && productRepairAllowed !== true
-            && expensiveModelAllowed !== true;
-    }
-    if (dispatchAction === 'run_targeted_product_repair') {
-        return normalizedInput.includeProductRepair === true
-            && productRepairAllowed === true
-            && expensiveModelAllowed !== true;
-    }
-    return dispatchAction === 'advance' || dispatchAction === 'continue_gate';
-}
-function isoNow(value) {
-    if (value instanceof Date) {
-        return value.toISOString();
-    }
-    var parsed = value ? new Date(value) : new Date();
-    if (Number.isFinite(parsed.getTime())) {
-        return parsed.toISOString();
-    }
-    return new Date().toISOString();
-}
-function stableHash(prefix, value) {
-    var normalized = typeof value === 'string'
-        ? cleanText(value, 12000)
-        : JSON.stringify(value || {});
-    var hash = 0;
-    for (var index = 0; index < normalized.length; index += 1) {
-        hash = ((hash << 5) - hash + normalized.charCodeAt(index)) | 0;
-    }
-    return "".concat(prefix, "-").concat(Math.abs(hash).toString(36) || '0');
-}
-function normalizeResolveIOAIManagerFailureClass(value) {
-    var normalized = cleanText(value, 80)
-        .toLowerCase()
-        .replace(/[\s-]+/g, '_');
-    if (!normalized) {
-        return 'unknown';
-    }
-    if (/^(qa_infra|infrastructure|harness|puppeteer|chrome|mongo|port|startup)$/.test(normalized)) {
-        return 'infra';
-    }
-    if (/^(build|compile|typescript|tsc|angular_build|ng_build)$/.test(normalized)) {
-        return 'compile';
-    }
-    if (/^(false_pass|route_only|missing_business_proof)$/.test(normalized)) {
-        return 'business';
-    }
-    return normalized.slice(0, 80);
-}
-function fingerprintResolveIOAIManagerBlocker(value) {
-    var normalized = cleanText(value, 4000)
-        .toLowerCase()
-        .replace(/[a-f0-9]{16,}/g, '<id>')
-        .replace(/\b\d{2,}\b/g, '<n>')
-        .replace(/\bline\s+<n>\b/g, 'line <n>')
-        .replace(/https?:\/\/\S+/g, '<url>')
-        .replace(/\s+/g, ' ')
-        .trim();
-    return stableHash('mgr-blocker', normalized);
-}
-function resolveResolveIOAIManagerBlockerFingerprint(record, fallback) {
-    var blockerText = cleanText((record === null || record === void 0 ? void 0 : record.blocker) || (record === null || record === void 0 ? void 0 : record.summary), 4000);
-    if (blockerText) {
-        return fingerprintResolveIOAIManagerBlocker(blockerText);
-    }
-    var explicit = cleanText(record === null || record === void 0 ? void 0 : record.blockerFingerprint, 120);
-    if (explicit) {
-        return explicit;
-    }
-    return fingerprintResolveIOAIManagerBlocker(fallback || '');
-}
-function hashResolveIOAIManagerEvidence(record) {
-    if (!record) {
-        return stableHash('mgr-evidence', '');
-    }
-    var explicit = cleanText(record.evidenceHash, 120);
-    if (explicit) {
-        return explicit;
-    }
-    return stableHash('mgr-evidence', {
-        failureClass: normalizeResolveIOAIManagerFailureClass(record.failureClass),
-        blocker: cleanText(record.blocker || record.summary, 2000),
-        changedFiles: cleanList(record.changedFiles, 80, 500).sort(),
-        artifactPaths: cleanList(record.artifactPaths, 80, 500).sort()
-    });
-}
-function buildResolveIOAIManagerRecoveryCheckpoint(input) {
-    var plan = input.plan;
-    var current = input.current || {};
-    var blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(current, plan.objective);
-    var evidenceHash = hashResolveIOAIManagerEvidence(current);
-    var changedFiles = cleanList(current.changedFiles, 80, 500);
-    var artifactPaths = cleanList(current.artifactPaths, 80, 500);
-    var previous = input.previousCheckpoint;
-    var sameCheckpointBase = previous
-        && previous.recoveryClass === plan.recoveryClass
-        && previous.lane === plan.lane
-        && previous.stepType === plan.stepType
-        && previous.blockerFingerprint === blockerFingerprint
-        && previous.evidenceHash === evidenceHash;
-    var attempts = sameCheckpointBase ? Math.max(0, Number(previous.attempts || 0)) + 1 : 1;
-    var status = plan.recoveryClass === 'manual_handoff'
-        ? 'manual_handoff'
-        : plan.recoveryClass === 'blocked_until_new_evidence'
-            ? 'parked'
-            : plan.recoveryClass === 'advance_after_proof'
-                ? 'complete'
-                : 'active';
-    var now = isoNow(input.now);
-    var checkpointId = stableHash('mgr-recovery', {
-        recoveryClass: plan.recoveryClass,
-        lane: plan.lane,
-        stepType: plan.stepType,
-        allowedAction: plan.allowedAction,
-        blockerFingerprint: blockerFingerprint,
-        evidenceHash: evidenceHash
-    });
-    return {
-        checkpointId: checkpointId,
-        recoveryClass: plan.recoveryClass,
-        status: status,
-        lane: plan.lane,
-        stepType: plan.stepType,
-        allowedAction: plan.allowedAction,
-        productRepairAllowed: plan.productRepairAllowed,
-        expensiveModelAllowed: plan.expensiveModelAllowed,
-        attempts: attempts,
-        maxAttemptsBeforePark: plan.maxAttemptsBeforePark,
-        blockerFingerprint: blockerFingerprint,
-        evidenceHash: evidenceHash,
-        changedFiles: changedFiles,
-        artifactPaths: artifactPaths,
-        requiredEvidence: cleanList(plan.requiredEvidence, 40, 500),
-        loopResetEvidence: cleanList(plan.loopResetEvidence, 40, 500),
-        forbiddenActions: cleanList(plan.forbiddenActions, 40, 500),
-        objective: cleanText(plan.objective, 1000),
-        nextActionLabel: cleanText(plan.nextActionLabel, 160),
-        createdAt: sameCheckpointBase && (previous === null || previous === void 0 ? void 0 : previous.createdAt) ? previous.createdAt : now,
-        updatedAt: now
-    };
-}
-function makeRecoveryEvidenceProbeStep(id, kind, label, objective, artifactExpectation, successSignal, options) {
-    if (options === void 0) { options = {}; }
-    return __assign(__assign({ id: id, kind: kind, label: label, objective: cleanText(objective, 1000), required: options.required !== false }, (options.commandHint ? { commandHint: cleanText(options.commandHint, 500) } : {})), { artifactExpectation: cleanText(artifactExpectation, 500), successSignal: cleanText(successSignal, 500) });
-}
-function recoveryEvidenceProbeStepsFor(checkpoint) {
-    var base = [
-        makeRecoveryEvidenceProbeStep('snapshot_current_blocker', 'rerun_same_gate', 'Snapshot Current Blocker', 'Capture the current blocker, failure class, evidence hash, changed files, and artifact paths before any new repair.', 'runner-evidence/current-blocker.json', 'Snapshot includes the same checkpointId, blockerFingerprint, and evidenceHashBefore.')
-    ];
-    if (checkpoint.recoveryClass === 'diagnosis_only' || checkpoint.recoveryClass === 'diagnosis_revision') {
-        return __spreadArray(__spreadArray([], __read(base), false), [
-            makeRecoveryEvidenceProbeStep('collect_read_only_root_cause_evidence', 'read_only_diagnosis', 'Collect Read-Only Root-Cause Evidence', checkpoint.recoveryClass === 'diagnosis_revision'
-                ? 'Collect new evidence that proves the current owner_files or failing_path is wrong before broadening scope.'
-                : 'Reproduce or classify the issue and record the exact customer complaint, expected result, observed result, route/module, and account context.', 'runner-evidence/diagnosis-readonly.md', 'Evidence supports one falsifiable accepted hypothesis and at least one rejected alternative.'),
-            makeRecoveryEvidenceProbeStep('validate_diagnosis_gate', 'read_only_diagnosis', 'Validate Diagnosis Gate', 'Validate issue_case, accepted_hypothesis, rejected_alternatives, failing_path, owner_files, and before/action/after proof_plan.', 'runner-evidence/diagnosis-gate.json', 'Diagnosis gate validates before product-code repair is allowed.')
-        ], false);
-    }
-    if (checkpoint.recoveryClass === 'infra_repair') {
-        return __spreadArray(__spreadArray([], __read(base), false), [
-            makeRecoveryEvidenceProbeStep('run_infra_preflight', 'infra_preflight', 'Run Infra Preflight', 'Check Puppeteer/Chrome, ports, Mongo/settings, cache state, startup commands, and server/client process health.', 'runner-evidence/infra-preflight.log', 'The same infra gate either passes or returns a new infra blocker hash.', { commandHint: 'runner preflight: puppeteer/chrome/mongo/ports/startup' })
-        ], false);
-    }
-    if (checkpoint.recoveryClass === 'compile_repair') {
-        return __spreadArray(__spreadArray([], __read(base), false), [
-            makeRecoveryEvidenceProbeStep('rerun_compile_gate', 'compile_check', 'Rerun Compile Gate', 'Rerun the same deterministic compile/build command and capture the first actionable error.', 'runner-evidence/compile.log', 'Compile passes or the first failing error changes.', { commandHint: 'same finite build/compile command from the failed gate' })
-        ], false);
-    }
-    if (checkpoint.recoveryClass === 'journey_contract_repair') {
-        return __spreadArray(__spreadArray([], __read(base), false), [
-            makeRecoveryEvidenceProbeStep('validate_journey_contract', 'journey_validation', 'Validate Journey Contract', 'Validate docs/APP_JOURNEY_CONTRACT.md has first/next/last workflow, route/action/method mapping, seeded data story, completion states, and QA assertions.', 'runner-evidence/journey-contract-validation.json', 'Journey contract validates before build tasks continue.'),
-            makeRecoveryEvidenceProbeStep('verify_hub_workflow_mapping', 'journey_validation', 'Verify Hub Workflow Mapping', 'Confirm the hub CTA and screen sequence implement the journey contract instead of link-only navigation.', 'runner-evidence/hub-workflow-map.json', 'Primary hub action maps to a real route/action/method/calculation and next state.')
-        ], false);
-    }
-    if (checkpoint.recoveryClass === 'business_proof_repair' || checkpoint.recoveryClass === 'product_code_repair') {
-        return __spreadArray(__spreadArray([], __read(base), false), [
-            makeRecoveryEvidenceProbeStep('rerun_business_assertion', 'business_assertion', 'Rerun Business Assertion', 'Run the exact issue/app promise proof and capture before/action/after DOM/data evidence.', 'runner-evidence/business-assertion.json', 'Business assertion passes, or the observed failure changes with a new artifact path.'),
-            makeRecoveryEvidenceProbeStep('check_diff_scope', 'diff_scope_check', 'Check Diff Scope', 'Compare changed files against the current diagnosis/journey owner scope before another code repair.', 'runner-evidence/diff-scope.json', 'Changed files are in scope, or diagnosis/journey scope is revised with evidence.')
-        ], false);
-    }
-    if (checkpoint.recoveryClass === 'release_repair') {
-        return __spreadArray(__spreadArray([], __read(base), false), [
-            makeRecoveryEvidenceProbeStep('collect_release_status', 'release_status', 'Collect Release Status', 'Collect publish/deploy/build-instance/domain/CloudFront status and the last actionable deploy error.', 'runner-evidence/release-status.json', 'Release gate passes or returns a new release blocker hash without product-code repair.')
-        ], false);
-    }
-    if (checkpoint.recoveryClass === 'manual_handoff') {
-        return __spreadArray(__spreadArray([], __read(base), false), [
-            makeRecoveryEvidenceProbeStep('operator_review_checkpoint', 'operator_review', 'Operator Review Checkpoint', 'Expose budget, blocker, evidence hash, and the minimum policy/scope change needed before another expensive loop.', 'runner-evidence/operator-review.json', 'Operator approves a new scope/policy or provides new external evidence.')
-        ], false);
-    }
-    return __spreadArray(__spreadArray([], __read(base), false), [
-        makeRecoveryEvidenceProbeStep('rerun_same_deterministic_gate', 'rerun_same_gate', 'Rerun Same Deterministic Gate', 'Rerun the exact failed check and capture new logs/artifacts without changing product code first.', 'runner-evidence/retry-gate.log', 'Gate passes, or evidenceHash/blockerFingerprint/artifactPaths change.')
-    ], false);
-}
-function buildResolveIOAIManagerRecoveryEvidenceProbe(input) {
-    var checkpoint = input.checkpoint;
-    var now = isoNow(input.now);
-    var steps = recoveryEvidenceProbeStepsFor(checkpoint);
-    var requiredArtifacts = Array.from(new Set(steps
-        .filter(function (step) { return step.required; })
-        .map(function (step) { return step.artifactExpectation; })
-        .filter(Boolean)));
-    return {
-        probeId: stableHash('mgr-probe', {
-            checkpointId: checkpoint.checkpointId,
-            recoveryClass: checkpoint.recoveryClass,
-            evidenceHash: checkpoint.evidenceHash,
-            blockerFingerprint: checkpoint.blockerFingerprint
-        }),
-        checkpointId: checkpoint.checkpointId,
-        recoveryClass: checkpoint.recoveryClass,
-        lane: checkpoint.lane,
-        stepType: checkpoint.stepType,
-        objective: checkpoint.status === 'parked'
-            ? 'Collect new evidence before any additional expensive model/code repair.'
-            : cleanText(checkpoint.objective, 1000),
-        evidenceOnly: checkpoint.status === 'parked'
-            || checkpoint.recoveryClass === 'diagnosis_only'
-            || checkpoint.recoveryClass === 'diagnosis_revision'
-            || checkpoint.recoveryClass === 'infra_repair'
-            || checkpoint.recoveryClass === 'compile_repair'
-            || checkpoint.recoveryClass === 'release_repair',
-        productRepairAllowed: checkpoint.productRepairAllowed && checkpoint.status !== 'parked',
-        expensiveModelAllowed: checkpoint.expensiveModelAllowed && checkpoint.status !== 'parked',
-        evidenceHashBefore: checkpoint.evidenceHash,
-        blockerFingerprint: checkpoint.blockerFingerprint,
-        steps: steps,
-        requiredArtifacts: requiredArtifacts,
-        acceptanceEvidence: Array.from(new Set(__spreadArray(__spreadArray(__spreadArray([], __read(checkpoint.requiredEvidence), false), __read(checkpoint.loopResetEvidence), false), __read(steps.map(function (step) { return step.successSignal; })), false).map(function (entry) { return cleanText(entry, 500); }).filter(Boolean))).slice(0, 30),
-        stopConditions: Array.from(new Set(__spreadArray(__spreadArray([], __read(checkpoint.forbiddenActions), false), [
-            'no new evidence hash',
-            'no new artifact path',
-            'product-code repair requested while evidenceOnly is true'
-        ], false).map(function (entry) { return cleanText(entry, 500); }).filter(Boolean))).slice(0, 30),
-        loopResetEvidence: checkpoint.loopResetEvidence,
-        createdAt: now
-    };
-}
-function recoveryAutomationModeFor(checkpoint) {
-    if (checkpoint.status === 'manual_handoff' || checkpoint.recoveryClass === 'manual_handoff') {
-        return 'manual_review';
-    }
-    if (checkpoint.status === 'complete' || checkpoint.recoveryClass === 'advance_after_proof') {
-        return 'advance';
-    }
-    if (checkpoint.status === 'parked' || checkpoint.recoveryClass === 'blocked_until_new_evidence') {
-        return 'collect_evidence';
-    }
-    if (checkpoint.recoveryClass === 'diagnosis_only' || checkpoint.recoveryClass === 'diagnosis_revision') {
-        return 'read_only_diagnosis';
-    }
-    if (checkpoint.recoveryClass === 'infra_repair') {
-        return 'repair_infra';
-    }
-    if (checkpoint.recoveryClass === 'compile_repair') {
-        return 'repair_compile';
-    }
-    if (checkpoint.recoveryClass === 'journey_contract_repair') {
-        return 'repair_journey_contract';
-    }
-    if (checkpoint.recoveryClass === 'business_proof_repair') {
-        return 'repair_business_assertion';
-    }
-    if (checkpoint.recoveryClass === 'release_repair') {
-        return 'repair_release';
-    }
-    if (checkpoint.recoveryClass === 'product_code_repair') {
-        return 'targeted_product_repair';
-    }
-    return 'continue_gate';
-}
-function recoveryActionLabelFor(mode, checkpoint) {
-    var explicit = cleanText(checkpoint.nextActionLabel, 120);
-    if (explicit && mode !== 'collect_evidence') {
-        return explicit;
-    }
-    var labels = {
-        advance: 'Advance To Next Gate',
-        collect_evidence: 'Collect New Evidence',
-        read_only_diagnosis: 'Run Diagnosis Evidence Pass',
-        repair_infra: 'Repair Infra Gate',
-        repair_compile: 'Repair Compile Gate',
-        repair_journey_contract: 'Repair Journey Contract',
-        repair_business_assertion: 'Repair Business Proof',
-        repair_release: 'Repair Release Gate',
-        targeted_product_repair: 'Run Targeted Repair',
-        manual_review: 'Manual Review',
-        continue_gate: 'Continue Current Gate'
-    };
-    return labels[mode];
-}
-function recoveryActionAutoRunnable(mode, probe) {
-    if (mode === 'manual_review') {
-        return false;
-    }
-    if (mode === 'advance' || mode === 'continue_gate') {
-        return true;
-    }
-    if (mode === 'targeted_product_repair' || mode === 'read_only_diagnosis' || mode === 'repair_journey_contract' || mode === 'repair_business_assertion') {
-        return true;
-    }
-    return probe.steps.some(function (step) { return step.commandHint || step.kind === 'rerun_same_gate' || step.kind === 'release_status' || step.kind === 'diff_scope_check'; });
-}
-function buildResolveIOAIManagerRecoveryActionPacket(input) {
-    var checkpoint = input.checkpoint;
-    var probe = input.probe || buildResolveIOAIManagerRecoveryEvidenceProbe({
-        checkpoint: checkpoint,
-        current: input.current,
-        now: input.now
-    });
-    var mode = recoveryAutomationModeFor(checkpoint);
-    var primaryStep = probe.steps.find(function (step) { return step.required && step.id !== 'snapshot_current_blocker'; })
-        || probe.steps.find(function (step) { return step.required; })
-        || probe.steps[0];
-    var evidenceOnly = probe.evidenceOnly || mode === 'collect_evidence' || mode === 'repair_infra' || mode === 'repair_compile' || mode === 'repair_release';
-    var requireNewEvidence = mode === 'collect_evidence'
-        || checkpoint.status === 'parked'
-        || checkpoint.attempts >= checkpoint.maxAttemptsBeforePark;
-    var stopWhen = Array.from(new Set(__spreadArray(__spreadArray([], __read(probe.stopConditions), false), __read((requireNewEvidence ? ['same blocker fingerprint and same evidence hash after probe'] : [])), false).map(function (entry) { return cleanText(entry, 500); }).filter(Boolean))).slice(0, 30);
-    var resetLoopWhen = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray([], __read(checkpoint.loopResetEvidence), false), __read(probe.loopResetEvidence), false), __read((requireNewEvidence ? [
-        'new material evidence: changed blocker, validated diagnosis/journey, business proof, compile/infra/release proof, or new actionable trace',
-        'weak hash-only evidence does not reset the loop'
-    ] : [])), false).map(function (entry) { return cleanText(entry, 500); }).filter(Boolean))).slice(0, 30);
-    var nextCommands = probe.steps
-        .map(function (step) { return cleanText(step.commandHint || "".concat(step.kind, ":").concat(step.id), 500); })
-        .filter(Boolean)
-        .slice(0, 12);
-    var releasePolicy = mode === 'repair_release'
-        ? buildResolveIOAIManagerHotfixFirstReleasePolicy({
-            surface: 'manager_recovery',
-            deployStatus: checkpoint.stepType,
-            publishStatus: checkpoint.lane
-        })
-        : undefined;
-    var now = isoNow(input.now);
-    return __assign(__assign(__assign({ actionId: stableHash('mgr-action', {
-            checkpointId: checkpoint.checkpointId,
-            probeId: probe.probeId,
-            mode: mode,
-            evidenceHash: checkpoint.evidenceHash,
-            blockerFingerprint: checkpoint.blockerFingerprint
-        }), checkpointId: checkpoint.checkpointId, probeId: probe.probeId, recoveryClass: checkpoint.recoveryClass, mode: mode, label: recoveryActionLabelFor(mode, checkpoint), lane: checkpoint.lane, stepType: checkpoint.stepType, primaryStepKind: (primaryStep === null || primaryStep === void 0 ? void 0 : primaryStep.kind) || 'none', objective: mode === 'collect_evidence'
-            ? probe.objective
-            : cleanText(checkpoint.objective || probe.objective, 1000), evidenceOnly: evidenceOnly, autoRunnable: recoveryActionAutoRunnable(mode, probe), productRepairAllowed: checkpoint.productRepairAllowed && !evidenceOnly && checkpoint.status !== 'parked', expensiveModelAllowed: checkpoint.expensiveModelAllowed && checkpoint.status !== 'parked', canResetLoopAfterEvidence: resetLoopWhen.length > 0, maxAttemptsBeforePark: checkpoint.maxAttemptsBeforePark, requiredArtifacts: probe.requiredArtifacts.slice(0, 20), nextCommands: releasePolicy
-            ? Array.from(new Set(__spreadArray(__spreadArray([], __read(nextCommands), false), __read(releasePolicy.allowedActions), false))).slice(0, 12)
-            : nextCommands, successCriteria: releasePolicy
-            ? Array.from(new Set(__spreadArray(__spreadArray([], __read(probe.acceptanceEvidence), false), __read(releasePolicy.requiredEvidence), false))).slice(0, 20)
-            : probe.acceptanceEvidence.slice(0, 20), retryPolicy: {
-            allowImmediateRetry: checkpoint.status !== 'parked' && mode !== 'manual_review',
-            requireNewEvidence: requireNewEvidence,
-            resetLoopWhen: resetLoopWhen,
-            stopWhen: stopWhen
-        } }, (releasePolicy ? { releasePolicy: releasePolicy } : {})), (mode === 'collect_evidence' ? { blockedReason: 'Manager parked this loop until the recovery action records new evidence.' } : {})), { createdAt: now });
-}
-function dispatchActionForMode(mode) {
-    var map = {
-        advance: 'advance',
-        collect_evidence: 'run_evidence_probe',
-        read_only_diagnosis: 'run_read_only_diagnosis',
-        repair_infra: 'run_infra_repair',
-        repair_compile: 'run_compile_repair',
-        repair_journey_contract: 'run_journey_contract_repair',
-        repair_business_assertion: 'run_business_assertion_repair',
-        repair_release: 'run_release_repair',
-        targeted_product_repair: 'run_targeted_product_repair',
-        manual_review: 'park_manual',
-        continue_gate: 'continue_gate'
-    };
-    return map[mode] || 'park_manual';
-}
-function buildRecoveryDispatchRecord(action, dispatchAction, status, reason, current, now) {
-    var evidenceHash = (current === null || current === void 0 ? void 0 : current.evidenceHash) || action.checkpointId || action.actionId;
-    var blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(current, action.objective);
-    var artifactPaths = cleanList(current === null || current === void 0 ? void 0 : current.artifactPaths, 20, 500);
-    var createdAt = isoNow(now);
-    return __assign(__assign(__assign({ dispatchId: stableHash('mgr-dispatch', {
-            actionId: action.actionId,
-            dispatchAction: dispatchAction,
-            evidenceHash: evidenceHash,
-            blockerFingerprint: blockerFingerprint,
-            status: status
-        }), actionId: action.actionId, checkpointId: action.checkpointId, probeId: action.probeId, mode: action.mode, dispatchAction: dispatchAction, status: status, evidenceHash: evidenceHash, blockerFingerprint: blockerFingerprint, productRepairAllowed: action.productRepairAllowed && dispatchAction === 'run_targeted_product_repair', expensiveModelAllowed: action.expensiveModelAllowed && dispatchAction !== 'run_evidence_probe', reason: reason, artifactPaths: artifactPaths }, (status === 'started' ? { startedAt: createdAt } : {})), (status === 'completed' ? { completedAt: createdAt } : {})), { createdAt: createdAt });
-}
-function decideResolveIOAIManagerRecoveryActionDispatch(input) {
-    var action = input.action;
-    var history = Array.isArray(input.history) ? input.history.filter(Boolean).slice(-50) : [];
-    var current = input.current || {};
-    if (!action) {
-        return {
-            dispatchAction: 'park_manual',
-            allowed: false,
-            reason: 'recovery_dispatch_missing_action',
-            status: 'parked',
-            canRunProductRepair: false,
-            canRunExpensiveModel: false,
-            shouldRecordDispatch: false,
-            requiresNewEvidence: true,
-            newEvidence: false
-        };
-    }
-    var dispatchAction = dispatchActionForMode(action.mode);
-    var evidenceHash = current.evidenceHash || action.checkpointId || action.actionId;
-    var blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(current, action.objective);
-    var sameActionHistory = history.filter(function (entry) { return entry.actionId === action.actionId; });
-    var sameEvidenceHistory = sameActionHistory.filter(function (entry) { return entry.evidenceHash === evidenceHash
-        && entry.blockerFingerprint === blockerFingerprint; });
-    var activeDispatch = sameEvidenceHistory.find(function (entry) { return entry.status === 'queued' || entry.status === 'started'; });
-    var completedDispatch = sameEvidenceHistory.find(function (entry) { return entry.status === 'completed' || entry.status === 'failed'; });
-    var newEvidence = sameActionHistory.length > 0 && sameEvidenceHistory.length === 0;
-    var requiresNewEvidence = action.retryPolicy.requireNewEvidence === true;
-    var manualOnly = action.mode === 'manual_review' || !action.autoRunnable;
-    var productDispatch = dispatchAction === 'run_targeted_product_repair';
-    var expensiveDispatch = !['run_evidence_probe', 'advance', 'continue_gate', 'park_manual'].includes(dispatchAction);
-    if (manualOnly && input.operatorApproved !== true) {
-        var record_1 = buildRecoveryDispatchRecord(action, 'park_manual', 'parked', 'recovery_dispatch_requires_manual_review', current, input.now);
-        return {
-            dispatchAction: 'park_manual',
-            allowed: false,
-            reason: record_1.reason,
-            status: 'parked',
-            canRunProductRepair: false,
-            canRunExpensiveModel: false,
-            shouldRecordDispatch: true,
-            requiresNewEvidence: requiresNewEvidence,
-            newEvidence: newEvidence,
-            dispatchRecord: record_1
-        };
-    }
-    if (productDispatch && action.productRepairAllowed !== true) {
-        var record_2 = buildRecoveryDispatchRecord(action, 'park_manual', 'parked', 'recovery_dispatch_product_repair_not_allowed', current, input.now);
-        return {
-            dispatchAction: 'park_manual',
-            allowed: false,
-            reason: record_2.reason,
-            status: 'parked',
-            canRunProductRepair: false,
-            canRunExpensiveModel: false,
-            shouldRecordDispatch: true,
-            requiresNewEvidence: true,
-            newEvidence: newEvidence,
-            dispatchRecord: record_2
-        };
-    }
-    if (activeDispatch) {
-        return {
-            dispatchAction: 'park_manual',
-            allowed: false,
-            reason: 'recovery_dispatch_already_running_for_same_evidence',
-            status: 'parked',
-            canRunProductRepair: false,
-            canRunExpensiveModel: false,
-            shouldRecordDispatch: false,
-            requiresNewEvidence: true,
-            newEvidence: false
-        };
-    }
-    if (completedDispatch && requiresNewEvidence && !newEvidence) {
-        var record_3 = buildRecoveryDispatchRecord(action, 'park_manual', 'parked', 'recovery_dispatch_same_evidence_already_attempted', current, input.now);
-        return {
-            dispatchAction: 'park_manual',
-            allowed: false,
-            reason: record_3.reason,
-            status: 'parked',
-            canRunProductRepair: false,
-            canRunExpensiveModel: false,
-            shouldRecordDispatch: true,
-            requiresNewEvidence: true,
-            newEvidence: false,
-            dispatchRecord: record_3
-        };
-    }
-    var status = dispatchAction === 'advance' || dispatchAction === 'continue_gate'
-        ? 'completed'
-        : 'started';
-    var record = buildRecoveryDispatchRecord(action, dispatchAction, status, 'recovery_dispatch_allowed', current, input.now);
-    return {
-        dispatchAction: dispatchAction,
-        allowed: true,
-        reason: 'recovery_dispatch_allowed',
-        status: status,
-        canRunProductRepair: productDispatch && action.productRepairAllowed === true,
-        canRunExpensiveModel: expensiveDispatch && action.expensiveModelAllowed === true,
-        shouldRecordDispatch: true,
-        requiresNewEvidence: requiresNewEvidence,
-        newEvidence: newEvidence,
-        dispatchRecord: record
-    };
-}
-function appendResolveIOAIManagerRecoveryActionDispatch(history, record, limit) {
-    if (limit === void 0) { limit = 50; }
-    var existing = Array.isArray(history) ? history.filter(Boolean) : [];
-    if (!record) {
-        return existing.slice(-limit);
-    }
-    var deduped = existing.filter(function (entry) { return entry.dispatchId !== record.dispatchId; });
-    return __spreadArray(__spreadArray([], __read(deduped), false), [record], false).slice(-limit);
-}
-function recoveryExecutionPhaseForDispatch(dispatchAction) {
-    var map = {
-        run_evidence_probe: 'evidence',
-        run_read_only_diagnosis: 'diagnosis',
-        run_infra_repair: 'infra',
-        run_compile_repair: 'compile',
-        run_journey_contract_repair: 'journey',
-        run_business_assertion_repair: 'business_proof',
-        run_release_repair: 'release',
-        run_targeted_product_repair: 'product_repair',
-        advance: 'advance',
-        continue_gate: 'advance',
-        park_manual: 'manual'
-    };
-    return map[dispatchAction] || 'manual';
-}
-function recoveryDirectiveReason(action, decision, current) {
-    var blocker = cleanText((current === null || current === void 0 ? void 0 : current.blocker) || (current === null || current === void 0 ? void 0 : current.summary) || '', 260);
-    var label = cleanText(action === null || action === void 0 ? void 0 : action.label, 120) || decision.dispatchAction;
-    var objective = cleanText(action === null || action === void 0 ? void 0 : action.objective, 260);
-    return [
-        "MANAGER_RECOVERY:".concat(decision.dispatchAction),
-        "label=".concat(label),
-        decision.reason ? "reason=".concat(decision.reason) : '',
-        blocker ? "blocker=".concat(blocker) : '',
-        objective ? "objective=".concat(objective) : ''
-    ].filter(Boolean).join(' | ');
-}
-function buildResolveIOAIManagerRecoveryExecutionDirective(input) {
-    var _a, _b, _c, _d, _e;
-    var action = input.action;
-    var dispatchDecision = input.dispatchDecision || decideResolveIOAIManagerRecoveryActionDispatch({
-        action: action,
-        current: input.current,
-        now: input.now
-    });
-    var dispatchAction = dispatchDecision.dispatchAction;
-    var now = isoNow(input.now);
-    var phase = recoveryExecutionPhaseForDispatch(dispatchAction);
-    var lane = cleanText((action === null || action === void 0 ? void 0 : action.lane) || ((_a = input.current) === null || _a === void 0 ? void 0 : _a.lane) || '', 120);
-    var stepType = cleanText((action === null || action === void 0 ? void 0 : action.stepType) || ((_b = input.current) === null || _b === void 0 ? void 0 : _b.stepType) || '', 120);
-    var rerunReason = recoveryDirectiveReason(action, dispatchDecision, input.current);
-    var surface = cleanText(input.surface || 'runner', 120);
-    return __assign(__assign(__assign({ directiveId: stableHash('mgr-directive', {
-            surface: surface,
-            actionId: (action === null || action === void 0 ? void 0 : action.actionId) || '',
-            dispatchAction: dispatchAction,
-            reason: dispatchDecision.reason,
-            evidenceHash: ((_c = dispatchDecision.dispatchRecord) === null || _c === void 0 ? void 0 : _c.evidenceHash) || ((_d = input.current) === null || _d === void 0 ? void 0 : _d.evidenceHash) || ''
-        }), surface: surface, dispatchAction: dispatchAction, phase: phase, allowed: dispatchDecision.allowed, status: dispatchDecision.status, reason: dispatchDecision.reason, lane: lane, stepType: stepType, nextActionLabel: cleanText(action === null || action === void 0 ? void 0 : action.label, 160) || dispatchAction, rerunReason: rerunReason, evidenceOnly: (action === null || action === void 0 ? void 0 : action.evidenceOnly) !== false || dispatchAction === 'run_evidence_probe', autoRunnable: (action === null || action === void 0 ? void 0 : action.autoRunnable) === true, productRepairAllowed: (action === null || action === void 0 ? void 0 : action.productRepairAllowed) === true, expensiveModelAllowed: (action === null || action === void 0 ? void 0 : action.expensiveModelAllowed) === true, canRunProductRepair: dispatchDecision.canRunProductRepair, canRunExpensiveModel: dispatchDecision.canRunExpensiveModel, canResetLoopAfterEvidence: (action === null || action === void 0 ? void 0 : action.canResetLoopAfterEvidence) === true, requiresNewEvidence: dispatchDecision.requiresNewEvidence, newEvidence: dispatchDecision.newEvidence, maxAttemptsBeforePark: Math.max(1, Number((action === null || action === void 0 ? void 0 : action.maxAttemptsBeforePark) || 1) || 1), requiredArtifacts: cleanList(action === null || action === void 0 ? void 0 : action.requiredArtifacts, 20, 500), nextCommands: cleanList(action === null || action === void 0 ? void 0 : action.nextCommands, 20, 500), successCriteria: cleanList(action === null || action === void 0 ? void 0 : action.successCriteria, 20, 500), forbiddenActions: (action === null || action === void 0 ? void 0 : action.productRepairAllowed) === true
-            ? []
-            : Array.from(new Set(__spreadArray([
-                'Do not run product-code repair from this directive unless canRunProductRepair is true.'
-            ], __read((((_e = action === null || action === void 0 ? void 0 : action.releasePolicy) === null || _e === void 0 ? void 0 : _e.forbiddenActions) || [])), false))).slice(0, 20) }, (dispatchDecision.dispatchRecord ? { dispatchRecord: dispatchDecision.dispatchRecord } : {})), ((action === null || action === void 0 ? void 0 : action.releasePolicy) ? { releasePolicy: action.releasePolicy } : {})), { createdAt: now });
-}
-function newListEntries(current, previous) {
-    var existing = new Set(previous.map(function (entry) { return cleanText(entry, 500); }).filter(Boolean));
-    return current
-        .map(function (entry) { return cleanText(entry, 500); })
-        .filter(function (entry) { return entry && !existing.has(entry); });
-}
-function recordLane(value) {
-    return cleanText(value === null || value === void 0 ? void 0 : value.lane, 80);
-}
-function recordStepType(value) {
-    return cleanText(value === null || value === void 0 ? void 0 : value.stepType, 80);
-}
-function recordFailureClass(value) {
-    var valueText = cleanText(value === null || value === void 0 ? void 0 : value.failureClass, 80);
-    return valueText ? normalizeResolveIOAIManagerFailureClass(valueText) : '';
-}
-function materialEvidenceText(record, paths) {
-    if (paths === void 0) { paths = []; }
-    return __spreadArray([
-        cleanText(record === null || record === void 0 ? void 0 : record.blocker, 1200),
-        cleanText(record === null || record === void 0 ? void 0 : record.summary, 1200)
-    ], __read(paths.map(function (path) { return cleanText(path, 500); })), false).filter(Boolean).join(' ').toLowerCase();
-}
-function hasMaterialEvidenceLanguage(text) {
-    return /(business|assertion|proof|before|after|dom|trace|stack|network|mongo|query|diff|scope|diagnosis|journey|contract|workflow|compile|build|preflight|infra|chrome|puppeteer|release|publish|deploy|sample|seed|route|auth|hydration|performance|slow|owner|root.?cause|repro|pdf|export|upload|import|filter|invoice|saved|calculated|comparison|report)/i.test(text);
-}
-function assessResolveIOAIManagerEvidenceChange(previous, current, fallbackObjective) {
-    var currentRecord = current || {};
-    var previousRecord = previous;
-    var previousEvidenceHash = previousRecord ? cleanText(previousRecord.evidenceHash, 160) || hashResolveIOAIManagerEvidence(previousRecord) : '';
-    var currentEvidenceHash = hashResolveIOAIManagerEvidence(currentRecord);
-    var previousBlockerFingerprint = previousRecord
-        ? cleanText(previousRecord.blockerFingerprint, 160) || resolveResolveIOAIManagerBlockerFingerprint(previousRecord, fallbackObjective)
-        : '';
-    var currentBlockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(currentRecord, fallbackObjective);
-    var previousChangedFiles = cleanList(previousRecord === null || previousRecord === void 0 ? void 0 : previousRecord.changedFiles, 80, 500);
-    var currentChangedFiles = cleanList(currentRecord.changedFiles, 80, 500);
-    var previousArtifactPaths = cleanList(previousRecord === null || previousRecord === void 0 ? void 0 : previousRecord.artifactPaths, 80, 500);
-    var currentArtifactPaths = cleanList(currentRecord.artifactPaths, 80, 500);
-    var addedChangedFiles = newListEntries(currentChangedFiles, previousChangedFiles);
-    var addedArtifactPaths = newListEntries(currentArtifactPaths, previousArtifactPaths);
-    var signals = [];
-    if (previousEvidenceHash && currentEvidenceHash !== previousEvidenceHash) {
-        signals.push('evidence_hash_changed');
-    }
-    if (previousBlockerFingerprint && currentBlockerFingerprint !== previousBlockerFingerprint) {
-        signals.push('blocker_fingerprint_changed');
-    }
-    if (recordLane(previousRecord) && recordLane(previousRecord) !== recordLane(currentRecord)) {
-        signals.push('lane_changed');
-    }
-    if (recordStepType(previousRecord) && recordStepType(previousRecord) !== recordStepType(currentRecord)) {
-        signals.push('step_type_changed');
-    }
-    if (recordFailureClass(previousRecord) && recordFailureClass(previousRecord) !== recordFailureClass(currentRecord)) {
-        signals.push('failure_class_changed');
-    }
-    if (addedChangedFiles.length) {
-        signals.push('changed_files_added');
-    }
-    if (addedArtifactPaths.length) {
-        signals.push('artifact_paths_added');
-    }
-    if (isPassingOutcome(currentRecord)) {
-        signals.push('passing_outcome');
-    }
-    var changed = signals.length > 0;
-    var evidenceText = materialEvidenceText(currentRecord, addedArtifactPaths);
-    var pathOrSummaryHasMaterialSignal = hasMaterialEvidenceLanguage(evidenceText);
-    var proof = signals.includes('passing_outcome');
-    var structuralChange = signals.some(function (signal) { return /blocker_fingerprint_changed|lane_changed|step_type_changed|failure_class_changed/.test(signal); });
-    var materialArtifact = addedArtifactPaths.length > 0 && pathOrSummaryHasMaterialSignal;
-    var materialChangedFiles = addedChangedFiles.length > 0
-        && /diagnosis|owner|scope|diff|root.?cause|failing path|stack|trace|business|proof|compile|release|deploy|workflow|journey/i.test(evidenceText);
-    var material = proof || structuralChange || materialArtifact || materialChangedFiles;
-    var strength = proof
-        ? 'proof'
-        : material
-            ? 'material'
-            : changed
-                ? 'weak'
-                : 'none';
-    return {
-        changed: changed,
-        material: material,
-        strength: strength,
-        signals: signals,
-        evidenceHash: currentEvidenceHash,
-        blockerFingerprint: currentBlockerFingerprint
-    };
-}
-function proposedActionIsProductRepair(value) {
-    var normalized = cleanText(value, 120);
-    return /product|code|repair|build|business|journey|workflow/i.test(normalized)
-        && !/infra|compile|diagnosis|manual|evidence|release|publish/i.test(normalized);
-}
-function decideResolveIOAIManagerRecoveryGate(input) {
-    var checkpoint = input.checkpoint;
-    var hasCurrent = !!input.current;
-    var current = input.current || {};
-    var assessment = hasCurrent
-        ? assessResolveIOAIManagerEvidenceChange(checkpoint, current, checkpoint.objective)
-        : {
-            changed: false,
-            material: false,
-            strength: 'none',
-            signals: [],
-            evidenceHash: checkpoint.evidenceHash,
-            blockerFingerprint: checkpoint.blockerFingerprint
-        };
-    var blockerFingerprint = assessment.blockerFingerprint;
-    var evidenceHash = assessment.evidenceHash;
-    var changedFiles = hasCurrent ? cleanList(current.changedFiles, 80, 500) : checkpoint.changedFiles;
-    var artifactPaths = hasCurrent ? cleanList(current.artifactPaths, 80, 500) : checkpoint.artifactPaths;
-    var evidenceChanged = assessment.changed;
-    var proposedAction = cleanText(input.proposedAction || checkpoint.allowedAction, 120);
-    var productRepairRequested = proposedActionIsProductRepair(proposedAction);
-    var missingEvidence = checkpoint.requiredEvidence.filter(function (required) {
-        var normalized = cleanText(required, 120).toLowerCase();
-        if (!normalized) {
-            return false;
-        }
-        if (/artifact|log|proof|gate|evidence/.test(normalized)) {
-            return !artifactPaths.length && !current.evidenceHash;
-        }
-        if (/diff|changed files|owner|scope|file/.test(normalized)) {
-            return !changedFiles.length;
-        }
-        return false;
-    });
-    var makeDecision = function (action, reason, overrides) {
-        if (overrides === void 0) { overrides = {}; }
-        return (__assign({ action: action, reason: reason, canRunProductRepair: checkpoint.productRepairAllowed, canRunExpensiveModel: checkpoint.expensiveModelAllowed, shouldResetLoopBudget: false, shouldIncrementAttempt: action === 'allow', newEvidence: evidenceChanged, materialEvidence: assessment.material, evidenceStrength: assessment.strength, evidenceSignals: assessment.signals, blockerFingerprint: blockerFingerprint, evidenceHash: evidenceHash, missingEvidence: missingEvidence, checkpoint: __assign(__assign({}, checkpoint), { updatedAt: isoNow(input.now) }) }, overrides));
-    };
-    if (checkpoint.status === 'complete') {
-        return makeDecision('complete', 'recovery_gate_checkpoint_already_complete', {
-            canRunProductRepair: false,
-            canRunExpensiveModel: false,
-            shouldIncrementAttempt: false
-        });
-    }
-    if (checkpoint.status === 'manual_handoff' && input.operatorApproved !== true) {
-        return makeDecision('manual_handoff', 'recovery_gate_manual_handoff_requires_operator_approval', {
-            canRunProductRepair: false,
-            canRunExpensiveModel: false,
-            shouldIncrementAttempt: false
-        });
-    }
-    if (productRepairRequested && !checkpoint.productRepairAllowed) {
-        return makeDecision('reject_action', 'recovery_gate_product_repair_not_allowed_for_checkpoint', {
-            canRunProductRepair: false,
-            canRunExpensiveModel: false,
-            shouldIncrementAttempt: false
-        });
-    }
-    if (checkpoint.status === 'parked' && !evidenceChanged) {
-        return makeDecision('collect_new_evidence', 'recovery_gate_parked_until_new_evidence', {
-            canRunProductRepair: false,
-            canRunExpensiveModel: false,
-            shouldIncrementAttempt: false
-        });
-    }
-    if (checkpoint.status === 'parked' && evidenceChanged && !assessment.material) {
-        return makeDecision('collect_new_evidence', 'recovery_gate_weak_evidence_requires_material_signal', {
-            canRunProductRepair: false,
-            canRunExpensiveModel: false,
-            shouldIncrementAttempt: false
-        });
-    }
-    if (checkpoint.attempts >= checkpoint.maxAttemptsBeforePark && !evidenceChanged) {
-        return makeDecision('collect_new_evidence', 'recovery_gate_attempt_limit_requires_new_evidence', {
-            canRunProductRepair: false,
-            canRunExpensiveModel: false,
-            shouldIncrementAttempt: false
-        });
-    }
-    if (checkpoint.attempts >= checkpoint.maxAttemptsBeforePark && evidenceChanged && !assessment.material) {
-        return makeDecision('collect_new_evidence', 'recovery_gate_attempt_limit_requires_material_evidence', {
-            canRunProductRepair: false,
-            canRunExpensiveModel: false,
-            shouldIncrementAttempt: false
-        });
-    }
-    if (evidenceChanged) {
-        var currentFailureClass = normalizeResolveIOAIManagerFailureClass(current.failureClass);
-        var currentCanRunProductRepair = checkpoint.productRepairAllowed
-            || !/^(infra|compile|diagnosis|release)$/i.test(currentFailureClass);
-        return makeDecision('allow', 'recovery_gate_new_material_evidence_unblocks_retry', {
-            canRunProductRepair: currentCanRunProductRepair,
-            canRunExpensiveModel: checkpoint.expensiveModelAllowed || currentCanRunProductRepair,
-            shouldResetLoopBudget: true
-        });
-    }
-    return makeDecision('allow', 'recovery_gate_action_allowed');
-}
-function failureKey(record) {
-    if (!record) {
-        return '';
-    }
-    var failureClass = normalizeResolveIOAIManagerFailureClass(record.failureClass);
-    var blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(record);
-    return "".concat(cleanText(record.lane, 80), ":").concat(cleanText(record.stepType, 80), ":").concat(failureClass, ":").concat(blockerFingerprint);
-}
-function failureEvidenceKey(record) {
-    return "".concat(failureKey(record), ":").concat(hashResolveIOAIManagerEvidence(record));
-}
-function isPassingOutcome(record) {
-    return /^(pass|accepted|ready_to_publish|published|ready_for_merge|complete|completed)$/i.test(cleanText(record === null || record === void 0 ? void 0 : record.outcome, 80));
-}
-function isManualOutcome(record) {
-    return /^(manual_handoff|park_manual|stopped)$/i.test(cleanText(record === null || record === void 0 ? void 0 : record.outcome, 80));
-}
-function buildResolveIOAIManagerRecoveryPlan(input) {
-    if (input === void 0) { input = {}; }
-    var action = cleanText(input.action, 80) || 'continue';
-    var reason = cleanText(input.reason, 240);
-    var failureClass = normalizeResolveIOAIManagerFailureClass(input.failureClass);
-    var lane = cleanText(input.lane, 80) || 'supervisor';
-    var stepType = cleanText(input.stepType, 80) || 'unknown';
-    var blocker = cleanText(input.blocker, 700);
-    var changedFiles = cleanList(input.changedFiles, 12, 240);
-    var artifactPaths = cleanList(input.artifactPaths, 12, 240);
-    var maxAttemptsBeforePark = Math.max(1, Number(input.maxSameFailureRepeats || 3) || 3);
-    var commonNotes = [
-        reason ? "policy_reason=".concat(reason) : '',
-        blocker ? "blocker=".concat(blocker) : '',
-        changedFiles.length ? "changed_files=".concat(changedFiles.join(', ')) : '',
-        artifactPaths.length ? "artifacts=".concat(artifactPaths.join(', ')) : ''
-    ].filter(Boolean);
-    var base = {
-        lane: lane,
-        stepType: stepType,
-        maxAttemptsBeforePark: maxAttemptsBeforePark,
-        notes: commonNotes
-    };
-    var makePlan = function (recoveryClass, nextActionLabel, objective, allowedAction, productRepairAllowed, expensiveModelAllowed, finiteSteps, requiredEvidence, loopResetEvidence, forbiddenActions) { return (__assign(__assign({}, base), { recoveryClass: recoveryClass, nextActionLabel: nextActionLabel, objective: objective, allowedAction: allowedAction, productRepairAllowed: productRepairAllowed, expensiveModelAllowed: expensiveModelAllowed, finiteSteps: finiteSteps, requiredEvidence: requiredEvidence, loopResetEvidence: loopResetEvidence, forbiddenActions: forbiddenActions })); };
-    if (action === 'reset_loop_budget') {
-        return makePlan('advance_after_proof', 'Advance After Proof', 'Checkpoint the passing evidence and move to the next required gate.', 'advance_to_next_gate', false, false, [
-            'Record the passing artifact, changed files, and gate result.',
-            'Reset the loop counter because a real gate passed.',
-            'Select the next unmet deterministic gate instead of repeating the previous repair.'
-        ], ['passing gate record', 'artifact or log proving the passed check'], ['new passing gate result', 'new business proof artifact'], ['rerun the same repair after a pass', 'mark accepted without the required downstream gate']);
-    }
-    if (action === 'manual_handoff') {
-        return makePlan('manual_handoff', 'Manual Review', 'Stop autonomous repair and expose the blocker, evidence, and last safe state.', 'manual_review_only', false, false, [
-            'Freeze further product-code edits.',
-            'Show the blocker fingerprint, evidence hash, and prior attempts.',
-            'Require a human edit to classification, scope, or retry policy before another model/code loop.'
-        ], ['blocker fingerprint', 'evidence hash', 'attempt history'], ['manual policy change', 'new external evidence'], ['start another automatic model repair', 'hide the failed evidence']);
-    }
-    if (action === 'budget_stop') {
-        return makePlan('manual_handoff', 'Budget Stop Review', 'Stop autonomous model/code loops until a cheaper scoped next action is selected.', 'budget_review_only', false, false, [
-            'Freeze further model repair loops.',
-            'Show the prompt/token/runtime budget that tripped the guard.',
-            'Select a cheaper deterministic gate, infra repair, diagnosis revision, or manual scope edit before resuming.'
-        ], ['budget guard reason', 'latest prompt estimate', 'last blocker/evidence hash'], ['manual scope reduction', 'new deterministic evidence', 'approved budget policy change'], ['start another broad model prompt', 'reset budget without new evidence', 'hide cost context']);
-    }
-    if (failureClass === 'diagnosis' || stepType === 'diagnosis_gate') {
-        return makePlan('diagnosis_only', 'Run Diagnosis Gate', 'Produce a falsifiable root-cause diagnosis before any repair.', 'read_only_diagnosis', false, true, [
-            'Reproduce or explicitly classify the customer issue.',
-            'Accept one falsifiable hypothesis and record rejected alternatives.',
-            'Identify the frontend/backend/shared failing path.',
-            'Select a small owner_files set.',
-            'Define exact before/action/after business proof.'
-        ], ['issue_case', 'accepted_hypothesis', 'rejected_alternatives', 'failing_path', 'owner_files', 'proof_plan'], ['new reproduction artifact', 'new query/log/code evidence', 'validated diagnosis gate'], ['edit product code', 'run broad repo repair', 'accept route-load evidence as success']);
-    }
-    if (failureClass === 'owner_scope' || failureClass === 'out_of_scope' || /out.?of.?scope|owner_files/i.test(reason)) {
-        return makePlan('diagnosis_revision', 'Revise Diagnosis Scope', 'Revise owner_files only when new evidence proves the current scope is wrong.', 'diagnosis_revision_only', false, true, [
-            'Compare changed files against the diagnosis owner_files.',
-            'Collect evidence proving why the new file is in the failing path.',
-            'Update accepted_hypothesis, failing_path, owner_files, and proof_plan together.',
-            'Resume repair only after the revised gate validates.'
-        ], ['out-of-scope file list', 'new failing-path evidence', 'revalidated diagnosis gate'], ['revised owner_files with evidence', 'new business proof requirement'], ['keep broad edits without diagnosis', 'add convenience refactors', 'continue repair outside owner_files']);
-    }
-    if (action === 'retry_infra') {
-        var isCompile = failureClass === 'compile';
-        return makePlan(isCompile ? 'compile_repair' : 'infra_repair', isCompile ? 'Repair Compile Gate' : 'Repair Infra Gate', isCompile
-            ? 'Fix the deterministic compile/build blocker before spending another product repair loop.'
-            : 'Fix the deterministic harness/browser/server/Mongo blocker before product repair.', isCompile ? 'compile_repair_only' : 'infra_repair_only', false, false, isCompile
-            ? [
-                'Read the exact compile/build log and identify the first actionable error.',
-                'Fix missing dependency, stale artifact, command, cache, or type wiring required by the compile gate.',
-                'Rerun the same finite compile command.',
-                'Return the compile log artifact and status.'
-            ]
-            : [
-                'Run preflight for Puppeteer, Chrome executable, ports, Mongo/settings, and startup command.',
-                'Repair only the failing harness/environment item.',
-                'Rerun the same infra check.',
-                'Return the infra log and pass/fail status.'
-            ], isCompile
-            ? ['compile command', 'compile log artifact', 'first failing error fixed or still failing']
-            : ['preflight command', 'infra log artifact', 'specific repaired environment item'], ['same check now passes', 'new infra/compile blocker hash'], ['run product-code model repair', 'count this as product failure', 'accept route/business success without the compile/infra gate']);
-    }
-    if (action === 'park_repeated_failure' || action === 'park_ping_pong') {
-        return makePlan('blocked_until_new_evidence', action === 'park_ping_pong' ? 'Park Ping-Pong Loop' : 'Park Repeated Failure', 'Stop the current loop until new evidence changes the diagnosis, route, or repair target.', 'collect_new_evidence_only', false, false, [
-            'Do not rerun the same prompt or same repair.',
-            'Show the repeated blocker and evidence hash.',
-            'Collect a new artifact: failing DOM state, stack trace, network response, Mongo delta, compile log, or revised diagnosis.',
-            'Reset the loop only after material evidence changes the blocker, proof, diagnosis, journey, or actionable trace.'
-        ], ['same failure count', 'blocker fingerprint', 'evidence hash'], ['changed blocker fingerprint', 'business/compile/infra/release proof artifact', 'revised diagnosis or journey contract', 'new actionable trace or data delta'], ['alternate between two failed patches', 'increase loop budget without evidence', 'hide the park reason']);
-    }
-    if (failureClass === 'journey') {
-        return makePlan('journey_contract_repair', 'Repair Journey Contract', 'Fix the first/next/last workflow contract before app code work continues.', 'journey_contract_repair', false, true, [
-            'Open docs/APP_JOURNEY_CONTRACT.md.',
-            'Define first_screen, north_star_workflow, screen_sequence, data_story, completion_states, and qa_assertions.',
-            'Ensure each CTA maps to an action, route, method, calculation, or state transition.',
-            'Validate that sample data can drive the promised workflow.'
-        ], ['validated journey_contract JSON', 'CTA-to-action mapping', 'workflow QA assertions'], ['journey validation passes', 'new workflow QA rows generated'], ['build empty routes', 'add link-only dashboard actions', 'defer workflow design to wow pass']);
-    }
-    if (failureClass === 'release') {
-        return makePlan('release_repair', 'Repair Release Gate', 'Repair deploy/publish/sample-data release evidence with a hotfix-first path before any repeated full deploy.', 'release_repair_only', false, false, [
-            'Read the deploy/publish/sample-data log.',
-            'Identify whether the blocker is domain, asset, seed data, route, permission, or CDN.',
-            'Prefer backend hotfix, release config, domain, cache, or seed-data repair when the product artifact already has business proof.',
-            'Rerun only the failed release gate.'
-        ], ['deploy or publish log', 'sample-data status', 'failed release gate rerun'], ['release gate passes', 'new release blocker hash'], ['change core workflow after business QA passed', 'mark accepted from scorecard only', 'rerun full builder loop', 'repeat deploy of same artifact without force_deploy evidence']);
-    }
-    if (failureClass === 'business' || failureClass === 'qa_evidence' || failureClass === 'route') {
-        return makePlan('business_proof_repair', 'Repair Business Proof', 'Fix the exact failing workflow assertion and prove before/action/after behavior.', 'business_repair', true, true, [
-            'Open the failing QA row or proof_plan.',
-            'Trace the UI action to method/publication/query/calculation.',
-            'Patch the smallest owner or workflow files.',
-            'Rerun only the failed business assertion.',
-            'Record DOM/data/Mongo/artifact proof.'
-        ], ['failing assertion', 'action trace', 'business proof artifact'], ['business assertion passes', 'new failed assertion with new evidence'], ['treat route load as success', 'rerun unrelated QA rows first', 'accept scorecard-only evidence']);
-    }
-    if (input.productRepairFailure !== false || failureClass === 'product_code') {
-        return makePlan('product_code_repair', 'Run Targeted Product Repair', 'Repair the current product-code blocker with the smallest scoped edit and immediate proof.', 'targeted_product_repair', true, true, [
-            'Inspect the current blocker, artifacts, changed files, and owner/workflow scope.',
-            'Form one small repair hypothesis.',
-            'Patch only files justified by the active diagnosis or journey contract.',
-            'Rerun the smallest failed gate.',
-            'Record new evidence before any additional loop.'
-        ], ['owner/workflow scope', 'repair diff', 'failed gate rerun artifact'], ['new evidence hash', 'same gate passes'], ['broad repo search-and-edit', 'rerun the same prompt without inspecting artifacts', 'change unrelated UI polish']);
-    }
-    return makePlan('continue', 'Continue Current Gate', 'Continue the current lane because no blocking loop or infra condition was detected.', 'continue', false, false, [
-        'Use the active lane memory.',
-        'Run the next finite gate.',
-        'Record artifacts and evidence hash.'
-    ], ['active lane memory', 'finite gate artifact'], ['new gate result', 'new artifact path'], ['spawn duplicate runners', 'advance without evidence']);
-}
-function collectOpenTail(records) {
-    var tail = [];
-    for (var index = records.length - 1; index >= 0; index -= 1) {
-        var record = records[index];
-        if (isPassingOutcome(record)) {
-            break;
-        }
-        tail.unshift(record);
-    }
-    return tail;
-}
-function countSameFailure(records, current) {
-    var currentKey = failureKey(current);
-    var count = 0;
-    for (var index = records.length - 1; index >= 0; index -= 1) {
-        var record = records[index];
-        if (isPassingOutcome(record)) {
-            break;
-        }
-        if (failureKey(record) !== currentKey) {
-            break;
-        }
-        count += 1;
-    }
-    return count;
-}
-function previousRecordForPolicy(history, current, currentWasExplicit) {
-    if (!history.length) {
-        return undefined;
-    }
-    if (!currentWasExplicit) {
-        return history.length > 1 ? history[history.length - 2] : undefined;
-    }
-    var last = history[history.length - 1];
-    if (failureEvidenceKey(last) === failureEvidenceKey(current)) {
-        return history.length > 1 ? history[history.length - 2] : undefined;
-    }
-    return last;
-}
-function countPingPong(records, current) {
-    var tail = collectOpenTail(records).filter(function (record) {
-        return cleanText(record.lane, 80) === cleanText(current.lane, 80)
-            && cleanText(record.stepType, 80) === cleanText(current.stepType, 80);
-    });
-    if (tail.length < 4) {
-        return 0;
-    }
-    var keys = tail.map(failureKey).filter(Boolean);
-    var last = keys.slice(-6);
-    if (last.length < 4) {
-        return 0;
-    }
-    var distinct = Array.from(new Set(last));
-    if (distinct.length !== 2) {
-        return 0;
-    }
-    for (var index = 2; index < last.length; index += 1) {
-        if (last[index] !== last[index - 2]) {
-            return 0;
-        }
-    }
-    return last.length - 1;
-}
-function decideResolveIOAIManagerPolicy(input) {
-    var history = Array.isArray(input.history) ? input.history : [];
-    var currentWasExplicit = !!input.current;
-    var current = input.current || history[history.length - 1] || {};
-    var failureClass = normalizeResolveIOAIManagerFailureClass(current.failureClass);
-    var blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(current);
-    var evidenceHash = hashResolveIOAIManagerEvidence(current);
-    var previous = previousRecordForPolicy(history, current, currentWasExplicit);
-    var previousSameFailure = previous && failureKey(previous) === failureKey(current);
-    var evidenceAssessment = previousSameFailure
-        ? assessResolveIOAIManagerEvidenceChange(previous, current)
-        : {
-            changed: false,
-            material: false,
-            strength: 'none',
-            signals: [],
-            evidenceHash: evidenceHash,
-            blockerFingerprint: blockerFingerprint
-        };
-    var newEvidence = !!previousSameFailure && evidenceAssessment.changed;
-    var sameFailureCount = countSameFailure(history, current);
-    var pingPongCount = countPingPong(history, current);
-    var maxSameFailureRepeats = Math.max(1, Number(input.maxSameFailureRepeats || 3) || 3);
-    var maxPingPongTransitions = Math.max(3, Number(input.maxPingPongTransitions || 3) || 3);
-    var infraClasses = new Set((input.infraFailureClasses || ['infra', 'compile']).map(normalizeResolveIOAIManagerFailureClass));
-    var ignoredClasses = new Set((input.ignoredFailureClasses || []).map(normalizeResolveIOAIManagerFailureClass));
-    var base = {
-        failureClass: failureClass,
-        blockerFingerprint: blockerFingerprint,
-        evidenceHash: evidenceHash,
-        sameFailureCount: sameFailureCount,
-        pingPongCount: pingPongCount,
-        newEvidence: newEvidence,
-        materialEvidence: evidenceAssessment.material,
-        evidenceStrength: evidenceAssessment.strength,
-        evidenceSignals: evidenceAssessment.signals,
-        loopBudgetShouldReset: false,
-        productRepairFailure: !infraClasses.has(failureClass) && !ignoredClasses.has(failureClass)
-    };
-    var withPlan = function (action, reason, overrides) {
-        if (overrides === void 0) { overrides = {}; }
-        var merged = __assign(__assign({}, base), overrides);
-        var recoveryPlan = buildResolveIOAIManagerRecoveryPlan({
-            action: action,
-            reason: reason,
-            failureClass: merged.failureClass,
-            lane: current.lane,
-            stepType: current.stepType,
-            blocker: current.blocker || current.summary,
-            sameFailureCount: merged.sameFailureCount,
-            pingPongCount: merged.pingPongCount,
-            newEvidence: merged.newEvidence,
-            productRepairFailure: merged.productRepairFailure,
-            changedFiles: current.changedFiles,
-            artifactPaths: current.artifactPaths,
-            maxSameFailureRepeats: maxSameFailureRepeats
-        });
-        var recoveryCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint({
-            plan: recoveryPlan,
-            current: current
-        });
-        var recoveryEvidenceProbe = buildResolveIOAIManagerRecoveryEvidenceProbe({
-            checkpoint: recoveryCheckpoint,
-            current: current
-        });
-        return __assign(__assign({}, merged), { action: action, reason: reason, recoveryPlan: recoveryPlan, recoveryCheckpoint: recoveryCheckpoint, recoveryEvidenceProbe: recoveryEvidenceProbe, recoveryAction: buildResolveIOAIManagerRecoveryActionPacket({
-                plan: recoveryPlan,
-                checkpoint: recoveryCheckpoint,
-                probe: recoveryEvidenceProbe,
-                current: current
-            }) });
-    };
-    if (isPassingOutcome(current)) {
-        return withPlan('reset_loop_budget', 'manager_policy_progress_passed', {
-            loopBudgetShouldReset: true,
-            productRepairFailure: false
-        });
-    }
-    if (isManualOutcome(current)) {
-        return withPlan('manual_handoff', 'manager_policy_manual_or_stopped');
-    }
-    if (pingPongCount >= maxPingPongTransitions) {
-        return withPlan('park_ping_pong', 'manager_policy_ping_pong_failure_loop');
-    }
-    if (sameFailureCount >= maxSameFailureRepeats && !evidenceAssessment.material) {
-        return withPlan('park_repeated_failure', newEvidence
-            ? 'manager_policy_same_failure_with_weak_evidence'
-            : 'manager_policy_same_failure_without_new_evidence');
-    }
-    if (infraClasses.has(failureClass)) {
-        return withPlan('retry_infra', 'manager_policy_infra_failure_routes_to_infra_repair', {
-            productRepairFailure: false
-        });
-    }
-    if (newEvidence || !previousSameFailure) {
-        if (newEvidence && !evidenceAssessment.material) {
-            return withPlan('continue', 'manager_policy_weak_evidence_does_not_reset_loop_budget');
-        }
-        return withPlan('continue', newEvidence
-            ? 'manager_policy_new_material_evidence_resets_loop_budget'
-            : 'manager_policy_new_failure_or_lane', {
-            loopBudgetShouldReset: true,
-            materialEvidence: newEvidence ? true : base.materialEvidence,
-            evidenceStrength: newEvidence ? evidenceAssessment.strength : base.evidenceStrength
-        });
-    }
-    return withPlan('continue', 'manager_policy_retry_below_repeat_limit');
-}
-function buildReplayDirectiveFromPlan(input) {
-    var checkpoint = buildResolveIOAIManagerRecoveryCheckpoint({
-        plan: input.plan,
-        current: input.current,
-        now: input.now
-    });
-    var probe = buildResolveIOAIManagerRecoveryEvidenceProbe({
-        checkpoint: checkpoint,
-        current: input.current,
-        now: input.now
-    });
-    var action = buildResolveIOAIManagerRecoveryActionPacket({
-        plan: input.plan,
-        checkpoint: checkpoint,
-        probe: probe,
-        current: input.current,
-        now: input.now
-    });
-    var dispatch = decideResolveIOAIManagerRecoveryActionDispatch({
-        action: action,
-        current: input.current,
-        now: input.now
-    });
-    return buildResolveIOAIManagerRecoveryExecutionDirective({
-        action: action,
-        dispatchDecision: dispatch,
-        current: input.current,
-        surface: input.surface,
-        now: input.now
-    });
-}
-function replayCaseFromDirective(input) {
-    var _a;
-    var directive = input.directive;
-    var safeAutoDispatch = isResolveIOAIManagerSafeAutoDispatch({
-        dispatchAction: directive.dispatchAction,
-        directive: directive,
-        includeJourneyContractRepair: input.expectedSafeAutoDispatch && directive.dispatchAction === 'run_journey_contract_repair',
-        includeReleaseRepair: input.expectedSafeAutoDispatch && directive.dispatchAction === 'run_release_repair',
-        includeProductRepair: false
-    });
-    return __assign(__assign({ caseId: input.caseId, surface: input.surface, pass: input.pass && safeAutoDispatch === input.expectedSafeAutoDispatch, action: input.action, reason: input.reason, recoveryClass: cleanText(((_a = directive.dispatchRecord) === null || _a === void 0 ? void 0 : _a.mode) || directive.phase, 120), dispatchAction: directive.dispatchAction, safeAutoDispatch: safeAutoDispatch, expectedSafeAutoDispatch: input.expectedSafeAutoDispatch, productRepairAllowed: directive.canRunProductRepair === true, loopBudgetShouldReset: input.loopBudgetShouldReset === true, materialEvidence: input.materialEvidence === true, evidenceStrength: input.evidenceStrength || 'none' }, (directive.releasePolicy ? {
-        hotfixFirst: directive.releasePolicy.policy === 'hotfix_first',
-        fullDeployAllowed: directive.releasePolicy.fullDeployAllowed
-    } : {})), { details: __assign({ phase: directive.phase, allowed: directive.allowed, reason: directive.reason, releasePolicy: directive.releasePolicy }, (input.details || {})) });
-}
-function buildResolveIOAIManagerRecoveryReplayMatrix(input) {
-    var _a, _b;
-    if (input === void 0) { input = {}; }
-    var surface = cleanText(input.surface || 'runner', 120);
-    var maxSameFailureRepeats = Math.max(1, Number(input.maxSameFailureRepeats || 2) || 2);
-    var includeReleaseRepair = input.includeReleaseRepair !== false;
-    var includeJourneyContractRepair = input.includeJourneyContractRepair !== false;
-    var cases = [];
-    var infraPolicy = decideResolveIOAIManagerPolicy({
-        history: [
-            { lane: 'qa', stepType: 'workflow_qa', outcome: 'needs_repair', failureClass: 'infra', blocker: 'Chrome executable missing.', evidenceHash: 'chrome-missing' }
-        ],
-        current: { lane: 'qa', stepType: 'workflow_qa', outcome: 'needs_repair', failureClass: 'infra', blocker: 'Chrome executable missing.', evidenceHash: 'chrome-missing' },
-        maxSameFailureRepeats: maxSameFailureRepeats
-    });
-    var infraDirective = buildResolveIOAIManagerRecoveryExecutionDirective({
-        action: infraPolicy.recoveryAction,
-        current: { lane: 'qa', stepType: 'workflow_qa', outcome: 'needs_repair', failureClass: 'infra', blocker: 'Chrome executable missing.', evidenceHash: 'chrome-missing' },
-        surface: surface
-    });
-    cases.push(replayCaseFromDirective({
-        caseId: 'infra_routes_to_infra_repair',
-        surface: surface,
-        action: infraPolicy.action,
-        reason: infraPolicy.reason,
-        directive: infraDirective,
-        expectedSafeAutoDispatch: true,
-        pass: infraPolicy.action === 'retry_infra'
-            && infraPolicy.recoveryPlan.recoveryClass === 'infra_repair'
-            && infraDirective.dispatchAction === 'run_infra_repair'
-            && infraDirective.canRunProductRepair === false,
-        details: { recoveryClass: infraPolicy.recoveryPlan.recoveryClass }
-    }));
-    var releasePlan = buildResolveIOAIManagerRecoveryPlan({
-        action: 'continue',
-        reason: 'publish failed after business proof',
-        failureClass: 'release',
-        lane: 'publish',
-        stepType: 'test_deploy',
-        blocker: 'Domain publish failed for the current artifact.'
-    });
-    var releaseCurrent = {
-        lane: 'publish',
-        stepType: 'test_deploy',
-        outcome: 'needs_repair',
-        failureClass: 'release',
-        blocker: 'Domain publish failed for the current artifact.',
-        evidenceHash: 'release-domain-publish-failed',
-        artifactPaths: ['runner-evidence/release-status.json']
-    };
-    var releaseDirective = buildReplayDirectiveFromPlan({
-        surface: surface,
-        plan: releasePlan,
-        current: releaseCurrent
-    });
-    cases.push(replayCaseFromDirective({
-        caseId: 'release_uses_hotfix_first_repair',
-        surface: surface,
-        action: 'continue',
-        reason: 'publish failed after business proof',
-        directive: releaseDirective,
-        expectedSafeAutoDispatch: includeReleaseRepair,
-        pass: releasePlan.recoveryClass === 'release_repair'
-            && releaseDirective.dispatchAction === 'run_release_repair'
-            && ((_a = releaseDirective.releasePolicy) === null || _a === void 0 ? void 0 : _a.policy) === 'hotfix_first'
-            && ((_b = releaseDirective.releasePolicy) === null || _b === void 0 ? void 0 : _b.fullDeployAllowed) === false
-            && releaseDirective.canRunProductRepair === false,
-        details: { recoveryClass: releasePlan.recoveryClass }
-    }));
-    var journeyPlan = buildResolveIOAIManagerRecoveryPlan({
-        action: 'continue',
-        reason: 'journey contract missing first next last',
-        failureClass: 'journey',
-        lane: 'plan',
-        stepType: 'journey_contract',
-        blocker: 'Journey contract does not map the hub CTA to an action.'
-    });
-    var journeyDirective = buildReplayDirectiveFromPlan({
-        surface: surface,
-        plan: journeyPlan,
-        current: {
-            lane: 'plan',
-            stepType: 'journey_contract',
-            outcome: 'needs_repair',
-            failureClass: 'journey',
-            blocker: 'Journey contract does not map the hub CTA to an action.',
-            evidenceHash: 'journey-contract-invalid'
-        }
-    });
-    cases.push(replayCaseFromDirective({
-        caseId: 'journey_repair_is_safe_only_for_aicoder_surfaces',
-        surface: surface,
-        action: 'continue',
-        reason: 'journey contract missing first next last',
-        directive: journeyDirective,
-        expectedSafeAutoDispatch: includeJourneyContractRepair,
-        pass: journeyPlan.recoveryClass === 'journey_contract_repair'
-            && journeyDirective.dispatchAction === 'run_journey_contract_repair'
-            && journeyDirective.canRunProductRepair === false,
-        details: { recoveryClass: journeyPlan.recoveryClass }
-    }));
-    var weakPolicy = decideResolveIOAIManagerPolicy({
-        history: [
-            { lane: 'repair', stepType: 'repair', outcome: 'needs_repair', failureClass: 'product_code', blocker: 'Save action still throws TypeError.', evidenceHash: 'save-before' },
-            { lane: 'repair', stepType: 'repair', outcome: 'needs_repair', failureClass: 'product_code', blocker: 'Save action still throws TypeError.', evidenceHash: 'renamed-hash-only' }
-        ],
-        current: { lane: 'repair', stepType: 'repair', outcome: 'needs_repair', failureClass: 'product_code', blocker: 'Save action still throws TypeError.', evidenceHash: 'renamed-hash-only' },
-        maxSameFailureRepeats: maxSameFailureRepeats
-    });
-    var weakDirective = buildResolveIOAIManagerRecoveryExecutionDirective({
-        action: weakPolicy.recoveryAction,
-        current: { lane: 'repair', stepType: 'repair', outcome: 'needs_repair', failureClass: 'product_code', blocker: 'Save action still throws TypeError.', evidenceHash: 'renamed-hash-only' },
-        surface: surface
-    });
-    cases.push(replayCaseFromDirective({
-        caseId: 'weak_hash_only_evidence_stays_parked',
-        surface: surface,
-        action: weakPolicy.action,
-        reason: weakPolicy.reason,
-        directive: weakDirective,
-        expectedSafeAutoDispatch: true,
-        pass: weakPolicy.action === 'park_repeated_failure'
-            && weakPolicy.materialEvidence === false
-            && weakPolicy.loopBudgetShouldReset === false
-            && weakDirective.dispatchAction === 'run_evidence_probe',
-        loopBudgetShouldReset: weakPolicy.loopBudgetShouldReset,
-        materialEvidence: weakPolicy.materialEvidence,
-        evidenceStrength: weakPolicy.evidenceStrength,
-        details: { evidenceSignals: weakPolicy.evidenceSignals }
-    }));
-    var materialPolicy = decideResolveIOAIManagerPolicy({
-        history: [
-            { lane: 'repair', stepType: 'repair', outcome: 'needs_repair', failureClass: 'product_code', blocker: 'Save action still throws TypeError.', evidenceHash: 'save-before', artifactPaths: ['qa/save-before.log'] },
-            {
-                lane: 'repair',
-                stepType: 'repair',
-                outcome: 'needs_repair',
-                failureClass: 'product_code',
-                blocker: 'Save action still throws TypeError.',
-                summary: 'New DOM trace proves the click reaches the method with an undefined id.',
-                evidenceHash: 'save-dom-trace',
-                artifactPaths: ['qa/save-before.log', 'qa/save-dom-trace.json']
-            }
-        ],
-        current: {
-            lane: 'repair',
-            stepType: 'repair',
-            outcome: 'needs_repair',
-            failureClass: 'product_code',
-            blocker: 'Save action still throws TypeError.',
-            summary: 'New DOM trace proves the click reaches the method with an undefined id.',
-            evidenceHash: 'save-dom-trace',
-            artifactPaths: ['qa/save-before.log', 'qa/save-dom-trace.json']
-        },
-        maxSameFailureRepeats: maxSameFailureRepeats
-    });
-    cases.push({
-        caseId: 'material_evidence_resets_loop_budget',
-        surface: surface,
-        pass: materialPolicy.action === 'continue'
-            && materialPolicy.materialEvidence === true
-            && materialPolicy.loopBudgetShouldReset === true,
-        action: materialPolicy.action,
-        reason: materialPolicy.reason,
-        recoveryClass: materialPolicy.recoveryPlan.recoveryClass,
-        dispatchAction: materialPolicy.recoveryAction.mode,
-        safeAutoDispatch: false,
-        expectedSafeAutoDispatch: false,
-        productRepairAllowed: materialPolicy.recoveryAction.productRepairAllowed,
-        loopBudgetShouldReset: materialPolicy.loopBudgetShouldReset,
-        materialEvidence: materialPolicy.materialEvidence,
-        evidenceStrength: materialPolicy.evidenceStrength,
-        details: { evidenceSignals: materialPolicy.evidenceSignals }
-    });
-    var productPlan = buildResolveIOAIManagerRecoveryPlan({
-        action: 'continue',
-        reason: 'business proof still failing',
-        failureClass: 'product_code',
-        lane: 'repair',
-        stepType: 'repair',
-        blocker: 'Save action still throws TypeError.',
-        productRepairFailure: true
-    });
-    var productDirective = buildReplayDirectiveFromPlan({
-        surface: surface,
-        plan: productPlan,
-        current: {
-            lane: 'repair',
-            stepType: 'repair',
-            outcome: 'needs_repair',
-            failureClass: 'product_code',
-            blocker: 'Save action still throws TypeError.',
-            evidenceHash: 'save-product-repair'
-        }
-    });
-    var productSafe = isResolveIOAIManagerSafeAutoDispatch({
-        dispatchAction: productDirective.dispatchAction,
-        directive: productDirective,
-        includeProductRepair: input.includeProductRepair === true
-    });
-    cases.push({
-        caseId: 'product_repair_requires_explicit_operator_policy',
-        surface: surface,
-        pass: productPlan.recoveryClass === 'product_code_repair'
-            && productDirective.dispatchAction === 'run_targeted_product_repair'
-            && productSafe === false,
-        action: 'continue',
-        reason: 'business proof still failing',
-        recoveryClass: productPlan.recoveryClass,
-        dispatchAction: productDirective.dispatchAction,
-        safeAutoDispatch: productSafe,
-        expectedSafeAutoDispatch: false,
-        productRepairAllowed: productDirective.canRunProductRepair,
-        loopBudgetShouldReset: false,
-        materialEvidence: false,
-        evidenceStrength: 'none',
-        details: { phase: productDirective.phase, allowed: productDirective.allowed }
-    });
-    var duplicateReleasePolicy = buildResolveIOAIManagerHotfixFirstReleasePolicy({
-        surface: surface,
-        deployFingerprint: "".concat(surface, "-artifact-sha"),
-        lastDeployFingerprint: "".concat(surface, "-artifact-sha"),
-        deployStatus: 'completed',
-        publishStatus: 'published'
-    });
-    cases.push({
-        caseId: 'duplicate_release_fingerprint_blocks_full_deploy',
-        surface: surface,
-        pass: duplicateReleasePolicy.recommendedAction === 'block_duplicate_deploy'
-            && duplicateReleasePolicy.duplicateDeployBlocked === true
-            && duplicateReleasePolicy.fullDeployAllowed === false,
-        action: duplicateReleasePolicy.recommendedAction,
-        reason: duplicateReleasePolicy.reason,
-        recoveryClass: 'release_repair',
-        dispatchAction: 'run_release_repair',
-        safeAutoDispatch: includeReleaseRepair,
-        expectedSafeAutoDispatch: includeReleaseRepair,
-        productRepairAllowed: false,
-        loopBudgetShouldReset: false,
-        materialEvidence: false,
-        evidenceStrength: 'none',
-        hotfixFirst: true,
-        fullDeployAllowed: duplicateReleasePolicy.fullDeployAllowed,
-        details: { releasePolicy: duplicateReleasePolicy }
-    });
-    return cases;
-}
-
-//# sourceMappingURL=ai-runner-manager-policy.js.map