@resolveio/server-lib 22.3.196 → 22.3.197

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

@@ -0,0 +1,1473 @@
+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');