@resolveio/server-lib 22.3.197 → 22.3.198

package/tests/support-runner-v5.test.ts

@@ -1,1473 +0,0 @@
-import * as assert from 'node:assert/strict';
-import {
-	buildResolveIOSupportDiagnosisEvidencePack,
-	buildResolveIOSupportIssueClassProbePlan,
-	buildResolveIOSupportIssueClassProbes,
-	buildResolveIOSupportClarificationContract,
-	buildResolveIOSupportContinuationProofCheckpoint,
-	buildResolveIOSupportManagerExecutionPacket,
-	buildResolveIOSupportV5MicrotaskPrompt,
-	buildResolveIOSupportV5DiagnoseFirstPrompt,
-	buildResolveIOSupportV5Incident,
-	buildResolveIOSupportV5PromptBudget,
-	buildResolveIOSupportV5ScopeDigest,
-	changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles,
-	decideResolveIOSupportCustomerReplyPolicy,
-	decideResolveIOSupportV5AutonomousNextAction,
-	decideResolveIOSupportV5RepairGate,
-	decideResolveIOSupportV5RepeatedFailureStop,
-	decideResolveIOSupportV5Continuation,
-	evaluateResolveIOSupportBusinessProofReadiness,
-	evaluateResolveIOSupportDiagnosisEvidenceQuality,
-	evaluateResolveIOSupportEvidenceFreshness,
-	evaluateResolveIOSupportPreflightGate,
-	extractResolveIOSupportDiagnosisGateFromText,
-	fingerprintResolveIOSupportV5Blocker,
-	initializeResolveIOSupportV5State,
-	recordResolveIOSupportV5MicrotaskUsage,
-	recordResolveIOSupportV5Step,
-	selectResolveIOSupportV5ActiveMicrotask,
-	selectResolveIOSupportSimilarCaseHints,
-	summarizeResolveIOSupportV5MicrotaskUsage,
-	validateResolveIOSupportClarificationContract,
-	validateResolveIOSupportCustomerReplyReadinessContract,
-	validateResolveIOSupportDiagnosisGate,
-	validateResolveIOSupportIssueClassProbePlan,
-	validateResolveIOSupportNextActionContract
-} from '../src/util/support-runner-v5';
-
-const initialized = initializeResolveIOSupportV5State({
-	jobId: 'job-1',
-	ticketId: 'ticket-1',
-	ticketNumber: '004999',
-	title: 'Support ticket #004999',
-	description: 'Fix BOL driver display and QA it.',
-	approvedScopeRequirements: ['BOL driver display', 'disabled driver canonical rejection'],
-	prBranch: 'feature/support-004999',
-	buildThreadKey: 'support:ticket-1:job:job-1:build',
-	qaThreadKey: 'support:ticket-1:job:job-1:qa',
-	now: '2026-06-06T00:00:00.000Z'
-});
-
-assert.equal(initialized.supportWorkflowVersion, 'v5');
-assert.equal(initialized.supportV5SupervisorState.noEmailUnlessApproved, true);
-assert.equal(initialized.supportV5LaneMemory.build.model, 'gpt-5.3-codex');
-assert.equal(initialized.supportV5LaneMemory.qa.model, 'gpt-5.4-mini');
-assert.equal(initialized.supportV5LaneMemory.build.threadKey, 'support:ticket-1:job:job-1:build');
-assert.match(initialized.supportV5SupervisorState.approvedScope, /BOL driver display/);
-assert.ok(initialized.supportV5MicrotaskLedger.length >= 4);
-assert.equal(initialized.supportV5MicrotaskLedger[0].type, 'diagnosis_gate');
-assert.equal(initialized.supportV5MicrotaskLedger[0].lane, 'build');
-assert.equal(initialized.supportV5MicrotaskLedger[1].lane, 'build');
-assert.equal(initialized.supportV5MicrotaskLedger[2].lane, 'qa');
-assert.equal(initialized.supportV5MicrotaskLedger[0].threadKey, 'support:ticket-1:job:job-1:build');
-assert.equal(initialized.supportV5MicrotaskLedger[2].threadKey, 'support:ticket-1:job:job-1:qa');
-assert.equal(initialized.supportV5ActiveMicrotaskId, initialized.supportV5MicrotaskLedger[0].microtaskId);
-assert.equal(selectResolveIOSupportV5ActiveMicrotask(initialized.supportV5MicrotaskLedger)?.type, 'diagnosis_gate');
-assert.match(initialized.supportV5ScopeDigest || '', /Approved scope/);
-assert.equal(validateResolveIOSupportDiagnosisGate(initialized.supportV5DiagnosisGate).valid, false);
-assert.deepEqual(initialized.supportV5RecoveryDispatchHistory, []);
-assert.equal(initialized.supportV5RecoveryDirective, undefined);
-
-const initialDiagnosisEvidencePack = buildResolveIOSupportDiagnosisEvidencePack({
-	issueClass: 'filter_query_mismatch',
-	ownerFiles: ['server/src/publications/support-tickets.ts'],
-	text: 'Support ticket list customer filter returns rows for the wrong customer.',
-	now: '2026-06-06T00:00:00.000Z'
-});
-const initializedWithDiagnosisEvidencePack = initializeResolveIOSupportV5State({
-	jobId: 'job-pack',
-	ticketId: 'ticket-pack',
-	ticketNumber: '004998',
-	title: 'Support ticket #004998',
-	description: 'Preserve diagnosis evidence pack.',
-	existing: {
-		supportV5DiagnosisEvidencePack: initialDiagnosisEvidencePack
-	} as any,
-	now: '2026-06-06T00:00:00.000Z'
-});
-assert.equal(initializedWithDiagnosisEvidencePack.supportV5DiagnosisEvidencePack?.packId, initialDiagnosisEvidencePack.packId);
-assert.equal(initializedWithDiagnosisEvidencePack.supportV5DiagnosisEvidencePack?.sourceEditsAllowed, false);
-
-const validDiagnosis = {
-	issue_case: {
-		customer_complaint: 'Disabled drivers appear in the BOL driver dropdown.',
-		expected_result: 'Disabled drivers are excluded or rejected.',
-		observed_result: 'Disabled driver can be selected.',
-		route_module: '/dashboard/driver/truck-treating/bol-detail/bol/route',
-		account_customer_context: '004999 reporter, truck treating route fixture',
-		reproduction_status: 'reproduced' as const
-	},
-	issue_class: 'filter_query_mismatch' as const,
-	accepted_hypothesis: {
-		statement: 'The driver dropdown publication does not filter disabled users.',
-		falsifiable_test: 'Inspect the publication/method query and run the dropdown with a disabled driver fixture.',
-		evidence: ['Ticket names disabled driver selection.', 'Publication path returns drivers without active filter.']
-	},
-	rejected_alternatives: ['Route auth failure rejected because the BOL page hydrates.', 'Pure CSS issue rejected because persisted selected id changes.'],
-	failing_path: {
-		frontend: 'geochem/angular/app/bol/new/bol-new.component.ts driver select',
-		backend: 'geochem/server/src/publications/drivers.ts',
-		description: 'Frontend driver select consumes an unfiltered backend driver list.'
-	},
-	owner_files: [
-		'geochem/angular/app/bol/new/bol-new.component.ts',
-		'geochem/server/src/publications/drivers.ts'
-	],
-	proof_plan: {
-		before: 'Seed/identify a disabled driver available to the BOL route.',
-		action: 'Open the BOL route, open the driver dropdown, and attempt selecting the disabled driver.',
-		after: 'Disabled driver is absent or rejected and the active driver remains selected.',
-		business_assertion: 'Disabled driver cannot replace the selected active driver.',
-		route: '/dashboard/driver/truck-treating/bol-detail/bol/route',
-		data_assertion: 'Persisted BOL driver id remains active after save attempt.',
-		business_proof_contract: {
-			issue_class: 'filter_query_mismatch' as const,
-			setup_state: 'A BOL route has one active driver and one disabled driver in the candidate dataset.',
-			action_under_test: 'Open the driver dropdown and attempt to choose the disabled driver.',
-			expected_business_state_change: 'The disabled driver is excluded or rejected while the active driver remains selected.',
-			prohibited_false_pass: 'Route load, screenshot visibility, or a populated dropdown alone is not acceptance.',
-			proof_artifacts: ['browser trace', 'dropdown DOM snapshot', 'persisted BOL driver id check'],
-			data_or_dom_assertion: 'The disabled driver option is absent or blocked and the saved BOL driver id remains active.'
-		}
-	},
-	evidence: [
-		{ type: 'ticket' as const, summary: 'Ticket reports disabled driver selection in BOL workflow.' },
-		{ type: 'browser' as const, summary: 'BOL driver dropdown allowed the disabled driver before repair.', artifactPath: 'qa-artifacts/004999-disabled-driver-before.png' },
-		{ type: 'code' as const, summary: 'Publication lacks disabled-user filter.' }
-	],
-	status: 'passed' as const
-};
-
-const validDiagnosisResult = validateResolveIOSupportDiagnosisGate(validDiagnosis);
-assert.equal(validDiagnosisResult.valid, true);
-assert.equal(validDiagnosisResult.normalized?.status, 'passed');
-assert.equal(validDiagnosisResult.evidenceQuality?.hasReproductionEvidence, true);
-assert.equal(validDiagnosisResult.evidenceQuality?.artifactBackedEvidenceCount, 1);
-assert.equal(buildResolveIOSupportIssueClassProbes(validDiagnosis)[0].issue_class, 'filter_query_mismatch');
-assert.match(buildResolveIOSupportIssueClassProbes(validDiagnosis)[0].expected_evidence, /dropdown DOM snapshot/);
-assert.equal(buildResolveIOSupportIssueClassProbes(validDiagnosis)[0].failure_class, 'business');
-assert.equal(buildResolveIOSupportIssueClassProbes(validDiagnosis)[0].acceptance_gate, 'aiqa_business_assertion');
-assert.ok(buildResolveIOSupportIssueClassProbes(validDiagnosis)[0].required_artifacts.some((artifact) => /included\/excluded row proof|dropdown DOM snapshot/i.test(artifact)));
-assert.equal(buildResolveIOSupportIssueClassProbes(validDiagnosis)[0].state_transition.assertion, validDiagnosis.proof_plan.business_proof_contract.data_or_dom_assertion);
-
-const validProbePlan = buildResolveIOSupportIssueClassProbePlan(validDiagnosis, '2026-06-06T00:00:05.000Z');
-const validProbePlanValidation = validateResolveIOSupportIssueClassProbePlan(validProbePlan, validDiagnosis);
-assert.equal(validProbePlan.status, 'ready');
-assert.equal(validProbePlanValidation.valid, true);
-assert.equal(validProbePlan.activeProbe?.issue_class, validDiagnosis.issue_class);
-assert.equal(validProbePlan.activeProbe?.route, validDiagnosis.proof_plan.route);
-assert.equal(validProbePlan.acceptanceGate, 'aiqa_business_assertion');
-assert.ok(validProbePlan.requiredArtifacts.some((artifact) => /dropdown DOM snapshot/i.test(artifact)));
-assert.ok(validProbePlan.falsePassBlockers.some((blocker) => /route screenshot|filter control visible|route loaded|screenshot/i.test(blocker)));
-
-const malformedProbePlan = validateResolveIOSupportIssueClassProbePlan({
-	...validProbePlan,
-	probes: [{
-		...(validProbePlan.activeProbe as any),
-		route: '',
-		required_artifacts: [],
-		state_transition: {
-			...(validProbePlan.activeProbe as any).state_transition,
-			assertion: ''
-		}
-	}]
-}, validDiagnosis);
-assert.equal(malformedProbePlan.valid, false);
-assert.ok(malformedProbePlan.blockers.some((blocker) => /route or module/i.test(blocker)));
-assert.ok(malformedProbePlan.blockers.some((blocker) => /at least two proof artifacts/i.test(blocker)));
-assert.ok(malformedProbePlan.blockers.some((blocker) => /assertion is required/i.test(blocker)));
-
-const similarCaseHints = selectResolveIOSupportSimilarCaseHints({
-	issueClass: validDiagnosis.issue_class,
-	ownerFiles: validDiagnosis.owner_files,
-	text: 'Disabled drivers should not appear in the BOL dropdown.',
-	candidates: [
-		{
-			source: 'airun',
-			id: 'run-accepted-1',
-			ticketNumber: '004333',
-			title: 'Disabled users leaked into driver dropdown',
-			outcome: 'accepted',
-			issueClass: 'filter_query_mismatch',
-			ownerFiles: ['geochem/server/src/publications/drivers.ts'],
-			commitSha: '1111111111111111111111111111111111111111'
-		},
-		{
-			source: 'airun',
-			id: 'run-rejected-1',
-			ticketNumber: '004334',
-			title: 'Rejected guess for dropdown',
-			outcome: 'rejected',
-			issueClass: 'filter_query_mismatch',
-			ownerFiles: ['geochem/server/src/publications/drivers.ts']
-		},
-		{
-			source: 'git_commit',
-			commitSha: '2222222222222222222222222222222222222222',
-			commitMessage: 'Filter disabled driver records before BOL selection',
-			ownerFiles: ['geochem/server/src/publications/drivers.ts']
-		},
-		{
-			source: 'support_ticket',
-			ticketNumber: '004335',
-			title: 'BOL page wording update',
-			outcome: 'accepted',
-			issueClass: 'missing_wrong_data',
-			ownerFiles: ['geochem/angular/app/bol/new/bol-new.component.ts']
-		}
-	],
-	now: '2026-06-06T00:00:10.000Z'
-});
-assert.equal(similarCaseHints.ranked[0].ticketNumber, '004333');
-assert.ok(similarCaseHints.ranked[0].structuredSignals.some((signal) => /issue_class/.test(signal)));
-assert.ok(similarCaseHints.ranked[0].structuredSignals.some((signal) => /owner_file_overlap/.test(signal)));
-assert.equal(similarCaseHints.ranked.some((hint) => hint.ticketNumber === '004334'), false);
-assert.equal(similarCaseHints.similarCommits.some((hint) => hint.commitSha === '2222222222222222222222222222222222222222'), true);
-assert.equal(similarCaseHints.ranked.every((hint) => hint.advisoryOnly === true), true);
-
-const missingDiagnosisEvidencePack = buildResolveIOSupportDiagnosisEvidencePack({
-	bundle: initialized,
-	similarCaseHints,
-	issueClass: validDiagnosis.issue_class,
-	ownerFiles: validDiagnosis.owner_files,
-	text: 'Disabled drivers should not appear in the BOL dropdown.',
-	now: '2026-06-06T00:00:20.000Z'
-});
-assert.equal(missingDiagnosisEvidencePack.status, 'needs_diagnosis');
-assert.equal(missingDiagnosisEvidencePack.readOnly, true);
-assert.equal(missingDiagnosisEvidencePack.sourceEditsAllowed, false);
-assert.equal(missingDiagnosisEvidencePack.requiredOutputKey, 'support_diagnosis_gate');
-assert.ok(missingDiagnosisEvidencePack.requiredFields.includes('accepted_hypothesis'));
-assert.ok(missingDiagnosisEvidencePack.requiredEvidence.some((entry) => /falsifiable root-cause hypothesis/i.test(entry)));
-assert.ok(missingDiagnosisEvidencePack.forbiddenActions.some((entry) => /similar tickets or commits as proof/i.test(entry)));
-assert.equal(missingDiagnosisEvidencePack.similarCaseSelection.ranked[0].ticketNumber, '004333');
-assert.equal(missingDiagnosisEvidencePack.similarCaseSelection.ranked.every((hint) => hint.advisoryOnly === true), true);
-assert.equal(missingDiagnosisEvidencePack.issueClassProbeCatalog.length, 7);
-
-const validDiagnosisEvidencePack = buildResolveIOSupportDiagnosisEvidencePack({
-	diagnosisGate: validDiagnosis,
-	similarCaseHints,
-	now: '2026-06-06T00:00:21.000Z'
-});
-assert.equal(validDiagnosisEvidencePack.status, 'diagnosis_ready');
-assert.equal(validDiagnosisEvidencePack.diagnosisValid, true);
-assert.equal(validDiagnosisEvidencePack.structuredFacts.productRepairBlockedUntilDiagnosisPassed, false);
-assert.ok(validDiagnosisEvidencePack.ownerFileHints.includes('geochem/server/src/publications/drivers.ts'));
-
-const weakDiagnosisEvidence = validateResolveIOSupportDiagnosisGate({
-	...validDiagnosis,
-	similar_tickets: similarCaseHints.similarTickets,
-	similar_commits: similarCaseHints.similarCommits,
-	evidence: [{ type: 'ticket' as const, summary: 'Customer says the driver dropdown is wrong.' }]
-});
-assert.equal(weakDiagnosisEvidence.valid, false);
-assert.ok(weakDiagnosisEvidence.blockers.some((blocker) => /root-cause proof/i.test(blocker)));
-assert.ok(weakDiagnosisEvidence.blockers.some((blocker) => /reproduction evidence/i.test(blocker)));
-
-const unartifactedRuntimeEvidence = validateResolveIOSupportDiagnosisGate({
-	...validDiagnosis,
-	evidence: [
-		{ type: 'ticket' as const, summary: 'Ticket reports disabled driver selection.' },
-		{ type: 'browser' as const, summary: 'Browser reproduced the disabled driver selection.' },
-		{ type: 'code' as const, summary: 'Publication lacks disabled-user filter.' }
-	]
-});
-assert.equal(unartifactedRuntimeEvidence.valid, false);
-assert.ok(unartifactedRuntimeEvidence.blockers.some((blocker) => /artifactPath/i.test(blocker)));
-
-const classifiedCodeOnlyEvidence = validateResolveIOSupportDiagnosisGate({
-	...validDiagnosis,
-	issue_case: {
-		...validDiagnosis.issue_case,
-		reproduction_status: 'classified' as const
-	},
-	evidence: [
-		{ type: 'ticket' as const, summary: 'Ticket gives a complete failing data example.' },
-		{ type: 'code' as const, summary: 'Query inspection found the disabled-driver predicate missing.' }
-	]
-});
-assert.equal(classifiedCodeOnlyEvidence.valid, true);
-assert.equal(evaluateResolveIOSupportDiagnosisEvidenceQuality(classifiedCodeOnlyEvidence.normalized).hasRootCauseEvidence, true);
-
-const blockedDiagnosis = validateResolveIOSupportDiagnosisGate({
-	...validDiagnosis,
-	accepted_hypothesis: { statement: '', falsifiable_test: '', evidence: [] },
-	owner_files: ['geochem/angular/app']
-});
-assert.equal(blockedDiagnosis.valid, false);
-assert.ok(blockedDiagnosis.blockers.some((blocker) => /accepted_hypothesis\.statement/.test(blocker)));
-assert.ok(blockedDiagnosis.blockers.some((blocker) => /broad or unsafe/.test(blocker)));
-
-const routeOnlyDiagnosis = validateResolveIOSupportDiagnosisGate({
-	...validDiagnosis,
-	proof_plan: {
-		before: 'The affected route is available.',
-		action: 'Open the support ticket route.',
-		after: 'The page loads and is visible.',
-		business_assertion: 'The route loads and the page is visible.',
-		route: '/support'
-	}
-});
-assert.equal(routeOnlyDiagnosis.valid, false);
-assert.ok(routeOnlyDiagnosis.blockers.some((blocker) => /route-load|screenshot-only|business state/i.test(blocker)));
-
-const missingProofContractDiagnosis = validateResolveIOSupportDiagnosisGate({
-	...validDiagnosis,
-	proof_plan: {
-		...validDiagnosis.proof_plan,
-		business_proof_contract: undefined
-	}
-});
-assert.equal(missingProofContractDiagnosis.valid, false);
-assert.ok(missingProofContractDiagnosis.blockers.some((blocker) => /business_proof_contract is required/.test(blocker)));
-
-const mismatchedProofContractDiagnosis = validateResolveIOSupportDiagnosisGate({
-	...validDiagnosis,
-	proof_plan: {
-		...validDiagnosis.proof_plan,
-		business_proof_contract: {
-			...validDiagnosis.proof_plan.business_proof_contract,
-			issue_class: 'upload_import' as const
-		}
-	}
-});
-assert.equal(mismatchedProofContractDiagnosis.valid, false);
-assert.ok(mismatchedProofContractDiagnosis.blockers.some((blocker) => /must match diagnosis issue_class/.test(blocker)));
-
-const safeCustomerReplyPolicy = decideResolveIOSupportCustomerReplyPolicy({
-	diagnosisGate: validDiagnosis,
-	outcomeLabel: 'accepted',
-	confidence: { level: 'high', category: 'repo_fix', shouldBlockPr: false },
-	businessAssertionStatus: 'pass',
-	businessProofArtifacts: ['qa-artifacts/disabled-driver-dropdown.png'],
-	releaseStatus: 'completed'
-});
-assert.equal(safeCustomerReplyPolicy.action, 'draft_resolution_reply');
-assert.equal(safeCustomerReplyPolicy.canDraftCustomerReply, true);
-assert.equal(safeCustomerReplyPolicy.canSendCustomerReply, false);
-assert.equal(safeCustomerReplyPolicy.draftBasis?.issueClass, 'filter_query_mismatch');
-assert.ok(safeCustomerReplyPolicy.draftBasis?.issueClassProbePlanId);
-assert.equal(safeCustomerReplyPolicy.draftBasis?.issueClassProbePlanStatus, 'ready');
-assert.equal(safeCustomerReplyPolicy.humanReviewPacket?.reviewType, 'customer_resolution_reply');
-assert.equal(safeCustomerReplyPolicy.humanReviewPacket?.primaryAction, 'review_customer_reply');
-assert.equal(safeCustomerReplyPolicy.humanReviewPacket?.customerFacingDraftAllowed, true);
-assert.equal(safeCustomerReplyPolicy.humanReviewPacket?.customerSendAllowed, false);
-assert.equal(safeCustomerReplyPolicy.humanReviewPacket?.requiresHumanApproval, true);
-assert.equal(safeCustomerReplyPolicy.readinessContract?.status, 'draft_ready');
-assert.equal(safeCustomerReplyPolicy.readinessContract?.primaryCommand, 'review_customer_reply');
-assert.equal(safeCustomerReplyPolicy.readinessContract?.canDraftCustomerReply, true);
-assert.equal(safeCustomerReplyPolicy.readinessContract?.canSendCustomerReply, false);
-assert.equal(safeCustomerReplyPolicy.readinessContract?.requiresHumanApproval, true);
-assert.equal(safeCustomerReplyPolicy.readinessContract?.proofBacked, true);
-assert.equal(validateResolveIOSupportCustomerReplyReadinessContract(safeCustomerReplyPolicy.readinessContract).valid, true);
-const unsafeAutoSendReadiness = validateResolveIOSupportCustomerReplyReadinessContract({
-	...safeCustomerReplyPolicy.readinessContract,
-	canSendCustomerReply: true
-});
-assert.equal(unsafeAutoSendReadiness.valid, false);
-assert.ok(unsafeAutoSendReadiness.blockers.some((blocker) => /never allow automatic customer send/i.test(blocker)));
-
-const malformedProbeReplyPolicy = decideResolveIOSupportCustomerReplyPolicy({
-	diagnosisGate: validDiagnosis,
-	issueClassProbePlan: malformedProbePlan.normalized,
-	outcomeLabel: 'accepted',
-	confidence: { level: 'high', category: 'repo_fix', shouldBlockPr: false },
-	businessAssertionStatus: 'pass',
-	businessProofArtifacts: ['qa-artifacts/disabled-driver-dropdown.png'],
-	releaseStatus: 'completed'
-});
-assert.equal(malformedProbeReplyPolicy.action, 'hold_internal');
-assert.equal(malformedProbeReplyPolicy.canDraftCustomerReply, false);
-assert.equal(malformedProbeReplyPolicy.reason, 'support_reply_requires_valid_issue_class_probe_plan');
-assert.equal(malformedProbeReplyPolicy.humanReviewPacket?.primaryAction, 'repair_support_issue_class_probe_plan');
-assert.ok(malformedProbeReplyPolicy.humanReviewPacket?.blockers.some((blocker) => /Issue-class probe/i.test(blocker)));
-
-const missingHotfixProofReplyPolicy = decideResolveIOSupportCustomerReplyPolicy({
-	diagnosisGate: validDiagnosis,
-	outcomeLabel: 'accepted',
-	confidence: { level: 'high', category: 'repo_fix', shouldBlockPr: false },
-	businessAssertionStatus: 'pass',
-	businessProofArtifacts: ['qa-artifacts/disabled-driver-dropdown.png'],
-	releaseStatus: 'completed',
-	releaseEvidence: {
-		hotfix_commit_proof: {
-			required: true,
-			blocked: true,
-			passed: false,
-			missing_fields: ['gitCommitStatus=passed']
-		},
-		hotfix_evidence: {
-			status: 'incomplete',
-			manager_must_commit_before_hotfix: true,
-			missing_fields: ['gitCommitStatus=passed']
-		}
-	}
-});
-assert.equal(missingHotfixProofReplyPolicy.action, 'hold_internal');
-assert.equal(missingHotfixProofReplyPolicy.canDraftCustomerReply, false);
-assert.equal(missingHotfixProofReplyPolicy.reason, 'support_reply_blocked_until_release_or_hotfix_gate_finishes');
-assert.equal(missingHotfixProofReplyPolicy.humanReviewPacket?.primaryAction, 'repair_release_hotfix_first');
-assert.ok(missingHotfixProofReplyPolicy.humanReviewPacket?.blockers.some((blocker) => /hotfix_commit_proof|gitCommitStatus/i.test(blocker)));
-assert.ok(missingHotfixProofReplyPolicy.requiredEvidence.some((entry) => /gitCommitStatus=passed/i.test(entry)));
-assert.equal(missingHotfixProofReplyPolicy.readinessContract?.status, 'blocked_until_release_hotfix');
-assert.equal(missingHotfixProofReplyPolicy.readinessContract?.primaryCommand, 'repair_release_hotfix_first');
-assert.equal(missingHotfixProofReplyPolicy.readinessContract?.canDraftCustomerReply, false);
-assert.equal(missingHotfixProofReplyPolicy.readinessContract?.releaseReady, false);
-assert.equal(validateResolveIOSupportCustomerReplyReadinessContract(missingHotfixProofReplyPolicy.readinessContract).valid, true);
-
-const matchedBusinessProofReadiness = evaluateResolveIOSupportBusinessProofReadiness({
-	diagnosisGate: validDiagnosis,
-	businessAssertions: [{
-		assertion: validDiagnosis.proof_plan.business_assertion,
-		status: 'pass',
-		workflow: validDiagnosis.proof_plan.business_proof_contract.action_under_test,
-		action: validDiagnosis.proof_plan.action,
-		expected: validDiagnosis.proof_plan.business_proof_contract.expected_business_state_change,
-		observed: 'The disabled driver option is absent and the active driver remains selected.',
-		dataProof: validDiagnosis.proof_plan.business_proof_contract.data_or_dom_assertion,
-		artifactPaths: ['qa-artifacts/disabled-driver-business-proof.json'],
-		metadata: { supportDiagnosisProof: true }
-	}]
-});
-assert.equal(matchedBusinessProofReadiness.ready, true);
-assert.equal(matchedBusinessProofReadiness.status, 'passed');
-assert.equal(matchedBusinessProofReadiness.artifactPaths[0], 'qa-artifacts/disabled-driver-business-proof.json');
-assert.ok(matchedBusinessProofReadiness.proofFingerprint);
-assert.ok(matchedBusinessProofReadiness.artifactFingerprint);
-assert.equal(matchedBusinessProofReadiness.proofFreshness, 'fresh');
-
-const staleBusinessProofReadiness = evaluateResolveIOSupportBusinessProofReadiness({
-	diagnosisGate: validDiagnosis,
-	previousProofFingerprint: matchedBusinessProofReadiness.proofFingerprint,
-	businessAssertions: [{
-		assertion: validDiagnosis.proof_plan.business_assertion,
-		status: 'pass',
-		workflow: validDiagnosis.proof_plan.business_proof_contract.action_under_test,
-		action: validDiagnosis.proof_plan.action,
-		expected: validDiagnosis.proof_plan.business_proof_contract.expected_business_state_change,
-		observed: 'The disabled driver option is absent and the active driver remains selected.',
-		dataProof: validDiagnosis.proof_plan.business_proof_contract.data_or_dom_assertion,
-		artifactPaths: ['qa-artifacts/disabled-driver-business-proof.json'],
-		metadata: { supportDiagnosisProof: true }
-	}]
-});
-assert.equal(staleBusinessProofReadiness.ready, false);
-assert.equal(staleBusinessProofReadiness.status, 'stale');
-assert.equal(staleBusinessProofReadiness.proofFreshness, 'same_as_previous');
-assert.equal(staleBusinessProofReadiness.reason, 'support_business_proof_same_fingerprint_as_previous');
-
-const routeOnlyBusinessProofReadiness = evaluateResolveIOSupportBusinessProofReadiness({
-	diagnosisGate: validDiagnosis,
-	outcomeLabel: 'accepted',
-	businessAssertionStatus: 'route_probe_pass',
-	businessProofArtifacts: ['qa-artifacts/route-loaded.png']
-});
-assert.equal(routeOnlyBusinessProofReadiness.ready, false);
-assert.equal(routeOnlyBusinessProofReadiness.status, 'route_only');
-assert.ok(routeOnlyBusinessProofReadiness.blockers.some((blocker) => /Route probe/i.test(blocker)));
-
-const blockedAssertionReadiness = evaluateResolveIOSupportBusinessProofReadiness({
-	diagnosisGate: validDiagnosis,
-	businessAssertions: [{
-		assertion: 'The route loaded.',
-		status: 'pass',
-		artifactPaths: ['qa-artifacts/route-loaded.png'],
-		acceptanceBlocked: true,
-		metadata: { routeOnly: true }
-	}]
-});
-assert.equal(blockedAssertionReadiness.ready, false);
-assert.equal(blockedAssertionReadiness.reason, 'support_business_proof_route_only_or_acceptance_blocked');
-
-const routeOnlyReplyPolicy = decideResolveIOSupportCustomerReplyPolicy({
-	diagnosisGate: validDiagnosis,
-	outcomeLabel: 'accepted',
-	confidence: { level: 'high', category: 'repo_fix', shouldBlockPr: false },
-	businessAssertionStatus: 'route_probe_pass',
-	businessProofArtifacts: ['qa-artifacts/route-loaded.png'],
-	releaseStatus: 'completed'
-});
-assert.equal(routeOnlyReplyPolicy.action, 'hold_internal');
-assert.equal(routeOnlyReplyPolicy.reason, 'support_reply_rejects_route_only_business_proof');
-assert.equal(routeOnlyReplyPolicy.readinessContract?.status, 'blocked_until_business_proof');
-assert.equal(routeOnlyReplyPolicy.readinessContract?.primaryCommand, 'run_support_v5_business_proof_qa_row');
-assert.equal(routeOnlyReplyPolicy.readinessContract?.canDraftCustomerReply, false);
-assert.equal(validateResolveIOSupportCustomerReplyReadinessContract(routeOnlyReplyPolicy.readinessContract).valid, true);
-
-const staleReplyPolicy = decideResolveIOSupportCustomerReplyPolicy({
-	diagnosisGate: validDiagnosis,
-	outcomeLabel: 'accepted',
-	confidence: { level: 'high', category: 'repo_fix', shouldBlockPr: false },
-	businessAssertions: [{
-		assertion: validDiagnosis.proof_plan.business_assertion,
-		status: 'pass',
-		workflow: validDiagnosis.proof_plan.business_proof_contract.action_under_test,
-		action: validDiagnosis.proof_plan.action,
-		expected: validDiagnosis.proof_plan.business_proof_contract.expected_business_state_change,
-		observed: 'The disabled driver option is absent and the active driver remains selected.',
-		dataProof: validDiagnosis.proof_plan.business_proof_contract.data_or_dom_assertion,
-		artifactPaths: ['qa-artifacts/disabled-driver-business-proof.json'],
-		metadata: { supportDiagnosisProof: true }
-	}],
-	previousProofFingerprint: matchedBusinessProofReadiness.proofFingerprint,
-	releaseStatus: 'completed'
-});
-assert.equal(staleReplyPolicy.action, 'hold_internal');
-assert.equal(staleReplyPolicy.reason, 'support_reply_requires_business_assertion_pass');
-assert.ok(staleReplyPolicy.humanReviewPacket?.blockers.some((blocker) => /new proof\/artifact fingerprint/i.test(blocker)));
-
-const lowConfidenceReplyPolicy = decideResolveIOSupportCustomerReplyPolicy({
-	diagnosisGate: validDiagnosis,
-	outcomeLabel: 'accepted',
-	confidence: { level: 'medium', category: 'repo_fix', shouldBlockPr: false },
-	businessAssertionStatus: 'pass',
-	businessProofArtifacts: ['qa-artifacts/disabled-driver-dropdown.png'],
-	releaseStatus: 'completed'
-});
-assert.equal(lowConfidenceReplyPolicy.action, 'hold_internal');
-assert.equal(lowConfidenceReplyPolicy.reason, 'support_reply_requires_high_confidence');
-
-const clarificationReplyPolicy = decideResolveIOSupportCustomerReplyPolicy({
-	diagnosisGate: {
-		...validDiagnosis,
-		issue_case: {
-			...validDiagnosis.issue_case,
-			reproduction_status: 'blocked' as const,
-			reproduction_blocker: 'Need the exact BOL number where the disabled driver appears.'
-		},
-		accepted_hypothesis: { statement: '', falsifiable_test: '', evidence: [] }
-	},
-	confidence: { level: 'low' }
-});
-assert.equal(clarificationReplyPolicy.action, 'ask_clarification');
-assert.equal(clarificationReplyPolicy.canSendCustomerReply, false);
-assert.match(clarificationReplyPolicy.clarificationQuestion || '', /exact BOL number/);
-assert.equal(clarificationReplyPolicy.clarificationContract?.status, 'ready');
-assert.equal(clarificationReplyPolicy.clarificationContract?.missingField, 'reproduction_blocker');
-assert.equal(clarificationReplyPolicy.clarificationContract?.oneQuestionOnly, true);
-assert.equal(clarificationReplyPolicy.clarificationContract?.customerSendAllowed, false);
-assert.equal(clarificationReplyPolicy.clarificationContract?.parksTicketUntilCustomerReply, true);
-assert.ok(clarificationReplyPolicy.clarificationContract?.nextCommands.includes('park_ticket_until_customer_reply'));
-assert.equal(clarificationReplyPolicy.humanReviewPacket?.reviewType, 'customer_clarification');
-assert.equal(clarificationReplyPolicy.humanReviewPacket?.primaryAction, 'review_customer_clarification');
-assert.match(clarificationReplyPolicy.humanReviewPacket?.question || '', /exact BOL number/);
-assert.equal(clarificationReplyPolicy.humanReviewPacket?.customerSendAllowed, false);
-assert.ok(clarificationReplyPolicy.humanReviewPacket?.forbiddenActions.some((action) => /guessed reproduction path/i.test(action)));
-assert.equal(clarificationReplyPolicy.readinessContract?.status, 'clarification_required');
-assert.equal(clarificationReplyPolicy.readinessContract?.primaryCommand, 'review_customer_clarification');
-assert.equal(clarificationReplyPolicy.readinessContract?.clarificationRequired, true);
-assert.equal(clarificationReplyPolicy.readinessContract?.canSendCustomerReply, false);
-assert.equal(validateResolveIOSupportCustomerReplyReadinessContract(clarificationReplyPolicy.readinessContract).valid, true);
-
-const validClarificationContract = validateResolveIOSupportClarificationContract(
-	buildResolveIOSupportClarificationContract(
-		clarificationReplyPolicy.clarificationContract ? {
-			...validDiagnosis,
-			issue_case: {
-				...validDiagnosis.issue_case,
-				reproduction_status: 'blocked' as const,
-				reproduction_blocker: 'Need the exact BOL number where the disabled driver appears.'
-			}
-		} : undefined,
-		['issue_case.reproduction_blocker is required when reproduction_status=blocked']
-	)
-);
-assert.equal(validClarificationContract.valid, true);
-assert.equal(validClarificationContract.normalized.oneQuestionOnly, true);
-
-const multiQuestionClarificationContract = validateResolveIOSupportClarificationContract({
-	...validClarificationContract.normalized,
-	question: 'Which BOL number is affected? Which account should we use?'
-});
-assert.equal(multiQuestionClarificationContract.valid, false);
-assert.ok(multiQuestionClarificationContract.blockers.some((blocker) => /exactly one customer question/i.test(blocker)));
-
-const diagnosisJson = JSON.stringify({ support_diagnosis_gate: validDiagnosis });
-assert.equal(extractResolveIOSupportDiagnosisGateFromText(`\`\`\`json\n${diagnosisJson}\n\`\`\``)?.issue_class, 'filter_query_mismatch');
-
-const diagnosedBundle = recordResolveIOSupportV5Step(initialized, {
-	stepType: 'diagnosis_gate',
-	outcome: 'pass',
-	lane: 'build',
-	summary: diagnosisJson,
-	diagnosisGate: validDiagnosis,
-	now: '2026-06-06T00:00:30.000Z'
-});
-assert.equal(diagnosedBundle.supportV5DiagnosisGate?.status, 'passed');
-assert.deepEqual(diagnosedBundle.supportV5MicrotaskLedger[1].targetFiles, validDiagnosis.owner_files);
-assert.equal(diagnosedBundle.supportV5IssueClassProbePlan?.status, 'ready');
-assert.equal(diagnosedBundle.supportV5IssueClassProbePlan?.activeProbe?.issue_class, validDiagnosis.issue_class);
-assert.equal(diagnosedBundle.supportV5MicrotaskLedger[2].contextRefs.includes('supportV5IssueClassProbePlan'), true);
-assert.equal(diagnosedBundle.supportV5LaneMemory.qa.activeQaRow?.workflow, validDiagnosis.proof_plan.business_proof_contract.action_under_test);
-assert.equal(diagnosedBundle.supportV5LaneMemory.qa.activeQaRow?.assertion, validDiagnosis.proof_plan.business_proof_contract.data_or_dom_assertion);
-assert.equal(diagnosedBundle.supportV5RecoveryPlan?.recoveryClass, 'advance_after_proof');
-assert.equal(diagnosedBundle.supportV5RecoveryCheckpoint?.recoveryClass, 'advance_after_proof');
-assert.equal(diagnosedBundle.supportV5RecoveryAction?.checkpointId, diagnosedBundle.supportV5RecoveryCheckpoint?.checkpointId);
-const failedPuppeteerPreflight = evaluateResolveIOSupportPreflightGate({
-	required: true,
-	checks: [
-		{ name: 'puppeteer_module', status: 'fail', summary: 'Cannot require puppeteer from the QA workspace.', artifactPath: 'qa-artifacts/preflight/puppeteer.log' },
-		{ name: 'chrome_executable', status: 'pass', summary: 'Chrome executable exists.' },
-		{ name: 'mongo_connection', status: 'pass', summary: 'Mongo ping ok.' }
-	],
-	recordedAt: '2026-06-06T00:00:35.000Z'
-});
-assert.equal(failedPuppeteerPreflight.status, 'infra_failed');
-assert.equal(failedPuppeteerPreflight.failureClass, 'infra');
-assert.equal(failedPuppeteerPreflight.blocksProductRepair, true);
-assert.equal(failedPuppeteerPreflight.nextCommand, 'run_support_v5_infra_repair');
-assert.ok(failedPuppeteerPreflight.requiredEvidence.some((entry) => /Puppeteer\/Chrome\/server\/client\/Mongo/i.test(entry)));
-const compilePreflight = evaluateResolveIOSupportPreflightGate({
-	required: true,
-	compileResult: {
-		status: 'fail',
-		summary: 'Angular compile failed on support ticket bundle.',
-		artifactPath: 'qa-artifacts/preflight/compile.log'
-	}
-});
-assert.equal(compilePreflight.status, 'compile_failed');
-assert.equal(compilePreflight.failureClass, 'compile');
-assert.equal(compilePreflight.nextCommand, 'run_support_v5_compile_repair');
-const persistedPreflightBundle = recordResolveIOSupportV5Step(diagnosedBundle, {
-	stepType: 'compile_check',
-	outcome: 'needs_repair',
-	lane: 'qa',
-	summary: 'Compile preflight failed before repair loop.',
-	preflightGate: compilePreflight,
-	failureClass: 'compile',
-	now: '2026-06-06T00:00:36.000Z'
-});
-assert.equal(persistedPreflightBundle.supportV5PreflightGate?.status, 'compile_failed');
-assert.equal(persistedPreflightBundle.supportV5StepHistory[persistedPreflightBundle.supportV5StepHistory.length - 1].preflightGate?.nextCommand, 'run_support_v5_compile_repair');
-const diagnosisMicrotaskId = diagnosedBundle.supportV5MicrotaskLedger.find((task) => task.type === 'diagnosis_gate')?.microtaskId;
-const buildMicrotasksAfterDiagnosis = diagnosedBundle.supportV5MicrotaskLedger.filter((task) => task.lane === 'build' && task.type !== 'diagnosis_gate');
-assert.ok(diagnosisMicrotaskId);
-assert.ok(buildMicrotasksAfterDiagnosis.length > 0);
-assert.ok(buildMicrotasksAfterDiagnosis.every((task) => task.dependsOn.includes(diagnosisMicrotaskId || '')));
-assert.ok(buildMicrotasksAfterDiagnosis.every((task) => task.dependsOn.length === new Set(task.dependsOn).size));
-assert.equal(changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles(validDiagnosis, [
-	'geochem/angular/app/bol/new/bol-new.component.ts',
-	'geochem/server/src/methods/unrelated.ts'
-]).length, 1);
-
-const initialAutonomousDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: initialized
-});
-assert.equal(initialAutonomousDecision.action, 'run_diagnosis_gate');
-assert.equal(initialAutonomousDecision.canRunAutonomously, true);
-assert.equal(initialAutonomousDecision.canEditProductCode, false);
-assert.equal(initialAutonomousDecision.rootCauseReadiness.status, 'diagnosis_required');
-assert.equal(initialAutonomousDecision.rootCauseReadiness.rootCauseFirstSatisfied, false);
-assert.equal(initialAutonomousDecision.rootCauseReadiness.nextGate, 'diagnosis');
-assert.equal(initialAutonomousDecision.evidenceFreshness.status, 'missing');
-assert.equal(initialAutonomousDecision.evidenceFreshness.mustCollectNewEvidence, false);
-assert.equal(initialAutonomousDecision.continuationProofCheckpoint.action, 'run_diagnosis_gate');
-assert.equal(initialAutonomousDecision.continuationProofCheckpoint.blocksProductRepairUntilChangedEvidence, true);
-assert.ok(initialAutonomousDecision.continuationProofCheckpoint.requiredResetEvidence.some((entry) => /SupportDiagnosisGate/i.test(entry)));
-assert.equal(initialAutonomousDecision.nextActionContract.action, 'run_diagnosis_gate');
-assert.equal(initialAutonomousDecision.nextActionContract.safeToAutoRun, true);
-assert.equal(initialAutonomousDecision.nextActionContract.canRunWithoutCodexMonitor, true);
-assert.equal(initialAutonomousDecision.nextActionContract.codexFallbackRequired, false);
-assert.equal(initialAutonomousDecision.nextActionContract.rootCauseFirstSatisfied, false);
-assert.ok(initialAutonomousDecision.nextActionContract.preconditions.some((entry) => /read-only/i.test(entry)));
-assert.ok(initialAutonomousDecision.nextActionContract.expectedStateTransition.includes('SupportDiagnosisGate changes'));
-assert.equal(validateResolveIOSupportNextActionContract(initialAutonomousDecision.nextActionContract).valid, true);
-assert.equal(initialAutonomousDecision.managerExecutionPacket.status, 'auto_ready');
-assert.equal(initialAutonomousDecision.managerExecutionPacket.executeNow, true);
-assert.equal(initialAutonomousDecision.managerExecutionPacket.retryScope, 'diagnosis_only');
-assert.equal(initialAutonomousDecision.managerExecutionPacket.canRunWithoutCodexMonitor, true);
-assert.ok(initialAutonomousDecision.managerExecutionPacket.proofRequiredBeforeContinuation.some((entry) => /SupportDiagnosisGate changes/i.test(entry)));
-assert.ok(initialAutonomousDecision.forbiddenActions.some((action) => /No source edits/i.test(action)));
-
-const blockedReproductionDiagnosis = {
-	...validDiagnosis,
-	issue_case: {
-		...validDiagnosis.issue_case,
-		reproduction_status: 'blocked' as const,
-		reproduction_blocker: 'Need the exact BOL number where the disabled driver appears.'
-	},
-	accepted_hypothesis: { statement: '', falsifiable_test: '', evidence: [] }
-};
-const clarificationAutonomousDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: {
-		...initialized,
-		supportV5DiagnosisGate: blockedReproductionDiagnosis
-	}
-});
-assert.equal(clarificationAutonomousDecision.action, 'ask_customer_clarification');
-assert.equal(clarificationAutonomousDecision.primaryCommand, 'review_customer_clarification');
-assert.equal(clarificationAutonomousDecision.canRunAutonomously, false);
-assert.equal(clarificationAutonomousDecision.canRunModel, false);
-assert.equal(clarificationAutonomousDecision.canEditProductCode, false);
-assert.equal(clarificationAutonomousDecision.canDraftCustomerReply, true);
-assert.equal(clarificationAutonomousDecision.rootCauseReadiness.status, 'customer_clarification_required');
-assert.equal(clarificationAutonomousDecision.rootCauseReadiness.nextGate, 'customer_reply');
-assert.equal(clarificationAutonomousDecision.rootCauseReadiness.requiresHumanDecision, true);
-assert.equal(clarificationAutonomousDecision.nextActionContract.safeToAutoRun, false);
-assert.equal(clarificationAutonomousDecision.nextActionContract.canRunWithoutCodexMonitor, false);
-assert.equal(clarificationAutonomousDecision.nextActionContract.codexFallbackRequired, false);
-assert.equal(clarificationAutonomousDecision.nextActionContract.codexFallbackReason, 'human_decision_required_not_codex_fallback');
-assert.match(clarificationAutonomousDecision.humanReviewPacket.question || '', /exact BOL number/);
-assert.ok(clarificationAutonomousDecision.forbiddenActions.some((action) => /guessed reproduction path/i.test(action)));
-
-const ownerScopedAutonomousDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: diagnosedBundle,
-	changedFiles: ['geochem/angular/app/bol/new/bol-new.component.ts']
-});
-assert.equal(ownerScopedAutonomousDecision.action, 'run_owner_scoped_repair');
-assert.equal(ownerScopedAutonomousDecision.canEditProductCode, true);
-assert.equal(ownerScopedAutonomousDecision.rootCauseReadiness.status, 'owner_scoped_repair_ready');
-assert.equal(ownerScopedAutonomousDecision.rootCauseReadiness.rootCauseFirstSatisfied, true);
-assert.equal(ownerScopedAutonomousDecision.rootCauseReadiness.canEditProductCode, true);
-assert.equal(ownerScopedAutonomousDecision.rootCauseReadiness.ownerFilesReady, true);
-assert.deepEqual(ownerScopedAutonomousDecision.ownerFiles, validDiagnosis.owner_files);
-assert.equal(ownerScopedAutonomousDecision.issueClassProbes[0].acceptance_gate, 'aiqa_business_assertion');
-assert.equal(ownerScopedAutonomousDecision.rootCauseReadiness.issueClassProbes?.[0].failure_class, 'business');
-assert.match(ownerScopedAutonomousDecision.primaryCommand, /owner_scoped_repair/);
-assert.equal(ownerScopedAutonomousDecision.continuationProofCheckpoint.action, 'run_owner_scoped_repair');
-assert.equal(ownerScopedAutonomousDecision.continuationProofCheckpoint.blocksProductRepairUntilChangedEvidence, false);
-assert.equal(ownerScopedAutonomousDecision.continuationProofCheckpoint.status, 'waiting_for_proof');
-assert.equal(ownerScopedAutonomousDecision.nextActionContract.safeToAutoRun, true);
-assert.equal(ownerScopedAutonomousDecision.nextActionContract.canRunWithoutCodexMonitor, true);
-assert.equal(ownerScopedAutonomousDecision.nextActionContract.codexFallbackRequired, false);
-assert.equal(ownerScopedAutonomousDecision.nextActionContract.costRisk, 'expensive_model');
-assert.equal(ownerScopedAutonomousDecision.nextActionContract.decisionBasis.diagnosisValid, true);
-assert.equal(ownerScopedAutonomousDecision.nextActionContract.decisionBasis.ownerFilesReady, true);
-assert.ok(ownerScopedAutonomousDecision.nextActionContract.stopConditions.some((entry) => /outside diagnosis owner_files/i.test(entry)));
-assert.equal(validateResolveIOSupportNextActionContract(ownerScopedAutonomousDecision.nextActionContract).valid, true);
-assert.equal(ownerScopedAutonomousDecision.managerExecutionPacket.status, 'auto_ready');
-assert.equal(ownerScopedAutonomousDecision.managerExecutionPacket.retryScope, 'owner_files_only');
-assert.equal(ownerScopedAutonomousDecision.managerExecutionPacket.maxAttemptsBeforeFreshEvidence, 1);
-assert.deepEqual(ownerScopedAutonomousDecision.managerExecutionPacket.ownerFiles, validDiagnosis.owner_files);
-
-const malformedOwnerRepairContract = validateResolveIOSupportNextActionContract({
-	...ownerScopedAutonomousDecision.nextActionContract,
-	rootCauseFirstSatisfied: false,
-	ownerFiles: []
-});
-assert.equal(malformedOwnerRepairContract.valid, false);
-assert.ok(malformedOwnerRepairContract.blockers.some((blocker) => /rootCauseFirstSatisfied|ownerFiles/i.test(blocker)));
-const blockedOwnerRepairPacket = buildResolveIOSupportManagerExecutionPacket({
-	...ownerScopedAutonomousDecision.nextActionContract,
-	rootCauseFirstSatisfied: false,
-	ownerFiles: []
-});
-assert.equal(blockedOwnerRepairPacket.status, 'blocked');
-assert.equal(blockedOwnerRepairPacket.executeNow, false);
-
-const outOfScopeAutonomousDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: diagnosedBundle,
-	changedFiles: ['geochem/server/src/methods/unrelated.ts']
-});
-assert.equal(outOfScopeAutonomousDecision.action, 'revise_diagnosis_scope');
-assert.equal(outOfScopeAutonomousDecision.canEditProductCode, false);
-assert.ok(outOfScopeAutonomousDecision.blockers.some((blocker) => /outside diagnosis owner_files/i.test(blocker)));
-
-const infraAutonomousDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: diagnosedBundle,
-	failureClass: 'infra',
-	blocker: 'Puppeteer executable missing.'
-});
-assert.equal(infraAutonomousDecision.action, 'repair_infra_only');
-assert.equal(infraAutonomousDecision.canRunAutonomously, true);
-assert.equal(infraAutonomousDecision.canEditProductCode, false);
-assert.equal(infraAutonomousDecision.canRunModel, false);
-assert.equal(infraAutonomousDecision.rootCauseReadiness.status, 'infra_repair_only');
-assert.equal(infraAutonomousDecision.rootCauseReadiness.infraOnly, true);
-assert.equal(infraAutonomousDecision.rootCauseReadiness.canEditProductCode, false);
-assert.equal(infraAutonomousDecision.evidenceFreshness.status, 'infra_ignored');
-assert.equal(infraAutonomousDecision.evidenceFreshness.productRepairFailure, false);
-
-const preflightBlockedAutonomousDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: diagnosedBundle,
-	preflightGate: failedPuppeteerPreflight
-});
-assert.equal(preflightBlockedAutonomousDecision.action, 'repair_infra_only');
-assert.equal(preflightBlockedAutonomousDecision.primaryCommand, 'run_support_v5_infra_repair');
-assert.equal(preflightBlockedAutonomousDecision.canRunModel, false);
-assert.equal(preflightBlockedAutonomousDecision.canEditProductCode, false);
-assert.equal(preflightBlockedAutonomousDecision.preflightGate.status, 'infra_failed');
-assert.equal(preflightBlockedAutonomousDecision.rootCauseReadiness.preflightReady, false);
-assert.equal(preflightBlockedAutonomousDecision.rootCauseReadiness.rootCauseFirstSatisfied, false);
-assert.equal(preflightBlockedAutonomousDecision.nextActionContract.decisionBasis.preflightStatus, 'infra_failed');
-assert.ok(preflightBlockedAutonomousDecision.nextActionContract.successEvidence.some((entry) => /Puppeteer\/Chrome\/server\/client\/Mongo/i.test(entry)));
-
-const compilePreflightAutonomousDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: diagnosedBundle,
-	preflightGate: compilePreflight
-});
-assert.equal(compilePreflightAutonomousDecision.action, 'repair_infra_only');
-assert.equal(compilePreflightAutonomousDecision.label, 'Repair Compile Only');
-assert.equal(compilePreflightAutonomousDecision.primaryCommand, 'run_support_v5_compile_repair');
-assert.equal(compilePreflightAutonomousDecision.canRunModel, false);
-assert.equal(compilePreflightAutonomousDecision.nextActionContract.decisionBasis.preflightFailureClass, 'compile');
-assert.ok(compilePreflightAutonomousDecision.requiredEvidence.some((entry) => /compile command output/i.test(entry)));
-
-const missingRequiredPreflightAutonomousDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: diagnosedBundle,
-	preflightGate: { required: true }
-});
-assert.equal(missingRequiredPreflightAutonomousDecision.action, 'repair_infra_only');
-assert.equal(missingRequiredPreflightAutonomousDecision.primaryCommand, 'run_support_v5_preflight');
-assert.equal(missingRequiredPreflightAutonomousDecision.canRunModel, false);
-assert.ok(missingRequiredPreflightAutonomousDecision.requiredEvidence.some((entry) => /support preflight result/i.test(entry)));
-
-const pendingReleaseDoesNotPreemptRepairDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: diagnosedBundle,
-	releaseStatus: 'pending_manual'
-});
-assert.equal(pendingReleaseDoesNotPreemptRepairDecision.action, 'run_owner_scoped_repair');
-assert.equal(pendingReleaseDoesNotPreemptRepairDecision.canEditProductCode, true);
-
-const releaseNeedsCommittedHotfixDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: diagnosedBundle,
-	releaseStatus: 'failed',
-	unresolvedBlockers: ['Duplicate deploy loop after a backend runner hotfix.']
-});
-assert.equal(releaseNeedsCommittedHotfixDecision.action, 'repair_release_hotfix_first');
-assert.equal(releaseNeedsCommittedHotfixDecision.primaryCommand, 'record_hotfix_evidence');
-assert.equal(releaseNeedsCommittedHotfixDecision.canEditProductCode, false);
-assert.equal(releaseNeedsCommittedHotfixDecision.canRunModel, false);
-assert.equal(releaseNeedsCommittedHotfixDecision.canPrepareHotfixPatch, true);
-assert.equal(releaseNeedsCommittedHotfixDecision.canHotfixBackend, false);
-assert.equal(releaseNeedsCommittedHotfixDecision.liveHotfixBlockedUntilCommit, true);
-assert.equal(releaseNeedsCommittedHotfixDecision.rootCauseReadiness.status, 'release_hotfix_required');
-assert.equal(releaseNeedsCommittedHotfixDecision.rootCauseReadiness.nextGate, 'release');
-assert.equal(releaseNeedsCommittedHotfixDecision.hotfixContinuation?.action, 'record_hotfix_evidence');
-assert.ok(releaseNeedsCommittedHotfixDecision.requiredEvidence.some((entry) => /sourceCommitSha.*githubCommitUrl.*gitCommitStatus.*gitPushStatus/i.test(entry)));
-assert.ok(releaseNeedsCommittedHotfixDecision.blockers.some((blocker) => /Hotfix evidence is missing/i.test(blocker)));
-assert.ok(releaseNeedsCommittedHotfixDecision.forbiddenActions.some((action) => /committed and pushed to GitHub/i.test(action)));
-assert.ok(releaseNeedsCommittedHotfixDecision.forbiddenActions.some((action) => /gitPushStatus/i.test(action)));
-assert.ok(releaseNeedsCommittedHotfixDecision.nextCommands.indexOf('commit_and_push_hotfix_to_github') >= 0);
-assert.ok(releaseNeedsCommittedHotfixDecision.nextCommands.indexOf('commit_and_push_hotfix_to_github') < releaseNeedsCommittedHotfixDecision.nextCommands.indexOf('apply_backend_hotfix_only_after_commit_proof'));
-assert.equal(releaseNeedsCommittedHotfixDecision.nextActionContract.action, 'repair_release_hotfix_first');
-assert.equal(releaseNeedsCommittedHotfixDecision.nextActionContract.safeToAutoRun, true);
-assert.equal(releaseNeedsCommittedHotfixDecision.nextActionContract.canRunWithoutCodexMonitor, true);
-assert.equal(releaseNeedsCommittedHotfixDecision.nextActionContract.codexFallbackRequired, false);
-assert.equal(releaseNeedsCommittedHotfixDecision.nextActionContract.decisionBasis.hotfixCommitRequired, true);
-assert.equal(releaseNeedsCommittedHotfixDecision.nextActionContract.decisionBasis.liveHotfixBlockedUntilCommit, true);
-assert.ok(releaseNeedsCommittedHotfixDecision.nextActionContract.stopConditions.some((entry) => /sourceCommitSha.*githubCommitUrl.*gitCommitStatus.*gitPushStatus/i.test(entry)));
-assert.equal(validateResolveIOSupportNextActionContract(releaseNeedsCommittedHotfixDecision.nextActionContract).valid, true);
-assert.equal(releaseNeedsCommittedHotfixDecision.managerExecutionPacket.status, 'auto_ready');
-assert.equal(releaseNeedsCommittedHotfixDecision.managerExecutionPacket.primaryCommand, 'record_hotfix_evidence');
-assert.equal(releaseNeedsCommittedHotfixDecision.managerExecutionPacket.retryScope, 'release_hotfix_only');
-assert.ok(releaseNeedsCommittedHotfixDecision.managerExecutionPacket.proofRequiredBeforeContinuation.some((entry) => /sourceCommitSha.*githubCommitUrl.*gitCommitStatus.*gitPushStatus/i.test(entry)));
-assert.equal(releaseNeedsCommittedHotfixDecision.hotfixDurabilityContract?.status, 'waiting_for_commit_proof');
-assert.equal(releaseNeedsCommittedHotfixDecision.hotfixDurabilityContract?.liveHotfixBlockedUntilCommit, true);
-assert.equal(releaseNeedsCommittedHotfixDecision.hotfixDurabilityContract?.canHotfixBackend, false);
-assert.equal(releaseNeedsCommittedHotfixDecision.hotfixDurabilityContract?.nextSafeAction, 'commit_and_push_hotfix_to_github');
-assert.ok(releaseNeedsCommittedHotfixDecision.hotfixDurabilityContract?.missingCommitProofFields.includes('sourceCommitSha'));
-
-const releaseAfterCommittedHotfixDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: diagnosedBundle,
-	releaseStatus: 'failed',
-	unresolvedBlockers: ['Release gate failed before hotfix evidence was recorded.'],
-	releaseGatePassed: true,
-	hotfixEvidence: {
-		channel: 'backend_js',
-		target: {
-			host: 'backend.resolveio.com',
-			path: '/var/app/current/http/support.js'
-		},
-		compiledArtifactPath: 'dist/http/support.js',
-		remoteChecksumBefore: '1111111111111111111111111111111111111111111111111111111111111111',
-		remoteChecksumAfter: '2222222222222222222222222222222222222222222222222222222222222222',
-		sourceCommitSha: 'dd20c124012757ff7d66c682e4b7aad45c402d87',
-		githubCommitUrl: 'https://github.com/resolveio/resolveio-all/commit/dd20c124012757ff7d66c682e4b7aad45c402d87',
-		gitCommitStatus: 'passed',
-		gitPushStatus: 'passed',
-		restartEvidence: 'nodejs restarted on backend.resolveio.com and workers',
-		healthCheckStatus: 'passed',
-		selfTestStatus: 'passed',
-		releaseGateStatus: 'passed'
-	}
-});
-assert.equal(releaseAfterCommittedHotfixDecision.action, 'repair_release_hotfix_first');
-assert.equal(releaseAfterCommittedHotfixDecision.primaryCommand, 'continue_support_runner_after_committed_hotfix');
-assert.equal(releaseAfterCommittedHotfixDecision.hotfixContinuation?.action, 'continue_runner');
-assert.equal(releaseAfterCommittedHotfixDecision.hotfixContinuation?.canContinueRun, true);
-assert.equal(releaseAfterCommittedHotfixDecision.canPrepareHotfixPatch, true);
-assert.equal(releaseAfterCommittedHotfixDecision.canHotfixBackend, true);
-assert.equal(releaseAfterCommittedHotfixDecision.liveHotfixBlockedUntilCommit, false);
-assert.equal(releaseAfterCommittedHotfixDecision.nextActionContract.decisionBasis.liveHotfixBlockedUntilCommit, false);
-assert.equal(releaseAfterCommittedHotfixDecision.nextActionContract.codexFallbackRequired, false);
-assert.equal(releaseAfterCommittedHotfixDecision.hotfixDurabilityContract?.status, 'ready_for_continuation');
-assert.equal(releaseAfterCommittedHotfixDecision.hotfixDurabilityContract?.commitProofPassed, true);
-assert.deepEqual(releaseAfterCommittedHotfixDecision.hotfixDurabilityContract?.missingCommitProofFields, []);
-
-const completedDiagnosedBundle = {
-	...diagnosedBundle,
-	supportV5ActiveMicrotaskId: undefined,
-	supportV5MicrotaskLedger: diagnosedBundle.supportV5MicrotaskLedger.map((task) => ({
-		...task,
-		status: 'pass' as const
-	}))
-};
-const replyAutonomousDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: completedDiagnosedBundle,
-	outcomeLabel: 'accepted',
-	confidence: { level: 'high', category: 'business_proof', shouldBlockPr: false },
-	businessAssertionStatus: 'pass',
-	businessProofArtifacts: ['qa-artifacts/disabled-driver-dropdown.png'],
-	releaseStatus: 'completed'
-});
-assert.equal(replyAutonomousDecision.action, 'draft_customer_reply');
-assert.equal(replyAutonomousDecision.canDraftCustomerReply, true);
-assert.equal(replyAutonomousDecision.canSendCustomerReply, false);
-assert.equal(replyAutonomousDecision.businessProofReadiness.ready, true);
-assert.equal(replyAutonomousDecision.rootCauseReadiness.status, 'customer_reply_draft_ready');
-assert.equal(replyAutonomousDecision.rootCauseReadiness.canDraftCustomerReply, true);
-assert.equal(replyAutonomousDecision.rootCauseReadiness.businessProofReady, true);
-assert.equal(replyAutonomousDecision.humanReviewPacket.reviewType, 'customer_resolution_reply');
-assert.equal(replyAutonomousDecision.humanReviewPacket.primaryAction, 'review_customer_reply');
-assert.equal(replyAutonomousDecision.humanReviewPacket.customerFacingDraftAllowed, true);
-assert.equal(replyAutonomousDecision.humanReviewPacket.customerSendAllowed, false);
-assert.equal(validateResolveIOSupportNextActionContract(replyAutonomousDecision.nextActionContract).valid, true);
-assert.equal(replyAutonomousDecision.managerExecutionPacket.status, 'auto_ready');
-assert.equal(replyAutonomousDecision.managerExecutionPacket.retryScope, 'customer_draft_only');
-assert.equal(replyAutonomousDecision.canSendCustomerReply, false);
-
-const hotfixBlockedReplyAutonomousDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: completedDiagnosedBundle,
-	outcomeLabel: 'accepted',
-	confidence: { level: 'high', category: 'business_proof', shouldBlockPr: false },
-	businessAssertionStatus: 'pass',
-	businessProofArtifacts: ['qa-artifacts/disabled-driver-dropdown.png'],
-	releaseStatus: 'completed',
-	hotfixEvidence: {
-		channel: 'backend_js',
-		target: {
-			host: 'backend.resolveio.com',
-			path: '/var/app/current/http/support.js'
-		},
-		compiledArtifactPath: 'dist/http/support.js',
-		remoteChecksumAfter: '2222222222222222222222222222222222222222222222222222222222222222',
-		sourceCommitSha: 'dd20c124012757ff7d66c682e4b7aad45c402d87',
-		githubCommitUrl: 'https://github.com/resolveio/resolveio-all/commit/dd20c124012757ff7d66c682e4b7aad45c402d87',
-		gitPushStatus: 'passed',
-		restartEvidence: 'nodejs restarted on backend.resolveio.com and workers',
-		healthCheckStatus: 'passed',
-		selfTestStatus: 'passed'
-	}
-});
-assert.equal(hotfixBlockedReplyAutonomousDecision.action, 'repair_release_hotfix_first');
-assert.equal(hotfixBlockedReplyAutonomousDecision.reason, 'support_v5_reply_blocked_by_hotfix_evidence');
-assert.equal(hotfixBlockedReplyAutonomousDecision.canDraftCustomerReply, false);
-assert.equal(hotfixBlockedReplyAutonomousDecision.liveHotfixBlockedUntilCommit, true);
-assert.ok(hotfixBlockedReplyAutonomousDecision.requiredEvidence.some((entry) => /gitCommitStatus=passed/i.test(entry)));
-assert.ok(hotfixBlockedReplyAutonomousDecision.forbiddenActions.some((entry) => /customer resolution/i.test(entry)));
-
-const routeOnlyAutonomousDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: completedDiagnosedBundle,
-	outcomeLabel: 'accepted',
-	confidence: { level: 'high', category: 'route_probe', shouldBlockPr: false },
-	businessAssertionStatus: 'route_probe_pass',
-	businessProofArtifacts: ['qa-artifacts/route-loaded.png'],
-	releaseStatus: 'completed'
-});
-assert.equal(routeOnlyAutonomousDecision.action, 'run_business_proof_qa');
-assert.equal(routeOnlyAutonomousDecision.canRunQa, true);
-assert.equal(routeOnlyAutonomousDecision.canRunModel, false);
-assert.equal(routeOnlyAutonomousDecision.businessProofReadiness.status, 'route_only');
-assert.equal(routeOnlyAutonomousDecision.rootCauseReadiness.status, 'business_proof_required');
-assert.equal(routeOnlyAutonomousDecision.rootCauseReadiness.canRunBusinessProofQa, true);
-assert.equal(routeOnlyAutonomousDecision.rootCauseReadiness.businessProofReady, false);
-assert.ok(routeOnlyAutonomousDecision.requiredEvidence.some((entry) => /filter_query_mismatch/.test(entry)));
-assert.ok(routeOnlyAutonomousDecision.requiredEvidence.some((entry) => /included\/excluded row proof|dropdown DOM snapshot/i.test(entry)));
-assert.ok(routeOnlyAutonomousDecision.forbiddenActions.some((action) => /businessProofReadiness\.ready=true/.test(action)));
-assert.equal(routeOnlyAutonomousDecision.humanReviewPacket.reviewType, 'business_proof_qa');
-assert.equal(routeOnlyAutonomousDecision.humanReviewPacket.primaryAction, 'run_support_v5_business_proof_qa_row');
-
-const staleProofAutonomousDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: completedDiagnosedBundle,
-	outcomeLabel: 'accepted',
-	confidence: { level: 'high', category: 'business_proof', shouldBlockPr: false },
-	businessAssertions: [{
-		assertion: validDiagnosis.proof_plan.business_assertion,
-		status: 'pass',
-		workflow: validDiagnosis.proof_plan.business_proof_contract.action_under_test,
-		action: validDiagnosis.proof_plan.action,
-		expected: validDiagnosis.proof_plan.business_proof_contract.expected_business_state_change,
-		observed: 'The disabled driver option is absent and the active driver remains selected.',
-		dataProof: validDiagnosis.proof_plan.business_proof_contract.data_or_dom_assertion,
-		artifactPaths: ['qa-artifacts/disabled-driver-business-proof.json'],
-		metadata: { supportDiagnosisProof: true }
-	}],
-	previousProofFingerprint: matchedBusinessProofReadiness.proofFingerprint,
-	releaseStatus: 'completed'
-});
-assert.equal(staleProofAutonomousDecision.action, 'run_business_proof_qa');
-assert.equal(staleProofAutonomousDecision.businessProofReadiness.status, 'stale');
-assert.equal(staleProofAutonomousDecision.rootCauseReadiness.businessProofStatus, 'stale');
-assert.equal(staleProofAutonomousDecision.rootCauseReadiness.proofFreshness, 'same_as_previous');
-assert.equal(staleProofAutonomousDecision.rootCauseReadiness.canRelease, false);
-assert.equal(staleProofAutonomousDecision.rootCauseReadiness.canDraftCustomerReply, false);
-assert.ok(staleProofAutonomousDecision.blockers.some((blocker) => /new proof\/artifact fingerprint/i.test(blocker)));
-
-const missingDiagnosisRepairGate = decideResolveIOSupportV5RepairGate({
-	diagnosisGate: undefined,
-	activeStepType: 'build_repair'
-});
-assert.equal(missingDiagnosisRepairGate.action, 'diagnose_only');
-assert.equal(missingDiagnosisRepairGate.recoveryPlan.recoveryClass, 'diagnosis_only');
-assert.equal(missingDiagnosisRepairGate.recoveryPlan.productRepairAllowed, false);
-assert.ok(missingDiagnosisRepairGate.recoveryPlan.requiredEvidence.includes('accepted_hypothesis'));
-assert.equal(missingDiagnosisRepairGate.recoveryCheckpoint.recoveryClass, 'diagnosis_only');
-assert.equal(missingDiagnosisRepairGate.recoveryCheckpoint.productRepairAllowed, false);
-assert.equal(missingDiagnosisRepairGate.recoveryAction.mode, 'read_only_diagnosis');
-assert.equal(missingDiagnosisRepairGate.recoveryAction.allowedDispatchAction, 'run_read_only_diagnosis');
-assert.equal(missingDiagnosisRepairGate.recoveryAction.productRepairAllowed, false);
-assert.equal(missingDiagnosisRepairGate.recoveryAction.proofRequiredBeforeContinuation, true);
-const allowedRepairGate = decideResolveIOSupportV5RepairGate({
-	diagnosisGate: validDiagnosis,
-	activeStepType: 'build_repair',
-	changedFiles: ['geochem/angular/app/bol/new/bol-new.component.ts']
-});
-assert.equal(allowedRepairGate.action, 'allow_product_repair');
-assert.equal(allowedRepairGate.recoveryPlan.recoveryClass, 'product_code_repair');
-assert.equal(allowedRepairGate.recoveryPlan.productRepairAllowed, true);
-assert.equal(allowedRepairGate.recoveryCheckpoint.recoveryClass, 'product_code_repair');
-assert.equal(allowedRepairGate.recoveryCheckpoint.productRepairAllowed, true);
-const outOfScopeRepairGate = decideResolveIOSupportV5RepairGate({
-	diagnosisGate: validDiagnosis,
-	activeStepType: 'build_repair',
-	changedFiles: ['geochem/server/src/methods/unrelated.ts']
-});
-assert.equal(outOfScopeRepairGate.action, 'reject_out_of_scope');
-assert.equal(outOfScopeRepairGate.recoveryPlan.recoveryClass, 'diagnosis_revision');
-assert.ok(outOfScopeRepairGate.recoveryPlan.forbiddenActions.some((action) => /outside owner_files/.test(action)));
-const infraRepairGate = decideResolveIOSupportV5RepairGate({
-	diagnosisGate: validDiagnosis,
-	activeStepType: 'build_repair',
-	failureClass: 'infra',
-	blocker: 'Puppeteer failed to launch.'
-});
-assert.equal(infraRepairGate.action, 'infra_repair_only');
-assert.equal(infraRepairGate.recoveryPlan.recoveryClass, 'infra_repair');
-assert.equal(infraRepairGate.recoveryPlan.expensiveModelAllowed, false);
-assert.ok(infraRepairGate.recoveryPlan.forbiddenActions.some((action) => /product-code model repair/.test(action)));
-assert.equal(infraRepairGate.recoveryCheckpoint.recoveryClass, 'infra_repair');
-assert.equal(infraRepairGate.recoveryCheckpoint.productRepairAllowed, false);
-const preflightRepairGate = decideResolveIOSupportV5RepairGate({
-	diagnosisGate: validDiagnosis,
-	activeStepType: 'build_repair',
-	preflightGate: compilePreflight
-});
-assert.equal(preflightRepairGate.action, 'infra_repair_only');
-assert.equal(preflightRepairGate.canEditProductCode, false);
-assert.equal(preflightRepairGate.preflightGate.status, 'compile_failed');
-assert.equal(preflightRepairGate.recoveryPlan.recoveryClass, 'compile_repair');
-assert.equal(preflightRepairGate.recoveryPlan.expensiveModelAllowed, false);
-const repeatedRepairGate = decideResolveIOSupportV5RepairGate({
-	diagnosisGate: validDiagnosis,
-	activeStepType: 'build_repair',
-	failureClass: 'product_code',
-	blocker: 'same blocker',
-	evidenceHash: 'same',
-	history: [
-		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'same', recordedAt: '1' },
-		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'same', recordedAt: '2' }
-	],
-	maxRepeatedNoProgress: 2
-});
-assert.equal(repeatedRepairGate.action, 'park_repeated_failure');
-assert.equal(repeatedRepairGate.recoveryPlan.recoveryClass, 'blocked_until_new_evidence');
-assert.ok(repeatedRepairGate.recoveryPlan.loopResetEvidence.some((evidence) => /changed evidence hash/.test(evidence)));
-assert.equal(repeatedRepairGate.recoveryCheckpoint.status, 'parked');
-assert.equal(repeatedRepairGate.recoveryCheckpoint.allowedAction, 'collect_new_evidence_only');
-assert.equal(repeatedRepairGate.recoveryEvidenceProbe.evidenceOnly, true);
-assert.equal(repeatedRepairGate.recoveryEvidenceProbe.productRepairAllowed, false);
-assert.ok(repeatedRepairGate.recoveryEvidenceProbe.steps.some((step) => step.kind === 'rerun_same_gate'));
-assert.equal(repeatedRepairGate.recoveryAction.mode, 'collect_evidence');
-assert.equal(repeatedRepairGate.recoveryAction.productRepairAllowed, false);
-assert.equal(repeatedRepairGate.recoveryAction.retryPolicy.requireNewEvidence, true);
-
-const staleEvidenceFreshness = evaluateResolveIOSupportEvidenceFreshness({
-	history: [
-		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same blocker', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'same', recordedAt: '1' },
-		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same blocker', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'same', recordedAt: '2' }
-	],
-	failureClass: 'product_code',
-	blocker: 'same blocker',
-	evidenceHash: 'same',
-	limit: 2
-});
-assert.equal(staleEvidenceFreshness.status, 'stale_repeated');
-assert.equal(staleEvidenceFreshness.mustCollectNewEvidence, true);
-assert.equal(staleEvidenceFreshness.canRetry, false);
-assert.ok(staleEvidenceFreshness.requiredResetEvidence.some((evidence) => /changed evidence hash|new artifact path|business\/compile\/infra\/release proof/i.test(evidence)));
-
-const staleContinuationProofCheckpoint = buildResolveIOSupportContinuationProofCheckpoint({
-	action: 'collect_new_evidence',
-	reason: staleEvidenceFreshness.reason,
-	evidenceFreshness: staleEvidenceFreshness,
-	requiredEvidence: staleEvidenceFreshness.requiredResetEvidence
-});
-assert.equal(staleContinuationProofCheckpoint.status, 'waiting_for_new_evidence');
-assert.equal(staleContinuationProofCheckpoint.successRequiresNewEvidence, true);
-assert.equal(staleContinuationProofCheckpoint.blocksProductRepairUntilChangedEvidence, true);
-assert.equal(staleContinuationProofCheckpoint.startingEvidenceHash, 'same');
-assert.ok(staleContinuationProofCheckpoint.requiredResetEvidence.some((evidence) => /changed evidence hash|new artifact path|business\/compile\/infra\/release proof/i.test(evidence)));
-
-const repeatedAutonomousDecision = decideResolveIOSupportV5AutonomousNextAction({
-	bundle: {
-		...diagnosedBundle,
-		supportV5StepHistory: [
-			{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same blocker', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'same', recordedAt: '1' },
-			{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same blocker', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'same', recordedAt: '2' }
-		]
-	},
-	failureClass: 'product_code',
-	blocker: 'same blocker',
-	evidenceHash: 'same'
-});
-assert.equal(repeatedAutonomousDecision.action, 'collect_new_evidence');
-assert.equal(repeatedAutonomousDecision.canEditProductCode, false);
-assert.equal(repeatedAutonomousDecision.evidenceFreshness.mustCollectNewEvidence, true);
-assert.equal(repeatedAutonomousDecision.continuationProofCheckpoint.status, 'waiting_for_new_evidence');
-assert.equal(repeatedAutonomousDecision.continuationProofCheckpoint.blocksProductRepairUntilChangedEvidence, true);
-assert.equal(repeatedAutonomousDecision.nextActionContract.action, 'collect_new_evidence');
-assert.equal(repeatedAutonomousDecision.nextActionContract.safeToAutoRun, true);
-assert.equal(repeatedAutonomousDecision.nextActionContract.canRunWithoutCodexMonitor, true);
-assert.equal(repeatedAutonomousDecision.nextActionContract.decisionBasis.sameFailureCount, 2);
-assert.equal(repeatedAutonomousDecision.humanDecisionRequest?.required, true);
-assert.equal(repeatedAutonomousDecision.humanDecisionRequest?.status, 'auto_dispatch_allowed');
-assert.equal(repeatedAutonomousDecision.humanDecisionRequest?.preferredChoiceId, 'run_bounded_evidence_probe');
-assert.equal(repeatedAutonomousDecision.humanDecisionRequest?.autoDispatchAllowed, true);
-assert.equal(repeatedAutonomousDecision.humanDecisionRequest?.evidence.sameFailureCount, 2);
-assert.ok(repeatedAutonomousDecision.humanDecisionRequest?.choices.some((choice) => choice.choiceId === 'run_bounded_evidence_probe' && choice.action === 'collect_new_evidence' && choice.allowedWithoutCodexMonitor === true));
-assert.ok(repeatedAutonomousDecision.humanDecisionRequest?.blockedUntil.some((entry) => /blockerFingerprint|evidenceHash|business|compile|infra|release proof/i.test(entry)));
-assert.ok(repeatedAutonomousDecision.nextActionContract.stopConditions.some((entry) => /Reset requires:.*changed evidence hash|Reset requires:.*new artifact path|same failure class/i.test(entry)));
-assert.equal(validateResolveIOSupportNextActionContract(repeatedAutonomousDecision.nextActionContract).valid, true);
-assert.equal(repeatedAutonomousDecision.managerExecutionPacket.status, 'auto_ready');
-assert.equal(repeatedAutonomousDecision.managerExecutionPacket.retryScope, 'evidence_only');
-assert.equal(repeatedAutonomousDecision.managerExecutionPacket.maxAttemptsBeforeFreshEvidence, 1);
-assert.ok(repeatedAutonomousDecision.managerExecutionPacket.blockers.some((blocker) => /same_failure|changed_evidence|support_v5/i.test(blocker)));
-assert.ok(repeatedAutonomousDecision.forbiddenActions.some((action) => /product-code repair|another repair loop|blockerFingerprint|evidenceHash/i.test(action)));
-
-const materialEvidenceFreshness = evaluateResolveIOSupportEvidenceFreshness({
-	history: [
-		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same blocker', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'same', artifactPaths: ['qa-artifacts/old.log'], recordedAt: '1' }
-	],
-	failureClass: 'product_code',
-	blocker: 'same blocker',
-	evidenceHash: 'after-business-proof',
-	artifactPaths: ['qa-artifacts/old.log', 'qa-artifacts/business-proof-after.png'],
-	limit: 2
-});
-assert.equal(materialEvidenceFreshness.status, 'material_evidence');
-assert.equal(materialEvidenceFreshness.materialEvidence, true);
-assert.equal(materialEvidenceFreshness.canRetry, true);
-assert.equal(materialEvidenceFreshness.loopBudgetShouldReset, true);
-
-const withFailure = recordResolveIOSupportV5Step(initialized, {
-	stepType: 'qa_row',
-	outcome: 'needs_repair',
-	lane: 'qa',
-	model: 'gpt-5.4-mini',
-	threadKey: 'support:ticket-1:job:job-1:qa',
-	promptTokenEstimate: 1200,
-	runtimeMs: 45000,
-	summary: 'Row 2 failed.',
-	blocker: 'Screenshot shell-only for row 2',
-	artifactPaths: ['qa-artifacts/row-2.jpg'],
-	activeQaRow: {
-		index: 2,
-		workflow: 'Disabled driver cannot replace selected active driver',
-		route: '/dashboard/driver/truck-treating/bol-detail/bol/route',
-		status: 'failed'
-	},
-	now: '2026-06-06T00:01:00.000Z'
-});
-
-assert.equal(withFailure.supportV5StepHistory.length, 1);
-assert.equal(withFailure.supportV5Budget.loopCount, 1);
-assert.equal(withFailure.supportV5LaneMemory.qa.activeBlocker, 'Screenshot shell-only for row 2');
-assert.equal(withFailure.supportV5SupervisorState.currentQaRow?.index, 2);
-assert.deepEqual(decideResolveIOSupportV5Continuation(withFailure).action, 'continue');
-
-let repeated = withFailure;
-repeated = recordResolveIOSupportV5Step(repeated, {
-	stepType: 'qa_row',
-	outcome: 'needs_repair',
-	lane: 'qa',
-	blocker: 'Screenshot shell-only for row 2',
-	summary: 'Still shell-only.',
-	now: '2026-06-06T00:02:00.000Z'
-});
-repeated = recordResolveIOSupportV5Step(repeated, {
-	stepType: 'qa_row',
-	outcome: 'needs_repair',
-	lane: 'qa',
-	blocker: 'Screenshot shell-only for row 2',
-	summary: 'Still shell-only again.',
-	now: '2026-06-06T00:03:00.000Z'
-});
-
-const repeatedDecision = decideResolveIOSupportV5Continuation(repeated);
-assert.equal(repeatedDecision.action, 'park');
-assert.equal(repeatedDecision.reason, 'support_v5_same_failure_with_weak_evidence');
-assert.equal(repeatedDecision.recoveryPlan.recoveryClass, 'blocked_until_new_evidence');
-assert.equal(repeatedDecision.recoveryPlan.allowedAction, 'collect_new_evidence_only');
-assert.equal(repeatedDecision.recoveryCheckpoint.status, 'parked');
-assert.equal(repeatedDecision.recoveryCheckpoint.allowedAction, 'collect_new_evidence_only');
-assert.equal(repeatedDecision.recoveryEvidenceProbe.evidenceOnly, true);
-assert.equal(repeatedDecision.recoveryEvidenceProbe.productRepairAllowed, false);
-assert.ok(repeatedDecision.recoveryEvidenceProbe.acceptanceEvidence.some((evidence) => /changed evidence hash|new artifact path/i.test(evidence)));
-assert.equal(repeatedDecision.recoveryAction.mode, 'collect_evidence');
-assert.equal(repeatedDecision.recoveryAction.retryPolicy.requireNewEvidence, true);
-assert.ok(repeatedDecision.recoveryAction.requiredArtifacts.length > 0);
-
-let materialEvidenceRetryBundle = withFailure;
-materialEvidenceRetryBundle = recordResolveIOSupportV5Step(materialEvidenceRetryBundle, {
-	stepType: 'qa_row',
-	outcome: 'needs_repair',
-	lane: 'qa',
-	failureClass: 'product_code',
-	blocker: 'Save action still throws TypeError.',
-	summary: 'Save action still throws TypeError.',
-	evidenceHash: 'save-typeerror-before',
-	artifactPaths: ['qa-artifacts/save-before.log'],
-	now: '2026-06-06T00:03:10.000Z'
-});
-materialEvidenceRetryBundle = recordResolveIOSupportV5Step(materialEvidenceRetryBundle, {
-	stepType: 'qa_row',
-	outcome: 'needs_repair',
-	lane: 'qa',
-	failureClass: 'product_code',
-	blocker: 'Save action still throws TypeError.',
-	summary: 'New business DOM trace proves the save click reaches the method with an undefined id.',
-	evidenceHash: 'save-typeerror-after-dom-trace',
-	artifactPaths: ['qa-artifacts/save-before.log', 'qa-artifacts/save-after-dom-trace.json'],
-	now: '2026-06-06T00:03:20.000Z'
-});
-const materialEvidenceRetryDecision = decideResolveIOSupportV5Continuation(materialEvidenceRetryBundle);
-assert.equal(materialEvidenceRetryDecision.action, 'continue');
-assert.equal(materialEvidenceRetryDecision.reason, 'support_v5_continue');
-
-const repeatedProductFailure = decideResolveIOSupportV5RepeatedFailureStop({
-	history: [
-		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'same', recordedAt: '1' },
-		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'same', recordedAt: '2' }
-	],
-	failureClass: 'product_code',
-	blocker: 'same blocker',
-	evidenceHash: 'same',
-	limit: 2
-});
-assert.equal(repeatedProductFailure.shouldStop, true);
-const repeatedInfraFailure = decideResolveIOSupportV5RepeatedFailureStop({
-	history: [
-		{ stepType: 'compile_check', outcome: 'needs_repair', lane: 'build', summary: 'same', failureClass: 'infra', blocker: 'puppeteer missing', evidenceHash: 'same', recordedAt: '1' }
-	],
-	failureClass: 'infra',
-	blocker: 'puppeteer missing',
-	evidenceHash: 'same',
-	limit: 1
-});
-assert.equal(repeatedInfraFailure.shouldStop, false);
-
-let repeatedInfraBundle = diagnosedBundle;
-repeatedInfraBundle = recordResolveIOSupportV5Step(repeatedInfraBundle, {
-	stepType: 'compile_check',
-	outcome: 'needs_repair',
-	lane: 'build',
-	failureClass: 'infra',
-	blocker: 'Puppeteer executable missing.',
-	evidenceHash: 'same-infra',
-	now: '2026-06-06T00:03:10.000Z'
-});
-repeatedInfraBundle = recordResolveIOSupportV5Step(repeatedInfraBundle, {
-	stepType: 'compile_check',
-	outcome: 'needs_repair',
-	lane: 'build',
-	failureClass: 'infra',
-	blocker: 'Puppeteer executable missing.',
-	evidenceHash: 'same-infra',
-	now: '2026-06-06T00:03:20.000Z'
-});
-repeatedInfraBundle = recordResolveIOSupportV5Step(repeatedInfraBundle, {
-	stepType: 'compile_check',
-	outcome: 'needs_repair',
-	lane: 'build',
-	failureClass: 'infra',
-	blocker: 'Puppeteer executable missing.',
-	evidenceHash: 'same-infra',
-	now: '2026-06-06T00:03:30.000Z'
-});
-const repeatedInfraContinuation = decideResolveIOSupportV5Continuation(repeatedInfraBundle);
-assert.equal(repeatedInfraContinuation.action, 'continue');
-assert.equal(repeatedInfraContinuation.reason, 'support_v5_infra_or_compile_repair_required');
-assert.equal(repeatedInfraContinuation.recoveryPlan.recoveryClass, 'infra_repair');
-assert.equal(repeatedInfraContinuation.recoveryPlan.productRepairAllowed, false);
-
-const sameBlockerWeakHashOnlyEvidence = decideResolveIOSupportV5RepeatedFailureStop({
-	history: [
-		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same root issue', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'before-fix-log', recordedAt: '1' },
-		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same root issue', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'renamed-hash-only', recordedAt: '2' }
-	],
-	failureClass: 'product_code',
-	blocker: 'same blocker',
-	evidenceHash: 'renamed-hash-only',
-	limit: 2
-});
-assert.equal(sameBlockerWeakHashOnlyEvidence.shouldStop, true);
-assert.equal(sameBlockerWeakHashOnlyEvidence.reason, 'support_v5_same_failure_with_weak_evidence');
-assert.equal(sameBlockerWeakHashOnlyEvidence.newEvidence, true);
-assert.equal(sameBlockerWeakHashOnlyEvidence.materialEvidence, false);
-assert.equal(sameBlockerWeakHashOnlyEvidence.evidenceStrength, 'weak');
-
-const sameBlockerMaterialEvidence = decideResolveIOSupportV5RepeatedFailureStop({
-	history: [
-		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same root issue', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'before-fix-log', artifactPaths: ['qa-artifacts/before.log'], recordedAt: '1' },
-		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'New business DOM trace proves the disabled driver option still persists after save.', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'after-business-proof', artifactPaths: ['qa-artifacts/before.log', 'qa-artifacts/business-proof-after.json'], recordedAt: '2' }
-	],
-	failureClass: 'product_code',
-	blocker: 'same blocker',
-	evidenceHash: 'after-business-proof',
-	artifactPaths: ['qa-artifacts/before.log', 'qa-artifacts/business-proof-after.json'],
-	limit: 2
-});
-assert.equal(sameBlockerMaterialEvidence.shouldStop, false);
-assert.equal(sameBlockerMaterialEvidence.reason, 'support_v5_retry_allowed_material_evidence');
-assert.equal(sameBlockerMaterialEvidence.materialEvidence, true);
-assert.equal(sameBlockerMaterialEvidence.evidenceStrength, 'material');
-assert.ok(sameBlockerMaterialEvidence.evidenceSignals?.includes('artifact_paths_added'));
-
-const pingPongFailure = decideResolveIOSupportV5RepeatedFailureStop({
-	history: [
-		{ stepType: 'qa_row', outcome: 'needs_repair', lane: 'qa', summary: 'Filter excludes active customers', failureClass: 'business', blocker: 'Filter excludes active customers', evidenceHash: 'a', recordedAt: '1' },
-		{ stepType: 'qa_row', outcome: 'needs_repair', lane: 'qa', summary: 'Filter includes inactive customers', failureClass: 'business', blocker: 'Filter includes inactive customers', evidenceHash: 'b', recordedAt: '2' },
-		{ stepType: 'qa_row', outcome: 'needs_repair', lane: 'qa', summary: 'Filter excludes active customers', failureClass: 'business', blocker: 'Filter excludes active customers', evidenceHash: 'a', recordedAt: '3' },
-		{ stepType: 'qa_row', outcome: 'needs_repair', lane: 'qa', summary: 'Filter includes inactive customers', failureClass: 'business', blocker: 'Filter includes inactive customers', evidenceHash: 'b', recordedAt: '4' }
-	],
-	failureClass: 'business',
-	blocker: 'Filter includes inactive customers',
-	evidenceHash: 'b',
-	limit: 3
-});
-assert.equal(pingPongFailure.shouldStop, true);
-assert.equal(pingPongFailure.reason, 'support_v5_ping_pong_failure_loop');
-
-const budgeted = recordResolveIOSupportV5Step(initialized, {
-	stepType: 'build_repair',
-	outcome: 'needs_repair',
-	lane: 'build',
-	promptTokenEstimate: 1900,
-	blocker: 'Prompt was too broad for a repair step.',
-	now: '2026-06-06T00:04:00.000Z'
-});
-assert.equal(decideResolveIOSupportV5Continuation(budgeted).reason, 'support_v5_budget_guard');
-assert.equal(decideResolveIOSupportV5Continuation(budgeted).recoveryPlan.recoveryClass, 'manual_handoff');
-
-const prompt = buildResolveIOSupportV5DiagnoseFirstPrompt({
-	goal: initialized.supportV5SupervisorState.currentGoal,
-	activeStep: 'qa_row',
-	activeBlocker: 'Route failed to hydrate.',
-	lane: 'qa',
-	currentQaRow: withFailure.supportV5SupervisorState.currentQaRow,
-	artifactPaths: ['qa-artifacts/client.log'],
-	changedFiles: ['geochem/angular/app/bol/new/bol-new.component.ts']
-}).join('\n');
-
-assert.match(prompt, /Diagnose First/);
-assert.match(prompt, /Do not send customer email/);
-assert.match(prompt, /Current QA row/);
-assert.match(prompt, /geochem\/angular\/app\/bol\/new\/bol-new\.component\.ts/);
-
-const diagnosisPromptWithHints = buildResolveIOSupportV5MicrotaskPrompt({
-	bundle: initialized,
-	lane: 'build',
-	stage: 'support-diagnosis-gate',
-	similarCaseHints,
-	contextSnippets: ['Ticket number: 004999']
-});
-assert.equal(diagnosisPromptWithHints.activeMicrotask?.type, 'diagnosis_gate');
-assert.equal(diagnosisPromptWithHints.diagnosisEvidencePack.status, 'needs_diagnosis');
-assert.equal(diagnosisPromptWithHints.diagnosisEvidencePack.sourceEditsAllowed, false);
-assert.equal(diagnosisPromptWithHints.diagnosisEvidencePack.similarCaseSelection.ranked[0].ticketNumber, '004333');
-assert.match(diagnosisPromptWithHints.prompt, /Similar accepted fix hints/);
-assert.match(diagnosisPromptWithHints.prompt, /diagnosis_evidence_pack|support-diagnosis-pack/);
-assert.match(diagnosisPromptWithHints.prompt, /advisory only/i);
-assert.match(diagnosisPromptWithHints.prompt, /004333/);
-assert.match(diagnosisPromptWithHints.prompt, /owner_file_overlap/);
-
-assert.equal(
-	fingerprintResolveIOSupportV5Blocker('Line 123 failed for 6a239cd7d67a2b24b36f3dfe'),
-	fingerprintResolveIOSupportV5Blocker('Line 456 failed for abcdefabcdefabcdef')
-);
-
-const incident = buildResolveIOSupportV5Incident({
-	incidentClass: 'false_screenshot_rejection',
-	summary: 'Sparse but valid BOL detail screen was rejected by file-size gate.',
-	stepType: 'artifact_package',
-	blocker: 'screenshot shell-only',
-	artifactPaths: ['qa-artifacts/row-2.jpg'],
-	now: '2026-06-06T00:05:00.000Z'
-});
-assert.equal(incident.incidentClass, 'false_screenshot_rejection');
-assert.ok(incident.blockerFingerprint);
-
-const microtaskPrompt = buildResolveIOSupportV5MicrotaskPrompt({
-	bundle: diagnosedBundle,
-	lane: 'build',
-	stage: 'support-autonomous-owner',
-	failureText: 'QA row failed because the driver dropdown still includes disabled drivers.',
-	changedFiles: ['geochem/angular/app/bol/new/bol-new.component.ts'],
-	contextSnippets: ['Workspace root: /var/ai-workspace/job-1', 'Project root: geochem']
-});
-assert.equal(microtaskPrompt.activeMicrotask?.lane, 'build');
-assert.equal(microtaskPrompt.withinHardCap, true);
-assert.ok(microtaskPrompt.promptTokenEstimate <= buildResolveIOSupportV5PromptBudget().buildMicrotaskHardCap);
-assert.match(microtaskPrompt.prompt, /Microtask id:/);
-assert.match(microtaskPrompt.prompt, /persistent lane thread/);
-assert.match(microtaskPrompt.prompt, /Diagnosis issue class: filter_query_mismatch/);
-assert.doesNotMatch(microtaskPrompt.prompt, /Initial ticket context:/);
-assert.doesNotMatch(microtaskPrompt.prompt, /Staged support context:/);
-assert.doesNotMatch(microtaskPrompt.prompt, /BUILD_PLAN/);
-
-const qaPrompt = buildResolveIOSupportV5MicrotaskPrompt({
-	bundle: {
-		...diagnosedBundle,
-		supportV5ActiveMicrotaskId: diagnosedBundle.supportV5MicrotaskLedger.find((task) => task.lane === 'qa')?.microtaskId
-	},
-	lane: 'qa',
-	stage: 'support-qa-validation',
-	activeQaRow: {
-		index: 0,
-		workflow: 'BOL driver display',
-		route: '/dashboard/driver/truck-treating/bol-detail/bol/route',
-		assertion: 'Disabled driver is rejected',
-		status: 'pending'
-	}
-});
-assert.equal(qaPrompt.activeMicrotask?.lane, 'qa');
-assert.ok(qaPrompt.promptTokenEstimate <= buildResolveIOSupportV5PromptBudget().qaMicrotaskHardCap);
-assert.match(qaPrompt.prompt, /Return strict JSON only/);
-assert.match(qaPrompt.prompt, /IssueClassProbePlan|support-probe-plan|filter_query_mismatch/);
-
-const usageBundle = recordResolveIOSupportV5MicrotaskUsage(initialized, {
-	microtaskId: initialized.supportV5MicrotaskLedger[0].microtaskId,
-	lane: 'build',
-	model: 'gpt-5.3-codex',
-	threadKey: initialized.supportV5LaneMemory.build.threadKey,
-	reuseThread: true,
-	promptTokenEstimate: microtaskPrompt.promptTokenEstimate,
-	promptSections: microtaskPrompt.promptSections,
-	outcome: 'pass'
-});
-const usageSummary = summarizeResolveIOSupportV5MicrotaskUsage(usageBundle);
-assert.equal(usageSummary.byMicrotask.length, 1);
-assert.ok(usageSummary.bySection.some((section) => section.name === 'active_microtask'));
-assert.equal(usageSummary.broadPromptViolations.length, 0);
-
-const digest = buildResolveIOSupportV5ScopeDigest({
-	goal: 'Resolve support ticket 004999',
-	approvedScope: ['A'.repeat(2000), 'B'.repeat(2000)],
-	prBranch: 'support-004999',
-	maxTokens: 200
-});
-assert.ok(digest.length <= 800);
-
-console.log('support runner v5 tests passed');