@resolveio/server-lib 22.3.176 → 22.3.178

package/tests/ai-manager-recovery-checkpoint.test.ts

@@ -1,1136 +0,0 @@
-import * as assert from 'node:assert/strict';
-import {
-	buildResolveIOAIManagerHotfixEvidenceRecord,
-	buildResolveIOAIManagerRecoveryCheckpoint,
-	buildResolveIOAIManagerRecoveryActionPacket,
-	buildResolveIOAIManagerRecoveryEvidenceProbe,
-	buildResolveIOAIManagerRecoveryPlan,
-	appendResolveIOAIManagerRecoveryActionDispatch,
-	buildResolveIOAIManagerRecoveryExecutionDirective,
-	buildResolveIOAIManagerHotfixFirstReleasePolicy,
-	buildResolveIOAIManagerRecoveryReplayMatrix,
-	decideResolveIOAIManagerAutonomyPolicy,
-	decideResolveIOAIManagerHotfixCommitGuard,
-	decideResolveIOAIManagerHotfixContinuation,
-	decideResolveIOAIManagerRecoveryActionDispatch,
-	decideResolveIOAIManagerRecoveryGate,
-	decideResolveIOAIManagerPolicy,
-	estimateResolveIOAIManagerRetryExpectedValue,
-	evaluateResolveIOAIManagerHotfixGitProof,
-	isResolveIOAIManagerSafeAutoDispatch,
-	validateResolveIOAIManagerHotfixEvidence
-} from '../src/util/ai-runner-manager-policy';
-import { buildResolveIOAIManagerAutopilotSnapshot } from '../src/util/ai-runner-manager-autopilot';
-
-const parkedPlan = buildResolveIOAIManagerRecoveryPlan({
-	action: 'park_repeated_failure',
-	reason: 'same blocker repeated without new proof',
-	failureClass: 'product_code',
-	lane: 'repair',
-	stepType: 'repair',
-	blocker: 'Save action still throws TypeError.',
-	artifactPaths: ['qa/save-before.log'],
-	maxSameFailureRepeats: 2,
-	productRepairFailure: true
-});
-
-const parkedCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint({
-	plan: parkedPlan,
-	current: {
-		lane: 'repair',
-		stepType: 'repair',
-		failureClass: 'product_code',
-		blocker: 'Save action still throws TypeError.',
-		evidenceHash: 'save-typeerror-before',
-		artifactPaths: ['qa/save-before.log']
-	},
-	now: '2026-06-15T00:00:00.000Z'
-});
-
-assert.equal(parkedCheckpoint.status, 'parked');
-assert.equal(parkedCheckpoint.recoveryClass, 'blocked_until_new_evidence');
-assert.equal(parkedCheckpoint.allowedAction, 'collect_new_evidence_only');
-
-const parkedEvidenceProbe = buildResolveIOAIManagerRecoveryEvidenceProbe({
-	checkpoint: parkedCheckpoint
-});
-const parkedAction = buildResolveIOAIManagerRecoveryActionPacket({
-	checkpoint: parkedCheckpoint,
-	probe: parkedEvidenceProbe
-});
-
-assert.equal(parkedEvidenceProbe.evidenceOnly, true);
-assert.equal(parkedEvidenceProbe.productRepairAllowed, false);
-assert.equal(parkedEvidenceProbe.expensiveModelAllowed, false);
-assert.ok(parkedEvidenceProbe.steps.some((step) => step.kind === 'rerun_same_gate'));
-assert.ok(parkedEvidenceProbe.stopConditions.some((entry) => /product-code repair/i.test(entry)));
-assert.equal(parkedAction.mode, 'collect_evidence');
-assert.equal(parkedAction.singleActionOnly, true);
-assert.equal(parkedAction.allowedDispatchAction, 'run_evidence_probe');
-assert.equal(parkedAction.evidenceOnly, true);
-assert.equal(parkedAction.productRepairAllowed, false);
-assert.equal(parkedAction.costCeilingUsd, 0.25);
-assert.equal(parkedAction.proofRequiredBeforeContinuation, true);
-assert.ok(/blockerFingerprint|evidenceHash/i.test(parkedAction.requiredStateTransition));
-assert.ok(parkedAction.exitCriteria.some((entry) => /do not continue runner until required proof artifact/i.test(entry)));
-assert.equal(parkedAction.retryPolicy.requireNewEvidence, true);
-assert.ok(parkedAction.nextCommands.some((command) => /rerun_same_gate|snapshot_current_blocker/i.test(command)));
-
-const parkedCurrent = {
-	lane: 'repair',
-	stepType: 'repair',
-	failureClass: 'product_code',
-	blocker: 'Save action still throws TypeError.',
-	blockerFingerprint: parkedCheckpoint.blockerFingerprint,
-	evidenceHash: parkedCheckpoint.evidenceHash,
-	artifactPaths: ['qa/save-before.log']
-};
-const parkedFirstDispatch = decideResolveIOAIManagerRecoveryActionDispatch({
-	action: parkedAction,
-	current: parkedCurrent
-});
-const parkedDispatchHistory = appendResolveIOAIManagerRecoveryActionDispatch([], parkedFirstDispatch.dispatchRecord);
-const parkedDirective = buildResolveIOAIManagerRecoveryExecutionDirective({
-	action: parkedAction,
-	dispatchDecision: parkedFirstDispatch,
-	current: parkedCurrent,
-	surface: 'resolveio_support_runner'
-});
-const malformedBoundedAction = {
-	...parkedAction,
-	allowedDispatchAction: 'run_release_repair' as const
-};
-const malformedDispatch = decideResolveIOAIManagerRecoveryActionDispatch({
-	action: malformedBoundedAction,
-	current: parkedCurrent
-});
-const parkedAutopilot = buildResolveIOAIManagerAutopilotSnapshot({
-	surface: 'resolveio_support_runner',
-	runId: 'support-004421',
-	current: parkedCurrent,
-	recoveryPlan: parkedPlan,
-	recoveryCheckpoint: parkedCheckpoint,
-	recoveryEvidenceProbe: parkedEvidenceProbe,
-	recoveryAction: parkedAction,
-	recoveryDirective: parkedDirective,
-	recoveryDispatchHistory: parkedDispatchHistory
-});
-const manualOnlyPolicy = decideResolveIOAIManagerAutonomyPolicy({
-	mode: 'manual_only',
-	currentSpendUsd: 4,
-	budgetHardUsd: 10,
-	projectedActionCostUsd: parkedAction.costCeilingUsd
-});
-const monitorOnlyPolicy = decideResolveIOAIManagerAutonomyPolicy({
-	mode: 'monitor_only',
-	currentSpendUsd: 4,
-	budgetHardUsd: 10,
-	projectedActionCostUsd: parkedAction.costCeilingUsd
-});
-const autoWithinBudgetPolicy = decideResolveIOAIManagerAutonomyPolicy({
-	mode: 'auto_retry_within_budget',
-	currentSpendUsd: 4,
-	budgetSoftUsd: 8,
-	budgetHardUsd: 10,
-	projectedActionCostUsd: parkedAction.costCeilingUsd
-});
-const autoHardCapPolicy = decideResolveIOAIManagerAutonomyPolicy({
-	mode: 'auto_retry_within_budget',
-	currentSpendUsd: 4.9,
-	budgetHardUsd: 5,
-	projectedActionCostUsd: parkedAction.costCeilingUsd
-});
-const autoEvidenceProbePolicy = decideResolveIOAIManagerAutonomyPolicy({
-	mode: 'auto_retry_within_budget',
-	currentSpendUsd: 4,
-	budgetHardUsd: 10,
-	projectedActionCostUsd: parkedAction.costCeilingUsd,
-	dispatchAction: 'run_evidence_probe',
-	evidenceStrength: 'none'
-});
-const weakEvidenceRepairPolicy = decideResolveIOAIManagerAutonomyPolicy({
-	mode: 'auto_retry_within_budget',
-	currentSpendUsd: 4,
-	budgetHardUsd: 10,
-	projectedActionCostUsd: 1.5,
-	dispatchAction: 'run_targeted_product_repair',
-	evidenceStrength: 'weak',
-	materialEvidence: false,
-	newEvidence: false
-});
-const negativeExpectedValueRepairPolicy = decideResolveIOAIManagerAutonomyPolicy({
-	mode: 'auto_retry_within_budget',
-	currentSpendUsd: 4,
-	budgetHardUsd: 10,
-	projectedActionCostUsd: 1.5,
-	dispatchAction: 'run_targeted_product_repair',
-	evidenceStrength: 'material',
-	materialEvidence: true,
-	expectedValueScore: -0.1,
-	minExpectedValueScore: 0
-});
-const positiveExpectedValueRepairPolicy = decideResolveIOAIManagerAutonomyPolicy({
-	mode: 'auto_retry_within_budget',
-	currentSpendUsd: 4,
-	budgetHardUsd: 10,
-	projectedActionCostUsd: 1.5,
-	dispatchAction: 'run_targeted_product_repair',
-	evidenceStrength: 'material',
-	materialEvidence: true,
-	expectedValueScore: 0.4,
-	minExpectedValueScore: 0
-});
-const estimatedWeakRepairValue = estimateResolveIOAIManagerRetryExpectedValue({
-	dispatchAction: 'run_targeted_product_repair',
-	projectedActionCostUsd: 3,
-	evidenceStrength: 'weak',
-	sameEvidenceAlreadyAttempted: true
-});
-const estimatedMaterialCompileValue = estimateResolveIOAIManagerRetryExpectedValue({
-	dispatchAction: 'run_compile_repair',
-	projectedActionCostUsd: 0.4,
-	failureClass: 'compile',
-	evidenceStrength: 'material',
-	materialEvidence: true
-});
-const estimatedNegativeRepairPolicy = decideResolveIOAIManagerAutonomyPolicy({
-	mode: 'auto_retry_within_budget',
-	currentSpendUsd: 4,
-	budgetHardUsd: 10,
-	projectedActionCostUsd: 3,
-	dispatchAction: 'run_targeted_product_repair',
-	evidenceStrength: 'material',
-	materialEvidence: true,
-	evidenceSignals: ['same_evidence_already_attempted'],
-	sameEvidenceAlreadyAttempted: true
-});
-const monitorBlockedDispatch = decideResolveIOAIManagerRecoveryActionDispatch({
-	action: parkedAction,
-	current: parkedCurrent,
-	operatorApproved: true,
-	autonomyPolicy: {
-		mode: 'monitor_only',
-		currentSpendUsd: 4,
-		budgetHardUsd: 10
-	}
-});
-const manualApprovedDispatch = decideResolveIOAIManagerRecoveryActionDispatch({
-	action: parkedAction,
-	current: parkedCurrent,
-	operatorApproved: true,
-	autonomyPolicy: {
-		mode: 'manual_only',
-		currentSpendUsd: 4,
-		budgetHardUsd: 10
-	}
-});
-const hardCapBlockedDispatch = decideResolveIOAIManagerRecoveryActionDispatch({
-	action: parkedAction,
-	current: parkedCurrent,
-	autonomyPolicy: {
-		mode: 'auto_retry_within_budget',
-		currentSpendUsd: 4.9,
-		budgetHardUsd: 5
-	}
-});
-const hardCapBlockedDirective = buildResolveIOAIManagerRecoveryExecutionDirective({
-	action: parkedAction,
-	dispatchDecision: hardCapBlockedDispatch,
-	current: parkedCurrent,
-	surface: 'resolveio_support_runner'
-});
-const budgetBlockedAutopilot = buildResolveIOAIManagerAutopilotSnapshot({
-	surface: 'resolveio_support_runner',
-	runId: 'support-004421-budget',
-	current: parkedCurrent,
-	recoveryPlan: parkedPlan,
-	recoveryCheckpoint: parkedCheckpoint,
-	recoveryEvidenceProbe: parkedEvidenceProbe,
-	recoveryAction: parkedAction,
-	recoveryDirective: parkedDirective,
-	recoveryDispatchHistory: [],
-	totalUsd: 4.9,
-	autonomyPolicy: {
-		mode: 'auto_retry_within_budget',
-		budgetHardUsd: 5
-	}
-});
-
-assert.equal(parkedAutopilot.recommendedAction.action, 'park_manual');
-assert.equal(parkedDirective.singleActionOnly, true);
-assert.equal(parkedDirective.allowedDispatchAction, 'run_evidence_probe');
-assert.equal(parkedDirective.costCeilingUsd, 0.25);
-assert.equal(parkedDirective.proofRequiredBeforeContinuation, true);
-assert.ok(parkedDirective.exitCriteria.some((entry) => /exact dispatch action run_evidence_probe/i.test(entry)));
-assert.equal(malformedDispatch.allowed, false);
-assert.equal(malformedDispatch.reason, 'recovery_dispatch_action_not_in_packet_contract');
-assert.equal(parkedAutopilot.recommendedAction.singleActionOnly, true);
-assert.equal(parkedAutopilot.recommendedAction.allowedDispatchAction, 'run_evidence_probe');
-assert.equal(parkedAutopilot.recommendedAction.costCeilingUsd, 0.25);
-assert.equal(parkedAutopilot.recommendedAction.proofRequiredBeforeContinuation, true);
-assert.equal(parkedAutopilot.autonomyPolicy.mode, 'manual_only');
-assert.equal(parkedAutopilot.recommendedAction.autonomyCanAutoDispatch, false);
-assert.equal(manualOnlyPolicy.canAutoDispatch, false);
-assert.equal(manualOnlyPolicy.canManualDispatch, true);
-assert.equal(monitorOnlyPolicy.canAutoDispatch, false);
-assert.equal(monitorOnlyPolicy.canManualDispatch, false);
-assert.equal(autoWithinBudgetPolicy.canAutoDispatch, true);
-assert.equal(autoWithinBudgetPolicy.blocked, false);
-assert.equal(autoHardCapPolicy.blocked, true);
-assert.equal(autoHardCapPolicy.canAutoDispatch, false);
-assert.equal(autoEvidenceProbePolicy.canAutoDispatch, true);
-assert.equal(autoEvidenceProbePolicy.evidenceBacked, false);
-assert.equal(weakEvidenceRepairPolicy.canAutoDispatch, false);
-assert.equal(weakEvidenceRepairPolicy.reason, 'auto_retry_requires_material_evidence');
-assert.equal(negativeExpectedValueRepairPolicy.canAutoDispatch, false);
-assert.equal(negativeExpectedValueRepairPolicy.reason, 'auto_retry_expected_value_not_positive');
-assert.equal(positiveExpectedValueRepairPolicy.canAutoDispatch, true);
-assert.equal(positiveExpectedValueRepairPolicy.expectedValuePositive, true);
-assert.equal(estimatedWeakRepairValue.positive, false);
-assert.ok(estimatedWeakRepairValue.signals.includes('same_evidence_already_attempted'));
-assert.equal(estimatedMaterialCompileValue.positive, true);
-assert.ok(estimatedMaterialCompileValue.signals.includes('failure_matches_compile_repair'));
-assert.equal(estimatedNegativeRepairPolicy.expectedValueSource, 'estimated');
-assert.equal(estimatedNegativeRepairPolicy.canAutoDispatch, false);
-assert.equal(estimatedNegativeRepairPolicy.reason, 'auto_retry_expected_value_not_positive');
-assert.equal(monitorBlockedDispatch.allowed, false);
-assert.equal(monitorBlockedDispatch.reason, 'recovery_dispatch_blocked_by_autonomy_policy:monitor_only_blocks_runner_dispatch');
-assert.equal(monitorBlockedDispatch.autonomyPolicy?.mode, 'monitor_only');
-assert.equal(manualApprovedDispatch.allowed, true);
-assert.equal(manualApprovedDispatch.autonomyPolicy?.mode, 'manual_only');
-assert.equal(hardCapBlockedDispatch.allowed, false);
-assert.equal(hardCapBlockedDispatch.autonomyPolicy?.blocked, true);
-assert.equal(hardCapBlockedDirective.autonomyPolicy?.hardBudgetExceeded, true);
-assert.equal(budgetBlockedAutopilot.autonomyPolicy.blocked, true);
-assert.equal(budgetBlockedAutopilot.recommendedAction.autoRunnable, false);
-assert.equal(budgetBlockedAutopilot.recommendedAction.autonomyBlocked, true);
-assert.equal(budgetBlockedAutopilot.controlPolicy.modeLabel, 'Auto Retry Within Budget');
-assert.equal(budgetBlockedAutopilot.controlPolicy.blocked, true);
-assert.equal(budgetBlockedAutopilot.controlPolicy.canAutoDispatch, false);
-assert.equal(budgetBlockedAutopilot.controlPolicy.budget.hardBudgetExceeded, true);
-assert.equal(budgetBlockedAutopilot.controlPolicy.secondaryActionGroups.some((group) => group.groupId === 'policy' && group.actions.some((action) => action.action === 'set_mode:manual_only')), true);
-assert.equal(parkedAutopilot.recovery.singleActionOnly, true);
-assert.ok(parkedAutopilot.recovery.exitCriteria.some((entry) => /required proof artifact/i.test(entry)));
-assert.equal(parkedAutopilot.loopGuard.sameEvidenceAlreadyAttempted, true);
-assert.equal(parkedAutopilot.humanDecision.required, true);
-assert.equal(parkedAutopilot.humanDecision.status, 'waiting_for_operator');
-assert.equal(parkedAutopilot.humanDecision.preferredChoiceId, 'attach_new_evidence');
-assert.ok(parkedAutopilot.humanDecision.choices.some((choice) => choice.choiceId === 'attach_new_evidence' && choice.action === 'run_evidence_probe'));
-assert.ok(parkedAutopilot.humanDecision.choices.some((choice) => choice.choiceId === 'revise_diagnosis' && choice.action === 'run_read_only_diagnosis'));
-assert.ok(parkedAutopilot.humanDecision.blockedUntil.some((entry) => /new material evidence/i.test(entry)));
-assert.equal(parkedAutopilot.humanDecision.evidence.evidenceHash, parkedCheckpoint.evidenceHash);
-
-assert.equal(isResolveIOAIManagerSafeAutoDispatch({ dispatchAction: 'run_evidence_probe' }), true);
-assert.equal(isResolveIOAIManagerSafeAutoDispatch({ dispatchAction: 'run_release_repair' }), true);
-assert.equal(isResolveIOAIManagerSafeAutoDispatch({ dispatchAction: 'run_journey_contract_repair' }), true);
-assert.equal(isResolveIOAIManagerSafeAutoDispatch({ dispatchAction: 'run_targeted_product_repair' }), false);
-assert.equal(isResolveIOAIManagerSafeAutoDispatch({ dispatchAction: 'run_business_assertion_repair' }), false);
-assert.equal(isResolveIOAIManagerSafeAutoDispatch({
-	dispatchAction: 'run_release_repair',
-	includeReleaseRepair: false
-}), false);
-
-const duplicateReleasePolicy = buildResolveIOAIManagerHotfixFirstReleasePolicy({
-	surface: 'aicoder_builder',
-	deployFingerprint: 'app-v6-build-sha',
-	lastDeployFingerprint: 'app-v6-build-sha',
-	deployStatus: 'completed',
-	publishStatus: 'published'
-});
-
-assert.equal(duplicateReleasePolicy.policy, 'hotfix_first');
-assert.equal(duplicateReleasePolicy.recommendedAction, 'block_duplicate_deploy');
-assert.equal(duplicateReleasePolicy.duplicateDeployBlocked, true);
-assert.equal(duplicateReleasePolicy.fullDeployAllowed, false);
-assert.equal(duplicateReleasePolicy.forceDeployRequiredToRepeat, true);
-assert.ok(duplicateReleasePolicy.allowedActions.includes('hotfix_release_artifact'));
-assert.ok(duplicateReleasePolicy.forbiddenActions.some((entry) => /duplicate deploy/i.test(entry)));
-assert.equal(duplicateReleasePolicy.hotfixPlan.fullDeployAvoided, true);
-assert.equal(duplicateReleasePolicy.hotfixPlan.recommendedChannel, 'static_ui');
-assert.ok(duplicateReleasePolicy.hotfixPlan.steps.some((step) => step.channel === 'static_ui' && step.requiresFullDeploy === false));
-assert.ok(duplicateReleasePolicy.hotfixPlan.steps.some((step) => step.channel === 'backend_js' && step.requiredEvidence.some((entry) => /compiled JS artifact/i.test(entry))));
-assert.ok(duplicateReleasePolicy.hotfixPlan.steps.some((step) => step.channel === 'backend_js' && step.requiredEvidence.some((entry) => /gitPushStatus/i.test(entry))));
-
-const weakBackendHotfixEvidence = validateResolveIOAIManagerHotfixEvidence({
-	channel: 'backend_js',
-	target: {
-		host: 'backend.resolveio.com',
-		path: '/var/app/current/http/admin-deploy.js'
-	},
-	compiledArtifactPath: 'dist/http/admin-deploy.js',
-	remoteChecksumBefore: 'old-sha',
-	remoteChecksumAfter: 'new-sha',
-	healthCheckStatus: 'pass'
-}, { policy: duplicateReleasePolicy });
-
-assert.equal(weakBackendHotfixEvidence.valid, false);
-assert.equal(weakBackendHotfixEvidence.fullDeployAllowed, false);
-assert.ok(weakBackendHotfixEvidence.blockers.some((blocker) => /restart evidence/i.test(blocker)));
-assert.ok(weakBackendHotfixEvidence.blockers.some((blocker) => /selfTestStatus/i.test(blocker)));
-assert.ok(weakBackendHotfixEvidence.blockers.some((blocker) => /sourceCommitSha/i.test(blocker)));
-
-const malformedBackendHotfixEvidence = validateResolveIOAIManagerHotfixEvidence({
-	channel: 'backend_js',
-	target: {
-		host: 'backend.resolveio.com',
-		path: '/var/app/current/http/admin-deploy.js'
-	},
-	compiledArtifactPath: 'dist/http/admin-deploy.js',
-	remoteChecksumAfter: 'after-sha',
-	sourceCommitSha: 'abc1234hotfix',
-	githubCommitUrl: 'https://github.com/resolveio/resolveio-server-lib/commit/abc1234hotfix',
-	restartEvidence: 'systemctl restart nodejs succeeded on all hosts',
-	healthCheckStatus: 'passed',
-	selfTestStatus: 'passed'
-}, { policy: duplicateReleasePolicy });
-
-assert.equal(malformedBackendHotfixEvidence.valid, false);
-assert.ok(malformedBackendHotfixEvidence.blockers.some((blocker) => /40-character git SHA/i.test(blocker)));
-assert.ok(malformedBackendHotfixEvidence.blockers.some((blocker) => /strong hex checksum/i.test(blocker)));
-
-const unpushedBackendHotfixEvidence = validateResolveIOAIManagerHotfixEvidence({
-	channel: 'backend_js',
-	target: {
-		host: 'backend.resolveio.com',
-		path: '/var/app/current/http/admin-deploy.js'
-	},
-	compiledArtifactPath: 'dist/http/admin-deploy.js',
-	remoteChecksumBefore: '1111111111111111111111111111111111111111111111111111111111111111',
-	remoteChecksumAfter: '2222222222222222222222222222222222222222222222222222222222222222',
-	sourceCommitSha: 'dd20c124012757ff7d66c682e4b7aad45c402d87',
-	githubCommitUrl: 'https://github.com/resolveio/resolveio-server-lib/commit/dd20c124012757ff7d66c682e4b7aad45c402d87',
-	restartEvidence: 'systemctl restart nodejs succeeded on all hosts',
-	healthCheckStatus: 'passed',
-	selfTestStatus: 'passed'
-}, { policy: duplicateReleasePolicy });
-
-assert.equal(unpushedBackendHotfixEvidence.valid, false);
-assert.ok(unpushedBackendHotfixEvidence.blockers.some((blocker) => /gitPushStatus.*GitHub/i.test(blocker)));
-assert.equal(unpushedBackendHotfixEvidence.githubCommitGuard.required, true);
-assert.equal(unpushedBackendHotfixEvidence.githubCommitGuard.status, 'missing');
-assert.equal(unpushedBackendHotfixEvidence.githubCommitGuard.managerMustCommitBeforeHotfix, true);
-assert.ok(unpushedBackendHotfixEvidence.githubCommitGuard.nextCommands.includes('commit_and_push_hotfix_to_github'));
-
-const unpushedBackendHotfixGitProof = evaluateResolveIOAIManagerHotfixGitProof({
-	channel: 'backend_js',
-	sourceCommitSha: 'dd20c124012757ff7d66c682e4b7aad45c402d87',
-	githubCommitUrl: 'https://github.com/resolveio/resolveio-server-lib/commit/dd20c124012757ff7d66c682e4b7aad45c402d87'
-});
-
-assert.equal(unpushedBackendHotfixGitProof.required, true);
-assert.equal(unpushedBackendHotfixGitProof.status, 'missing');
-assert.equal(unpushedBackendHotfixGitProof.passed, false);
-assert.equal(unpushedBackendHotfixGitProof.managerMustCommitBeforeHotfix, true);
-assert.ok(unpushedBackendHotfixGitProof.nextCommands.includes('verify_github_commit_url_and_push_status'));
-
-const localOnlyBackendHotfixEvidence = validateResolveIOAIManagerHotfixEvidence({
-	channel: 'backend_js',
-	target: {
-		host: 'backend.resolveio.com',
-		path: '/var/app/current/http/admin-deploy.js'
-	},
-	compiledArtifactPath: 'dist/http/admin-deploy.js',
-	remoteChecksumBefore: '1111111111111111111111111111111111111111111111111111111111111111',
-	remoteChecksumAfter: '2222222222222222222222222222222222222222222222222222222222222222',
-	sourceCommitSha: 'dd20c124012757ff7d66c682e4b7aad45c402d87',
-	githubCommitUrl: 'https://github.com/resolveio/resolveio-server-lib/commit/dd20c124012757ff7d66c682e4b7aad45c402d87',
-	gitCommitStatus: 'passed',
-	restartEvidence: 'systemctl restart nodejs succeeded on all hosts',
-	healthCheckStatus: 'passed',
-	selfTestStatus: 'passed'
-}, { policy: duplicateReleasePolicy });
-
-assert.equal(localOnlyBackendHotfixEvidence.valid, false);
-assert.equal(localOnlyBackendHotfixEvidence.githubCommitGuard.status, 'missing');
-assert.equal(localOnlyBackendHotfixEvidence.githubCommitGuard.gitCommitStatus, 'passed');
-assert.equal(localOnlyBackendHotfixEvidence.githubCommitGuard.gitPushStatus, '');
-assert.ok(localOnlyBackendHotfixEvidence.blockers.some((blocker) => /passed gitPushStatus/i.test(blocker)));
-
-const localOnlyBackendHotfixRecord = buildResolveIOAIManagerHotfixEvidenceRecord({
-	evidence: localOnlyBackendHotfixEvidence.normalized,
-	policy: duplicateReleasePolicy,
-	source: 'manager_hotfix'
-});
-assert.equal(localOnlyBackendHotfixRecord.valid, false);
-assert.equal(localOnlyBackendHotfixRecord.managerMustCommitBeforeHotfix, true);
-assert.ok(localOnlyBackendHotfixRecord.missingFields.includes('gitPushStatus'));
-
-const backendHotfixEvidence = validateResolveIOAIManagerHotfixEvidence({
-	channel: 'backend_js',
-	target: {
-		host: 'backend.resolveio.com',
-		path: '/var/app/current/http/admin-deploy.js'
-	},
-	compiledArtifactPath: 'dist/http/admin-deploy.js',
-	remoteChecksumBefore: '1111111111111111111111111111111111111111111111111111111111111111',
-	remoteChecksumAfter: '2222222222222222222222222222222222222222222222222222222222222222',
-	sourceCommitSha: 'dd20c124012757ff7d66c682e4b7aad45c402d87',
-	githubCommitUrl: 'https://github.com/resolveio/resolveio-server-lib/commit/dd20c124012757ff7d66c682e4b7aad45c402d87',
-	gitPushStatus: 'passed',
-	restartEvidence: 'systemctl restart nodejs succeeded on all hosts',
-	healthCheckStatus: 'passed',
-	selfTestStatus: 'passed'
-}, { policy: duplicateReleasePolicy });
-
-assert.equal(backendHotfixEvidence.valid, true);
-assert.equal(backendHotfixEvidence.hotfixSatisfied, true);
-assert.equal(backendHotfixEvidence.fullDeployAllowed, false);
-assert.equal(backendHotfixEvidence.nextAction, 'rerun_release_gate');
-assert.equal(backendHotfixEvidence.githubCommitGuard.status, 'passed');
-assert.equal(backendHotfixEvidence.githubCommitGuard.passed, true);
-
-const committedBackendHotfixCommitGuard = decideResolveIOAIManagerHotfixCommitGuard({
-	evidence: backendHotfixEvidence.normalized,
-	policy: duplicateReleasePolicy,
-	failureClass: 'release',
-	blocker: 'Backend hotfix has matching GitHub push proof.'
-});
-
-assert.equal(committedBackendHotfixCommitGuard.active, true);
-assert.equal(committedBackendHotfixCommitGuard.blocked, false);
-assert.equal(committedBackendHotfixCommitGuard.nextAction, 'continue');
-assert.equal(committedBackendHotfixCommitGuard.githubCommitGuard.passed, true);
-
-const backendHotfixAutoRecord = buildResolveIOAIManagerHotfixEvidenceRecord({
-	evidence: backendHotfixEvidence.normalized,
-	policy: duplicateReleasePolicy,
-	source: 'runner_console',
-	recordedBy: 'operator@example.com',
-	reason: 'A backend runner hotfix replaced one compiled JS file.',
-	now: '2026-06-16T00:00:00.000Z'
-});
-
-assert.equal(backendHotfixAutoRecord.valid, true);
-assert.equal(backendHotfixAutoRecord.status, 'passed');
-assert.equal(backendHotfixAutoRecord.readyForReleaseGate, true);
-assert.equal(backendHotfixAutoRecord.readyForContinuation, false);
-assert.equal(backendHotfixAutoRecord.sourceCommitSha, 'dd20c124012757ff7d66c682e4b7aad45c402d87');
-assert.equal(backendHotfixAutoRecord.gitPushStatus, 'passed');
-assert.equal(backendHotfixAutoRecord.githubCommitRequired, true);
-assert.equal(backendHotfixAutoRecord.githubCommitProofPassed, true);
-assert.equal(backendHotfixAutoRecord.commitProofStatus, 'passed');
-assert.equal(backendHotfixAutoRecord.managerMustCommitBeforeHotfix, false);
-assert.equal(backendHotfixAutoRecord.githubCommitGuard.status, 'passed');
-assert.deepEqual(backendHotfixAutoRecord.missingFields, []);
-assert.ok(backendHotfixAutoRecord.requiredFields.includes('gitPushStatus'));
-assert.ok(backendHotfixAutoRecord.requiredFields.includes('remoteChecksumAfter'));
-
-const incompleteBackendHotfixAutoRecord = buildResolveIOAIManagerHotfixEvidenceRecord({
-	channel: 'backend_js',
-	target: {
-		host: 'backend.resolveio.com',
-		path: '/var/app/current/http/admin-deploy.js'
-	},
-	compiledArtifactPath: 'dist/http/admin-deploy.js',
-	remoteChecksumAfter: '2222222222222222222222222222222222222222222222222222222222222222',
-	sourceCommitSha: 'dd20c124012757ff7d66c682e4b7aad45c402d87',
-	githubCommitUrl: 'https://github.com/resolveio/resolveio-server-lib/commit/dd20c124012757ff7d66c682e4b7aad45c402d87',
-	restartEvidence: 'systemctl restart nodejs succeeded on all hosts',
-	healthCheckStatus: 'passed',
-	selfTestStatus: 'passed',
-	policy: duplicateReleasePolicy,
-	source: 'runner_console'
-});
-
-assert.equal(incompleteBackendHotfixAutoRecord.valid, false);
-assert.equal(incompleteBackendHotfixAutoRecord.nextAction, 'record_hotfix_evidence');
-assert.equal(incompleteBackendHotfixAutoRecord.commitProofStatus, 'missing');
-assert.equal(incompleteBackendHotfixAutoRecord.managerMustCommitBeforeHotfix, true);
-assert.equal(incompleteBackendHotfixAutoRecord.githubCommitGuard.managerMustCommitBeforeHotfix, true);
-assert.ok(incompleteBackendHotfixAutoRecord.missingFields.includes('gitPushStatus'));
-
-const incompleteBackendHotfixCommitGuard = decideResolveIOAIManagerHotfixCommitGuard({
-	evidence: incompleteBackendHotfixAutoRecord.evidence,
-	policy: duplicateReleasePolicy,
-	failureClass: 'release',
-	blocker: 'Backend hotfix was applied before GitHub push proof was recorded.'
-});
-
-assert.equal(incompleteBackendHotfixCommitGuard.active, true);
-assert.equal(incompleteBackendHotfixCommitGuard.blocked, true);
-assert.equal(incompleteBackendHotfixCommitGuard.nextAction, 'record_hotfix_evidence');
-assert.equal(incompleteBackendHotfixCommitGuard.githubCommitGuard.managerMustCommitBeforeHotfix, true);
-assert.ok(incompleteBackendHotfixCommitGuard.nextCommands.includes('commit_and_push_hotfix_to_github'));
-
-const incompleteBackendHotfixContinuation = decideResolveIOAIManagerHotfixContinuation({
-	evidence: {
-		channel: 'backend_js',
-		target: {
-			host: 'backend.resolveio.com',
-			path: '/var/app/current/http/admin-deploy.js'
-		},
-		compiledArtifactPath: 'dist/http/admin-deploy.js',
-		remoteChecksumAfter: '557d0bf',
-		healthCheckStatus: 'passed'
-	},
-	policy: duplicateReleasePolicy,
-	failureClass: 'release',
-	blocker: 'Duplicate deploy loop.'
-});
-
-assert.equal(incompleteBackendHotfixContinuation.action, 'record_hotfix_evidence');
-assert.equal(incompleteBackendHotfixContinuation.canContinueRun, false);
-assert.equal(incompleteBackendHotfixContinuation.canRunFullDeploy, false);
-assert.equal(incompleteBackendHotfixContinuation.githubCommitGuard.managerMustCommitBeforeHotfix, true);
-assert.ok(incompleteBackendHotfixContinuation.nextCommands.includes('commit_and_push_hotfix_to_github'));
-assert.ok(incompleteBackendHotfixContinuation.blockers.some((blocker) => /restart evidence/i.test(blocker)));
-
-const backendHotfixContinuation = decideResolveIOAIManagerHotfixContinuation({
-	evidence: backendHotfixEvidence.normalized,
-	policy: duplicateReleasePolicy,
-	failureClass: 'release',
-	blocker: 'Duplicate deploy loop.'
-});
-
-assert.equal(backendHotfixContinuation.action, 'rerun_release_gate');
-assert.equal(backendHotfixContinuation.shouldRerunReleaseGate, true);
-assert.equal(backendHotfixContinuation.canRunFullDeploy, false);
-assert.equal(backendHotfixContinuation.canContinueRun, false);
-assert.equal(backendHotfixContinuation.githubCommitGuard.passed, true);
-assert.ok(backendHotfixContinuation.nextCommands.includes('rerun_release_gate_once'));
-
-const backendHotfixContinueAfterGate = decideResolveIOAIManagerHotfixContinuation({
-	evidence: {
-		...backendHotfixEvidence.normalized,
-		releaseGateStatus: 'passed'
-	},
-	policy: duplicateReleasePolicy,
-	releaseGatePassed: true,
-	failureClass: 'release',
-	blocker: 'Duplicate deploy loop.'
-});
-
-assert.equal(backendHotfixContinueAfterGate.action, 'continue_runner');
-assert.equal(backendHotfixContinueAfterGate.canContinueRun, true);
-assert.equal(backendHotfixContinueAfterGate.canRunFullDeploy, false);
-assert.equal(backendHotfixContinueAfterGate.shouldRerunReleaseGate, false);
-assert.ok(backendHotfixContinueAfterGate.nextCommands.includes('continue_current_runner'));
-
-const fullDeployDuringDuplicateEvidence = validateResolveIOAIManagerHotfixEvidence({
-	channel: 'backend_js',
-	fullDeployRequested: true,
-	target: {
-		host: 'backend.resolveio.com',
-		path: '/var/app/current/http/admin-deploy.js'
-	},
-	compiledArtifactPath: 'dist/http/admin-deploy.js',
-	remoteChecksumAfter: '2222222222222222222222222222222222222222222222222222222222222222',
-	sourceCommitSha: 'dd20c124012757ff7d66c682e4b7aad45c402d87',
-	githubCommitUrl: 'https://github.com/resolveio/resolveio-server-lib/commit/dd20c124012757ff7d66c682e4b7aad45c402d87',
-	gitPushStatus: 'passed',
-	restartEvidence: 'systemctl restart nodejs succeeded',
-	healthCheckStatus: 'passed',
-	selfTestStatus: 'passed'
-}, { policy: duplicateReleasePolicy });
-
-assert.equal(fullDeployDuringDuplicateEvidence.valid, false);
-assert.equal(fullDeployDuringDuplicateEvidence.fullDeployBlocked, true);
-assert.ok(fullDeployDuringDuplicateEvidence.blockers.some((blocker) => /Full deploy requested/i.test(blocker)));
-
-const successfulAICoderDeployPolicy = buildResolveIOAIManagerHotfixFirstReleasePolicy({
-	surface: 'aicoder_deploy_dashboard',
-	deployFingerprint: 'client:bucket:apps/layflat/:',
-	lastDeployFingerprint: 'client:bucket:apps/layflat/:',
-	deployStatus: 'Success',
-	publishStatus: 'Client deploy from s3://bucket/apps/layflat/'
-});
-
-assert.equal(successfulAICoderDeployPolicy.recommendedAction, 'block_duplicate_deploy');
-assert.equal(successfulAICoderDeployPolicy.duplicateDeployBlocked, true);
-assert.equal(successfulAICoderDeployPolicy.fullDeployAllowed, false);
-
-const duplicatePublishPolicy = buildResolveIOAIManagerHotfixFirstReleasePolicy({
-	surface: 'aicoder_publish_gate',
-	publishFingerprint: 'npm:@resolveio/client-lib-aicoder-dashboard:21.0.16:22c7d73a',
-	lastPublishFingerprint: 'npm:@resolveio/client-lib-aicoder-dashboard:21.0.16:22c7d73a',
-	publishStatus: 'failed: registry denied publish PUT'
-});
-
-assert.equal(duplicatePublishPolicy.recommendedAction, 'block_duplicate_publish');
-assert.equal(duplicatePublishPolicy.duplicatePublishBlocked, true);
-assert.equal(duplicatePublishPolicy.fullDeployAllowed, false);
-assert.equal(duplicatePublishPolicy.forcePublishRequiredToRepeat, true);
-assert.ok(duplicatePublishPolicy.allowedActions.includes('request_force_publish_with_reason'));
-assert.equal(duplicatePublishPolicy.hotfixPlan.label, 'Hotfix Or Force Publish');
-assert.equal(duplicatePublishPolicy.hotfixPlan.recommendedChannel, 'release_artifact');
-assert.ok(duplicatePublishPolicy.forbiddenActions.some((entry) => /duplicate publish/i.test(entry)));
-
-const completedPublishPolicy = buildResolveIOAIManagerHotfixFirstReleasePolicy({
-	surface: 'support_push_master',
-	publishFingerprint: 'support-pr-123-merge-sha',
-	lastPublishFingerprint: 'support-pr-123-merge-sha',
-	publishStatus: 'completed',
-	hasNewArtifact: true
-});
-
-assert.equal(completedPublishPolicy.duplicatePublishBlocked, false);
-assert.notEqual(completedPublishPolicy.recommendedAction, 'block_duplicate_publish');
-
-const forcedPublishPolicy = buildResolveIOAIManagerHotfixFirstReleasePolicy({
-	surface: 'aicoder_publish_gate',
-	publishFingerprint: 'npm:@resolveio/client-lib-aicoder-dashboard:21.0.16:22c7d73a',
-	lastPublishFingerprint: 'npm:@resolveio/client-lib-aicoder-dashboard:21.0.16:22c7d73a',
-	publishStatus: 'failed: registry denied publish PUT',
-	forcePublish: true
-});
-
-assert.equal(forcedPublishPolicy.recommendedAction, 'review_force_deploy');
-assert.equal(forcedPublishPolicy.duplicatePublishBlocked, false);
-assert.equal(forcedPublishPolicy.fullDeployAllowed, true);
-assert.match(forcedPublishPolicy.reason, /force_publish/);
-
-const forcedReleasePolicy = buildResolveIOAIManagerHotfixFirstReleasePolicy({
-	surface: 'support_runner',
-	deployFingerprint: 'support-pr-123-sha',
-	lastDeployFingerprint: 'support-pr-123-sha',
-	deployStatus: 'completed',
-	forceDeploy: true
-});
-
-assert.equal(forcedReleasePolicy.recommendedAction, 'review_force_deploy');
-assert.equal(forcedReleasePolicy.duplicateDeployBlocked, false);
-assert.equal(forcedReleasePolicy.fullDeployAllowed, true);
-assert.ok(forcedReleasePolicy.requiredEvidence.some((entry) => /force_deploy/i.test(entry)));
-
-const newArtifactReleasePolicy = buildResolveIOAIManagerHotfixFirstReleasePolicy({
-	surface: 'aicoder_app_dashboard_terminal',
-	deployFingerprint: 'new-app-build-sha',
-	lastDeployFingerprint: 'old-app-build-sha',
-	deployStatus: 'ready',
-	publishStatus: 'ready',
-	hasNewArtifact: true
-});
-
-assert.equal(newArtifactReleasePolicy.recommendedAction, 'deploy_new_artifact_after_release_gate');
-assert.equal(newArtifactReleasePolicy.fullDeployAllowed, true);
-assert.equal(newArtifactReleasePolicy.hotfixPreferred, false);
-assert.equal(newArtifactReleasePolicy.hotfixPlan.fullDeployAvoided, false);
-assert.equal(newArtifactReleasePolicy.hotfixPlan.recommendedChannel, 'new_artifact_deploy');
-
-const releasePlan = buildResolveIOAIManagerRecoveryPlan({
-	action: 'continue',
-	reason: 'domain publish failed after business proof',
-	failureClass: 'release',
-	lane: 'publish',
-	stepType: 'test_deploy',
-	blocker: 'CloudFront invalidation failed for the published app.'
-});
-const releaseCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint({
-	plan: releasePlan,
-	current: {
-		lane: 'publish',
-		stepType: 'test_deploy',
-		failureClass: 'release',
-		blocker: 'CloudFront invalidation failed for the published app.',
-		evidenceHash: 'publish-cloudfront-failed',
-		artifactPaths: ['qa/release-publish.log']
-	}
-});
-const releaseProbe = buildResolveIOAIManagerRecoveryEvidenceProbe({ checkpoint: releaseCheckpoint });
-const releaseAction = buildResolveIOAIManagerRecoveryActionPacket({
-	checkpoint: releaseCheckpoint,
-	probe: releaseProbe
-});
-const releaseDirective = buildResolveIOAIManagerRecoveryExecutionDirective({
-	action: releaseAction,
-	current: {
-		lane: 'publish',
-		stepType: 'test_deploy',
-		failureClass: 'release',
-		blocker: 'CloudFront invalidation failed for the published app.',
-		evidenceHash: 'publish-cloudfront-failed',
-		artifactPaths: ['qa/release-publish.log']
-	},
-	surface: 'aicoder_builder'
-});
-
-assert.equal(releasePlan.recoveryClass, 'release_repair');
-assert.equal(releasePlan.productRepairAllowed, false);
-assert.equal(releaseAction.mode, 'repair_release');
-assert.equal(releaseAction.productRepairAllowed, false);
-assert.equal(releaseAction.releasePolicy?.policy, 'hotfix_first');
-assert.equal(releaseAction.releasePolicy?.recommendedAction, 'hotfix_release_artifact');
-assert.ok(releaseAction.nextCommands.includes('hotfix_live_runner_or_release_artifact'));
-assert.ok(releaseAction.nextCommands.includes('commit_and_push_hotfix_to_github'));
-assert.ok(releaseAction.nextCommands.includes('record_github_commit_for_hotfix'));
-assert.ok(releaseAction.nextCommands.includes('apply_live_hotfix_only_after_github_commit_proof'));
-assert.ok(releaseAction.requiredArtifacts.some((entry) => /sourceCommitSha/i.test(entry)));
-assert.ok(releaseAction.requiredArtifacts.some((entry) => /gitPushStatus/i.test(entry)));
-assert.ok(releaseAction.successCriteria.some((entry) => /GitHub commit and push proof/i.test(entry)));
-assert.equal(releaseDirective.phase, 'release');
-assert.equal(releaseDirective.releasePolicy?.policy, 'hotfix_first');
-assert.ok(releaseDirective.forbiddenActions.some((entry) => /full builder loop|duplicate deploy/i.test(entry)));
-
-const supportReplayMatrix = buildResolveIOAIManagerRecoveryReplayMatrix({
-	surface: 'support_runner',
-	includeReleaseRepair: true,
-	includeJourneyContractRepair: false
-});
-const aicoderBuilderReplayMatrix = buildResolveIOAIManagerRecoveryReplayMatrix({
-	surface: 'aicoder_builder',
-	includeReleaseRepair: true,
-	includeJourneyContractRepair: true
-});
-const aicoderTerminalReplayMatrix = buildResolveIOAIManagerRecoveryReplayMatrix({
-	surface: 'aicoder_app_dashboard_terminal',
-	includeReleaseRepair: true,
-	includeJourneyContractRepair: true
-});
-
-assert.ok(supportReplayMatrix.every((entry) => entry.pass), JSON.stringify(supportReplayMatrix.filter((entry) => !entry.pass), null, 2));
-assert.ok(aicoderBuilderReplayMatrix.every((entry) => entry.pass), JSON.stringify(aicoderBuilderReplayMatrix.filter((entry) => !entry.pass), null, 2));
-assert.ok(aicoderTerminalReplayMatrix.every((entry) => entry.pass), JSON.stringify(aicoderTerminalReplayMatrix.filter((entry) => !entry.pass), null, 2));
-assert.equal(supportReplayMatrix.find((entry) => entry.caseId === 'journey_repair_is_safe_only_for_aicoder_surfaces')?.safeAutoDispatch, false);
-assert.equal(aicoderBuilderReplayMatrix.find((entry) => entry.caseId === 'journey_repair_is_safe_only_for_aicoder_surfaces')?.safeAutoDispatch, true);
-assert.equal(aicoderTerminalReplayMatrix.find((entry) => entry.caseId === 'journey_repair_is_safe_only_for_aicoder_surfaces')?.safeAutoDispatch, true);
-for (const matrix of [supportReplayMatrix, aicoderBuilderReplayMatrix, aicoderTerminalReplayMatrix]) {
-	assert.equal(matrix.find((entry) => entry.caseId === 'release_uses_hotfix_first_repair')?.hotfixFirst, true);
-	assert.equal(matrix.find((entry) => entry.caseId === 'release_uses_hotfix_first_repair')?.fullDeployAllowed, false);
-	assert.equal(matrix.find((entry) => entry.caseId === 'duplicate_release_fingerprint_blocks_full_deploy')?.fullDeployAllowed, false);
-	assert.equal(matrix.find((entry) => entry.caseId === 'product_repair_requires_explicit_operator_policy')?.safeAutoDispatch, false);
-	assert.equal(matrix.find((entry) => entry.caseId === 'weak_hash_only_evidence_stays_parked')?.evidenceStrength, 'weak');
-	assert.equal(matrix.find((entry) => entry.caseId === 'material_evidence_resets_loop_budget')?.loopBudgetShouldReset, true);
-}
-
-const firstDispatch = decideResolveIOAIManagerRecoveryActionDispatch({
-	action: parkedAction,
-	current: {
-		lane: 'repair',
-		stepType: 'repair',
-		failureClass: 'product_code',
-		blocker: 'Save action still throws TypeError.',
-		evidenceHash: 'save-typeerror-before',
-		artifactPaths: ['qa/save-before.log']
-	},
-	now: '2026-06-15T00:01:00.000Z'
-});
-
-assert.equal(firstDispatch.allowed, true);
-assert.equal(firstDispatch.dispatchAction, 'run_evidence_probe');
-assert.equal(firstDispatch.canRunProductRepair, false);
-assert.equal(firstDispatch.shouldRecordDispatch, true);
-assert.equal(firstDispatch.dispatchRecord?.status, 'started');
-
-const firstDirective = buildResolveIOAIManagerRecoveryExecutionDirective({
-	action: parkedAction,
-	dispatchDecision: firstDispatch,
-	current: {
-		lane: 'repair',
-		stepType: 'repair',
-		failureClass: 'product_code',
-		blocker: 'Save action still throws TypeError.',
-		evidenceHash: 'save-typeerror-before',
-		artifactPaths: ['qa/save-before.log']
-	},
-	surface: 'aicoder_builder',
-	now: '2026-06-15T00:01:00.000Z'
-});
-
-assert.equal(firstDirective.allowed, true);
-assert.equal(firstDirective.phase, 'evidence');
-assert.equal(firstDirective.canRunProductRepair, false);
-assert.match(firstDirective.rerunReason, /MANAGER_RECOVERY:run_evidence_probe/);
-assert.ok(firstDirective.forbiddenActions.some((entry) => /product-code repair/i.test(entry)));
-
-const completedDispatchHistory = appendResolveIOAIManagerRecoveryActionDispatch([], {
-	...firstDispatch.dispatchRecord!,
-	status: 'completed',
-	completedAt: '2026-06-15T00:02:00.000Z'
-});
-const repeatedDispatch = decideResolveIOAIManagerRecoveryActionDispatch({
-	action: parkedAction,
-	history: completedDispatchHistory,
-	current: {
-		lane: 'repair',
-		stepType: 'repair',
-		failureClass: 'product_code',
-		blocker: 'Save action still throws TypeError.',
-		evidenceHash: 'save-typeerror-before',
-		artifactPaths: ['qa/save-before.log']
-	},
-	now: '2026-06-15T00:03:00.000Z'
-});
-
-assert.equal(repeatedDispatch.allowed, false);
-assert.equal(repeatedDispatch.dispatchAction, 'park_manual');
-assert.equal(repeatedDispatch.reason, 'recovery_dispatch_same_evidence_already_attempted');
-assert.equal(repeatedDispatch.requiresNewEvidence, true);
-
-const repeatedDirective = buildResolveIOAIManagerRecoveryExecutionDirective({
-	action: parkedAction,
-	dispatchDecision: repeatedDispatch,
-	current: {
-		lane: 'repair',
-		stepType: 'repair',
-		failureClass: 'product_code',
-		blocker: 'Save action still throws TypeError.',
-		evidenceHash: 'save-typeerror-before',
-		artifactPaths: ['qa/save-before.log']
-	},
-	surface: 'aicoder_builder',
-	now: '2026-06-15T00:03:00.000Z'
-});
-
-assert.equal(repeatedDirective.allowed, false);
-assert.equal(repeatedDirective.phase, 'manual');
-assert.equal(repeatedDirective.dispatchAction, 'park_manual');
-assert.equal(repeatedDirective.requiresNewEvidence, true);
-
-const newEvidenceDispatch = decideResolveIOAIManagerRecoveryActionDispatch({
-	action: parkedAction,
-	history: completedDispatchHistory,
-	current: {
-		lane: 'repair',
-		stepType: 'repair',
-		failureClass: 'product_code',
-		blocker: 'Save action still throws TypeError.',
-		evidenceHash: 'save-typeerror-after-dom-trace',
-		artifactPaths: ['qa/save-before.log', 'qa/save-after-dom-trace.json']
-	},
-	now: '2026-06-15T00:04:00.000Z'
-});
-
-assert.equal(newEvidenceDispatch.allowed, true);
-assert.equal(newEvidenceDispatch.newEvidence, true);
-assert.equal(newEvidenceDispatch.dispatchAction, 'run_evidence_probe');
-
-const stillParked = decideResolveIOAIManagerRecoveryGate({
-	checkpoint: parkedCheckpoint,
-	current: {
-		lane: 'repair',
-		stepType: 'repair',
-		failureClass: 'product_code',
-		blocker: 'Save action still throws TypeError.',
-		evidenceHash: 'save-typeerror-before',
-		artifactPaths: ['qa/save-before.log']
-	}
-});
-
-assert.equal(stillParked.action, 'collect_new_evidence');
-assert.equal(stillParked.shouldResetLoopBudget, false);
-assert.equal(stillParked.canRunProductRepair, false);
-
-const runnerSpecificFingerprintCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint({
-	plan: parkedPlan,
-	current: {
-		lane: 'repair',
-		stepType: 'repair',
-		failureClass: 'product_code',
-		blocker: 'Save action still throws TypeError.',
-		blockerFingerprint: 'aicoder-v6-runner-specific',
-		evidenceHash: 'save-typeerror-before',
-		artifactPaths: ['qa/save-before.log']
-	},
-	now: '2026-06-15T00:00:00.000Z'
-});
-const runnerSpecificStillParked = decideResolveIOAIManagerRecoveryGate({
-	checkpoint: runnerSpecificFingerprintCheckpoint,
-	current: {
-		lane: 'repair',
-		stepType: 'repair',
-		failureClass: 'product_code',
-		blocker: 'Save action still throws TypeError.',
-		evidenceHash: 'save-typeerror-before',
-		artifactPaths: ['qa/save-before.log']
-	}
-});
-
-assert.equal(runnerSpecificStillParked.action, 'collect_new_evidence');
-assert.equal(runnerSpecificStillParked.newEvidence, false);
-assert.equal(runnerSpecificStillParked.canRunProductRepair, false);
-
-const noCurrentStillParked = decideResolveIOAIManagerRecoveryGate({
-	checkpoint: runnerSpecificFingerprintCheckpoint
-});
-
-assert.equal(noCurrentStillParked.action, 'collect_new_evidence');
-assert.equal(noCurrentStillParked.newEvidence, false);
-
-const blindRepairRejected = decideResolveIOAIManagerRecoveryGate({
-	checkpoint: parkedCheckpoint,
-	proposedAction: 'targeted_product_repair',
-	current: {
-		lane: 'repair',
-		stepType: 'repair',
-		failureClass: 'product_code',
-		blocker: 'Save action still throws TypeError.',
-		evidenceHash: 'save-typeerror-before',
-		artifactPaths: ['qa/save-before.log']
-	}
-});
-
-assert.equal(blindRepairRejected.action, 'reject_action');
-assert.equal(blindRepairRejected.reason, 'recovery_gate_product_repair_not_allowed_for_checkpoint');
-
-const newEvidenceUnblocks = decideResolveIOAIManagerRecoveryGate({
-	checkpoint: parkedCheckpoint,
-	current: {
-		lane: 'repair',
-		stepType: 'repair',
-		failureClass: 'product_code',
-		blocker: 'Save action still throws TypeError.',
-		evidenceHash: 'save-typeerror-after-dom-trace',
-		artifactPaths: ['qa/save-before.log', 'qa/save-after-dom-trace.json']
-	}
-});
-
-assert.equal(newEvidenceUnblocks.action, 'allow');
-assert.equal(newEvidenceUnblocks.reason, 'recovery_gate_new_material_evidence_unblocks_retry');
-assert.equal(newEvidenceUnblocks.shouldResetLoopBudget, true);
-assert.equal(newEvidenceUnblocks.canRunProductRepair, true);
-assert.equal(newEvidenceUnblocks.newEvidence, true);
-assert.equal(newEvidenceUnblocks.materialEvidence, true);
-assert.equal(newEvidenceUnblocks.evidenceStrength, 'material');
-
-const weakHashOnlyStillParked = decideResolveIOAIManagerRecoveryGate({
-	checkpoint: parkedCheckpoint,
-	current: {
-		lane: 'repair',
-		stepType: 'repair',
-		failureClass: 'product_code',
-		blocker: 'Save action still throws TypeError.',
-		evidenceHash: 'save-typeerror-renamed-hash-only',
-		artifactPaths: ['qa/save-before.log']
-	}
-});
-
-assert.equal(weakHashOnlyStillParked.action, 'collect_new_evidence');
-assert.equal(weakHashOnlyStillParked.reason, 'recovery_gate_weak_evidence_requires_material_signal');
-assert.equal(weakHashOnlyStillParked.newEvidence, true);
-assert.equal(weakHashOnlyStillParked.materialEvidence, false);
-assert.equal(weakHashOnlyStillParked.evidenceStrength, 'weak');
-assert.equal(weakHashOnlyStillParked.shouldResetLoopBudget, false);
-assert.equal(weakHashOnlyStillParked.canRunProductRepair, false);
-
-const weakHashOnlyPolicy = decideResolveIOAIManagerPolicy({
-	history: [
-		{ lane: 'repair', stepType: 'repair', outcome: 'needs_repair', failureClass: 'product_code', blocker: 'Save action still throws TypeError.', evidenceHash: 'save-typeerror-before' },
-		{ lane: 'repair', stepType: 'repair', outcome: 'needs_repair', failureClass: 'product_code', blocker: 'Save action still throws TypeError.', evidenceHash: 'save-typeerror-renamed-hash-only' }
-	],
-	current: {
-		lane: 'repair',
-		stepType: 'repair',
-		outcome: 'needs_repair',
-		failureClass: 'product_code',
-		blocker: 'Save action still throws TypeError.',
-		evidenceHash: 'save-typeerror-renamed-hash-only'
-	},
-	maxSameFailureRepeats: 2
-});
-
-assert.equal(weakHashOnlyPolicy.action, 'park_repeated_failure');
-assert.equal(weakHashOnlyPolicy.reason, 'manager_policy_same_failure_with_weak_evidence');
-assert.equal(weakHashOnlyPolicy.newEvidence, true);
-assert.equal(weakHashOnlyPolicy.materialEvidence, false);
-assert.equal(weakHashOnlyPolicy.evidenceStrength, 'weak');
-assert.equal(weakHashOnlyPolicy.loopBudgetShouldReset, false);
-
-const materialEvidencePolicy = decideResolveIOAIManagerPolicy({
-	history: [
-		{ lane: 'repair', stepType: 'repair', outcome: 'needs_repair', failureClass: 'product_code', blocker: 'Save action still throws TypeError.', evidenceHash: 'save-typeerror-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 save click reaches the method with an undefined id.',
-			evidenceHash: 'save-typeerror-after-dom-trace',
-			artifactPaths: ['qa/save-before.log', 'qa/save-after-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 save click reaches the method with an undefined id.',
-		evidenceHash: 'save-typeerror-after-dom-trace',
-		artifactPaths: ['qa/save-before.log', 'qa/save-after-dom-trace.json']
-	},
-	maxSameFailureRepeats: 2
-});
-
-assert.equal(materialEvidencePolicy.action, 'continue');
-assert.equal(materialEvidencePolicy.reason, 'manager_policy_new_material_evidence_resets_loop_budget');
-assert.equal(materialEvidencePolicy.newEvidence, true);
-assert.equal(materialEvidencePolicy.materialEvidence, true);
-assert.equal(materialEvidencePolicy.evidenceStrength, 'material');
-assert.equal(materialEvidencePolicy.loopBudgetShouldReset, true);
-
-const infraPlan = buildResolveIOAIManagerRecoveryPlan({
-	action: 'retry_infra',
-	reason: 'puppeteer missing',
-	failureClass: 'infra',
-	lane: 'qa',
-	stepType: 'workflow_qa',
-	blocker: 'Chrome executable missing.'
-});
-const infraCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint({
-	plan: infraPlan,
-	current: {
-		lane: 'qa',
-		stepType: 'workflow_qa',
-		failureClass: 'infra',
-		blocker: 'Chrome executable missing.',
-		evidenceHash: 'chrome-missing'
-	}
-});
-const productRepairOnInfra = decideResolveIOAIManagerRecoveryGate({
-	checkpoint: infraCheckpoint,
-	proposedAction: 'targeted_product_repair',
-	current: {
-		lane: 'qa',
-		stepType: 'workflow_qa',
-		failureClass: 'infra',
-		blocker: 'Chrome executable missing.',
-		evidenceHash: 'chrome-missing'
-	}
-});
-
-assert.equal(productRepairOnInfra.action, 'reject_action');
-assert.equal(productRepairOnInfra.canRunProductRepair, false);
-
-const infraEvidenceProbe = buildResolveIOAIManagerRecoveryEvidenceProbe({
-	checkpoint: infraCheckpoint
-});
-const infraAction = buildResolveIOAIManagerRecoveryActionPacket({
-	checkpoint: infraCheckpoint,
-	probe: infraEvidenceProbe
-});
-
-assert.equal(infraEvidenceProbe.evidenceOnly, true);
-assert.ok(infraEvidenceProbe.steps.some((step) => step.kind === 'infra_preflight'));
-assert.ok(infraEvidenceProbe.requiredArtifacts.some((entry) => /infra-preflight/i.test(entry)));
-assert.equal(infraAction.mode, 'repair_infra');
-assert.equal(infraAction.autoRunnable, true);
-assert.equal(infraAction.productRepairAllowed, false);
-
-const budgetPlan = buildResolveIOAIManagerRecoveryPlan({
-	action: 'budget_stop',
-	reason: 'hard budget guard',
-	failureClass: 'product_code',
-	lane: 'build',
-	stepType: 'build'
-});
-const budgetCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint({
-	plan: budgetPlan,
-	current: {
-		lane: 'build',
-		stepType: 'build',
-		failureClass: 'product_code',
-		blocker: 'Budget guard tripped.',
-		evidenceHash: 'budget-stop'
-	}
-});
-
-assert.equal(decideResolveIOAIManagerRecoveryGate({
-	checkpoint: budgetCheckpoint
-}).action, 'manual_handoff');
-assert.equal(decideResolveIOAIManagerRecoveryGate({
-	checkpoint: budgetCheckpoint,
-	operatorApproved: true
-}).action, 'allow');
-
-console.log('ai manager recovery checkpoint tests passed');