@resolveio/server-lib 22.3.145 → 22.3.146

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

@@ -47,6 +47,8 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     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;
@@ -56,9 +58,11 @@ exports.buildResolveIOAIManagerRecoveryActionPacket = buildResolveIOAIManagerRec
 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);
@@ -92,6 +96,292 @@ function cleanList(values, limit, max) {
     }
     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 === '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' : 'Hotfix Release Artifact',
+        recommendedChannel: 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',
+            '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 fingerprintMatchesLast = !!deployFingerprint && !!lastDeployFingerprint && deployFingerprint === lastDeployFingerprint;
+    var releaseBlocked = [deployStatus, publishStatus, sampleDataStatus].some(releaseStatusIsBlocked);
+    var duplicateDeployBlocked = fingerprintMatchesLast
+        && input.forceDeploy !== true
+        && releaseStatusIsTerminalDeploy([deployStatus, publishStatus].filter(Boolean).join(' '));
+    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 (fingerprintMatchesLast && input.forceDeploy === true) {
+        recommendedAction = 'review_force_deploy';
+        label = 'Review Force Deploy';
+        reason = '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,
+        forceDeployRequiredToRepeat: true,
+        statuses: {
+            deploy: deployStatus,
+            publish: publishStatus,
+            sampleData: sampleDataStatus
+        },
+        fingerprints: {
+            current: deployFingerprint,
+            last: lastDeployFingerprint,
+            matchesLast: fingerprintMatchesLast
+        },
+        hotfixPlan: hotfixPlan,
+        allowedActions: allowedActions,
+        forbiddenActions: [
+            'rerun full builder loop for a release-only blocker',
+            'queue duplicate deploy without force_deploy 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',
+            'hotfix/config/seed/domain change evidence when no new product artifact is needed',
+            'force_deploy 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();
@@ -399,13 +689,23 @@ function buildResolveIOAIManagerRecoveryActionPacket(input) {
         || 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 ? ['changed evidence hash', 'new artifact path'] : [])), 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({ actionId: stableHash('mgr-action', {
+    return __assign(__assign(__assign({ actionId: stableHash('mgr-action', {
             checkpointId: checkpoint.checkpointId,
             probeId: probe.probeId,
             mode: mode,
@@ -413,12 +713,16 @@ function buildResolveIOAIManagerRecoveryActionPacket(input) {
             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: nextCommands, successCriteria: probe.acceptanceEvidence.slice(0, 20), retryPolicy: {
+            : 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
-        } }, (mode === 'collect_evidence' ? { blockedReason: 'Manager parked this loop until the recovery action records new evidence.' } : {})), { createdAt: now });
+        } }, (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 = {
@@ -592,7 +896,7 @@ function recoveryDirectiveReason(action, decision, current) {
     ].filter(Boolean).join(' | ');
 }
 function buildResolveIOAIManagerRecoveryExecutionDirective(input) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     var action = input.action;
     var dispatchDecision = input.dispatchDecision || decideResolveIOAIManagerRecoveryActionDispatch({
         action: action,
@@ -606,7 +910,7 @@ function buildResolveIOAIManagerRecoveryExecutionDirective(input) {
     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({ directiveId: stableHash('mgr-directive', {
+    return __assign(__assign(__assign({ directiveId: stableHash('mgr-directive', {
             surface: surface,
             actionId: (action === null || action === void 0 ? void 0 : action.actionId) || '',
             dispatchAction: dispatchAction,
@@ -614,14 +918,100 @@ function buildResolveIOAIManagerRecoveryExecutionDirective(input) {
             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
             ? []
-            : ['Do not run product-code repair from this directive unless canRunProductRepair is true.'] }, (dispatchDecision.dispatchRecord ? { dispatchRecord: dispatchDecision.dispatchRecord } : {})), { createdAt: now });
+            : 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 listHasNewEntry(current, previous) {
+function newListEntries(current, previous) {
     var existing = new Set(previous.map(function (entry) { return cleanText(entry, 500); }).filter(Boolean));
-    return current.some(function (entry) {
-        var normalized = cleanText(entry, 500);
-        return !!normalized && !existing.has(normalized);
-    });
+    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);
@@ -632,16 +1022,21 @@ function decideResolveIOAIManagerRecoveryGate(input) {
     var checkpoint = input.checkpoint;
     var hasCurrent = !!input.current;
     var current = input.current || {};
-    var blockerFingerprint = hasCurrent
-        ? resolveResolveIOAIManagerBlockerFingerprint(current, checkpoint.objective)
-        : checkpoint.blockerFingerprint;
-    var evidenceHash = hasCurrent ? hashResolveIOAIManagerEvidence(current) : checkpoint.evidenceHash;
+    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 = evidenceHash !== checkpoint.evidenceHash
-        || blockerFingerprint !== checkpoint.blockerFingerprint
-        || listHasNewEntry(changedFiles, checkpoint.changedFiles)
-        || listHasNewEntry(artifactPaths, 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) {
@@ -659,7 +1054,7 @@ function decideResolveIOAIManagerRecoveryGate(input) {
     });
     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, blockerFingerprint: blockerFingerprint, evidenceHash: evidenceHash, missingEvidence: missingEvidence, checkpoint: __assign(__assign({}, checkpoint), { updatedAt: isoNow(input.now) }) }, 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', {
@@ -689,6 +1084,13 @@ function decideResolveIOAIManagerRecoveryGate(input) {
             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,
@@ -696,11 +1098,18 @@ function decideResolveIOAIManagerRecoveryGate(input) {
             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_evidence_unblocks_retry', {
+        return makeDecision('allow', 'recovery_gate_new_material_evidence_unblocks_retry', {
             canRunProductRepair: currentCanRunProductRepair,
             canRunExpensiveModel: checkpoint.expensiveModelAllowed || currentCanRunProductRepair,
             shouldResetLoopBudget: true
@@ -812,8 +1221,8 @@ function buildResolveIOAIManagerRecoveryPlan(input) {
             '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 the new evidence hash changes.'
-        ], ['same failure count', 'blocker fingerprint', 'evidence hash'], ['changed evidence hash', 'new artifact path', 'revised diagnosis or journey contract'], ['alternate between two failed patches', 'increase loop budget without evidence', 'hide the park reason']);
+            '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, [
@@ -824,12 +1233,12 @@ function buildResolveIOAIManagerRecoveryPlan(input) {
         ], ['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 without rewriting working app flow.', 'release_repair_only', false, false, [
+        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.',
-            'Repair the release artifact/config/seed issue.',
+            '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']);
+        ], ['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, [
@@ -867,20 +1276,33 @@ function collectOpenTail(records) {
     return tail;
 }
 function countSameFailure(records, current) {
-    var currentKey = failureEvidenceKey(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 (failureEvidenceKey(record) !== currentKey) {
+        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)
@@ -907,14 +1329,24 @@ function countPingPong(records, current) {
 }
 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 = history.length > 1 ? history[history.length - 2] : undefined;
+    var previous = previousRecordForPolicy(history, current, currentWasExplicit);
     var previousSameFailure = previous && failureKey(previous) === failureKey(current);
-    var previousEvidenceHash = previousSameFailure ? hashResolveIOAIManagerEvidence(previous) : '';
-    var newEvidence = !!previousSameFailure && !!previousEvidenceHash && previousEvidenceHash !== evidenceHash;
+    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);
@@ -928,6 +1360,9 @@ function decideResolveIOAIManagerPolicy(input) {
         sameFailureCount: sameFailureCount,
         pingPongCount: pingPongCount,
         newEvidence: newEvidence,
+        materialEvidence: evidenceAssessment.material,
+        evidenceStrength: evidenceAssessment.strength,
+        evidenceSignals: evidenceAssessment.signals,
         loopBudgetShouldReset: false,
         productRepairFailure: !infraClasses.has(failureClass) && !ignoredClasses.has(failureClass)
     };
@@ -976,8 +1411,10 @@ function decideResolveIOAIManagerPolicy(input) {
     if (pingPongCount >= maxPingPongTransitions) {
         return withPlan('park_ping_pong', 'manager_policy_ping_pong_failure_loop');
     }
-    if (sameFailureCount >= maxSameFailureRepeats && !newEvidence) {
-        return withPlan('park_repeated_failure', 'manager_policy_same_failure_without_new_evidence');
+    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', {
@@ -985,13 +1422,311 @@ function decideResolveIOAIManagerPolicy(input) {
         });
     }
     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_evidence_resets_loop_budget'
+            ? 'manager_policy_new_material_evidence_resets_loop_budget'
             : 'manager_policy_new_failure_or_lane', {
-            loopBudgetShouldReset: true
+            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