@resolveio/server-lib 22.3.219 → 22.3.221

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

@@ -0,0 +1,3201 @@
+import * as assert from 'node:assert/strict';
+import {
+	buildResolveIOSupportDiagnosisEvidencePack,
+	buildResolveIOSupportDiagnosisProofMatrix,
+	buildResolveIOSupportEvidenceProbeContract,
+	buildResolveIOSupportIssueClassProbePlan,
+	buildResolveIOSupportIssueClassProbes,
+	buildResolveIOSupportOwnerScopedRepairContract,
+	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,
+	validateResolveIOSupportEvidenceProbeContract,
+	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(validDiagnosisResult.proofMatrix?.status, 'ready');
+assert.equal(validDiagnosisResult.proofMatrix?.ownerFileCoverage.every((entry) => entry.covered), true);
+assert.equal(validDiagnosisResult.proofMatrix?.businessProofArtifacts.some((artifact) => /dropdown DOM snapshot|persisted BOL driver id check/i.test(artifact)), true);
+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);
+assert.ok(buildResolveIOSupportIssueClassProbes(validDiagnosis)[0].browser_steps.length >= 3);
+assert.equal(buildResolveIOSupportIssueClassProbes(validDiagnosis)[0].active_qa_row?.acceptance_gate, 'aiqa_business_assertion');
+assert.equal(buildResolveIOSupportIssueClassProbes(validDiagnosis)[0].active_qa_row?.route_only_is_false_pass, true);
+assert.equal(buildResolveIOSupportIssueClassProbes(validDiagnosis)[0].aiqa_business_assertion_template.metadata.supportDiagnosisProof, true);
+
+const structuredDiagnosisResult = validateResolveIOSupportDiagnosisGate({
+	...validDiagnosis,
+	owner_files: [
+		{ path: 'geochem/angular/app/bol/new/bol-new.component.ts' },
+		{ ownerFile: 'geochem/server/src/publications/drivers.ts' }
+	],
+	accepted_hypothesis: {
+		...validDiagnosis.accepted_hypothesis,
+		evidence: [
+			{ summary: 'Ticket names disabled driver selection.' },
+			{ message: 'Publication path returns drivers without active filter.' }
+		]
+	},
+	evidence: [
+		{ type: 'ticket' as const, summary: 'Ticket reports disabled driver selection in BOL workflow.', ownerFiles: [{ path: 'geochem/server/src/publications/drivers.ts' }] },
+		{ 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.', ownerFiles: [{ ownerFile: 'geochem/server/src/publications/drivers.ts' }] }
+	]
+});
+assert.equal(structuredDiagnosisResult.valid, true);
+assert.deepEqual(structuredDiagnosisResult.normalized?.owner_files, validDiagnosis.owner_files);
+assert.deepEqual(structuredDiagnosisResult.normalized?.accepted_hypothesis.evidence, validDiagnosis.accepted_hypothesis.evidence);
+assert.equal(structuredDiagnosisResult.normalized?.owner_files.some((entry) => entry === '[object Object]'), false);
+
+const workspacePrefixedOwnerDiagnosisResult = validateResolveIOSupportDiagnosisGate({
+	...validDiagnosis,
+	owner_files: validDiagnosis.owner_files.map((ownerFile) => `/var/app/resolveio-ai-workspace/6a35c4162031d2a4a0216ce4/resolveio-all/${ownerFile}`)
+});
+assert.equal(workspacePrefixedOwnerDiagnosisResult.valid, true, workspacePrefixedOwnerDiagnosisResult.blockers.join(' | '));
+assert.deepEqual(workspacePrefixedOwnerDiagnosisResult.normalized?.owner_files, validDiagnosis.owner_files);
+assert.equal(workspacePrefixedOwnerDiagnosisResult.blockers.some((blocker) => /broad or unsafe path/i.test(blocker)), false);
+
+const looseFeatureRequestDiagnosisResult = validateResolveIOSupportDiagnosisGate({
+	support_diagnosis_gate: {
+	issue_case: 'Customer requested a new QC/Sample Testing dashboard workflow with field-entry and manager views modeled after Dry Media.',
+	issue_class: 'feature_request',
+	accepted_hypothesis: 'This is a feature request, not an existing behavior failure, because no QC dashboard route, permission, navigation entry, or client route exists today.',
+	rejected_alternatives: [
+		{ hypothesis: 'Existing QC dashboard route is broken.', reason_rejected: 'No QC dashboard route is defined in dashboard routing or the server client-route allowlist.' },
+		{ hypothesis: 'Existing QC UI is hidden by a user-role guard.', why_rejected: 'No QC screen or permission target exists in the current navigation/permission chain.' }
+	],
+	failing_path: {
+		path: 'none_existing',
+		route_module_permission_gate: 'No QC dashboard route and no QC dashboard permission entry found.',
+		template_conditional_rendering_gate: 'No QC template/helper visibility guard found.',
+		backing_role_group_config_publications_gate: 'No QC-specific role/group/config publication gate found for a dashboard path.'
+	},
+	owner_files: [
+		'/var/app/resolveio-ai-workspace/6a35a876bccf4dc547494e27/resolveio-all/h2sko/.resolveio-support-context/manual-ticket.request.txt',
+		'/var/app/resolveio-ai-workspace/6a35a876bccf4dc547494e27/resolveio-all/h2sko/angular/app/dashboard/dashboard.routing.ts',
+		'/var/app/resolveio-ai-workspace/6a35a876bccf4dc547494e27/resolveio-all/h2sko/angular/app/dashboard/dashboard.permission.ts',
+		'/var/app/resolveio-ai-workspace/6a35a876bccf4dc547494e27/resolveio-all/h2sko/angular/app/app.component.ts',
+		'/var/app/resolveio-ai-workspace/6a35a876bccf4dc547494e27/resolveio-all/h2sko/server/src/client-routes.ts'
+	],
+	proof_plan: [
+		{
+			action: 'Map spreadsheet tabs Specs and Batch Entry to a QC schema and field-entry flow.',
+			proof_required: 'Representative QC records persist mapped fields and pass/fail status inputs.'
+		},
+		{
+			action: 'Implement a QC manager/list flow with date, media, source, and type filters.',
+			proof_required: 'Date/media/source/type filtering and sorting return expected QC rows.'
+		},
+		{
+			action: 'Add QC route, permission, and navigation wiring.',
+			proof_required: 'Authorized users can access QC screens and route-only evidence is not accepted without saved QC data proof.'
+		}
+	],
+	evidence: [
+		{ file: '/var/app/resolveio-ai-workspace/6a35a876bccf4dc547494e27/resolveio-all/h2sko/.resolveio-support-context/manual-ticket.request.txt', fact: 'Subject is New Feature Request and asks for QC/Sample Testing functionality.' },
+		{ file: '/var/app/resolveio-ai-workspace/6a35a876bccf4dc547494e27/resolveio-all/h2sko/angular/app/dashboard/dashboard.routing.ts', fact: 'Dashboard routes include Dry Media and sample paths but no QC dashboard route.' },
+		{ file: '/var/app/resolveio-ai-workspace/6a35a876bccf4dc547494e27/resolveio-all/h2sko/angular/app/dashboard/dashboard.permission.ts', fact: 'Dashboard permissions include Dry Media and Lab Sample entries but no QC dashboard permission.' },
+		{ file: '/var/app/resolveio-ai-workspace/6a35a876bccf4dc547494e27/resolveio-all/h2sko/angular/app/app.component.ts', fact: 'Navigation includes Dry Media entries but no QC nav item.' },
+		{ file: '/var/app/resolveio-ai-workspace/6a35a876bccf4dc547494e27/resolveio-all/h2sko/server/src/client-routes.ts', fact: 'Client route allowlist includes Dry Media/sample routes but no QC dashboard route.' }
+	],
+	status: 'passed'
+	}
+});
+assert.equal(looseFeatureRequestDiagnosisResult.valid, true);
+assert.equal(looseFeatureRequestDiagnosisResult.normalized?.issue_class, 'missing_wrong_data');
+assert.equal(looseFeatureRequestDiagnosisResult.normalized?.issue_case.reproduction_status, 'classified');
+assert.deepEqual(looseFeatureRequestDiagnosisResult.normalized?.owner_files, [
+	'h2sko/angular/app/dashboard/dashboard.routing.ts',
+	'h2sko/angular/app/dashboard/dashboard.permission.ts',
+	'h2sko/angular/app/app.component.ts',
+	'h2sko/server/src/client-routes.ts'
+]);
+assert.match(looseFeatureRequestDiagnosisResult.normalized?.issue_case.expected_result || '', /requested workflow/i);
+assert.match(looseFeatureRequestDiagnosisResult.normalized?.proof_plan.business_assertion || '', /Representative QC records persist/i);
+assert.match(looseFeatureRequestDiagnosisResult.normalized?.proof_plan.business_proof_contract?.data_or_dom_assertion || '', /Representative QC records persist/i);
+assert.ok(looseFeatureRequestDiagnosisResult.normalized?.rejected_alternatives.every((entry) => !/\[object Object\]/.test(entry)));
+assert.ok(looseFeatureRequestDiagnosisResult.evidenceQuality?.hasRootCauseEvidence);
+
+const live4433DiagnosisResult = validateResolveIOSupportDiagnosisGate({
+	support_diagnosis_gate: {
+		status: 'passed',
+		issue_case: 'On `/part/detail/:id`, the user is comparing two different tables: a check-in entry showing `Kermit` and checkout history entries showing `Midland` for the same part.',
+		issue_class: 'data_mismatch',
+		accepted_hypothesis: {
+			summary: 'Existing behavior, not a runtime defect. Check-ins and checkouts are intentionally separate data streams on this screen, and checkout warehouse values come from checkout records (`warehouse_location`).',
+			why: 'Template and publication wiring show distinct sources for check-in vs checkout rows.'
+		},
+		rejected_alternatives: [
+			{ hypothesis: 'Permission/role gating is changing warehouse visibility/value.', reason: 'No field-level permission/helper gate controls these warehouse cells; only edit/delete actions are role-wrapped.' },
+			{ hypothesis: 'Report logic is rewriting warehouse on Part Detail.', reason: 'Part Detail history tables are fed by publications, not report methods.' },
+			{ hypothesis: 'Checkout query is incorrectly constrained to Midland.', reason: 'Checkout publication filter is by part item id, so all checkout warehouses for that part are returned.' }
+		],
+		failing_path: {
+			route: '/part/detail/:id',
+			chain: 'PartDetailComponent subscribes to `checkinsWithItemId` and `checkoutsWithItemId` separately; template renders separate check-in and checkout sections; checkout table binds `checkout.warehouse_location`.',
+			visibility_gate_trace: 'No route/module/helper gating found for these specific warehouse fields in the two history tables.'
+		},
+		owner_files: [
+			'/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/angular/app/part/detail/part-detail.component.html',
+			'/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/angular/app/part/detail/part-detail.component.ts',
+			'/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/server/src/publications/checkins.ts',
+			'/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/server/src/publications/checkouts.ts'
+		],
+		proof_plan: [
+			{ step: 'Match screenshot table title/columns to exact Part Detail section.', proof: 'Shown table is `Part Check-out History`.' },
+			{ step: 'Trace component subscriptions.', proof: 'Check-ins and checkouts are loaded from separate publications.' },
+			{ step: 'Trace publication queries.', proof: 'Both are filtered by part item id and return independent record sets.' },
+			{ step: 'Classify outcome.', proof: 'General Inquiry / existing behavior unless customer requests behavior change.' }
+		],
+		evidence: [
+			{ artifact: '/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/.resolveio-support-context/manual-ticket.request.txt', finding: 'Reporter says inventory entered in Kermit on June 1 and later saw Midland.' },
+			{ artifact: '/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/.resolveio-support-context/attachments/Screenshot_2026-06-09_at_11.16.41_AM.png', finding: 'Visible grid is `Part Check-out History` with Midland rows.' },
+			{ artifact: '/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/angular/app/part/detail/part-detail.component.html', finding: 'Separate `Other Part Check-in History` and `Part Check-out History` sections; checkout warehouse uses `checkout.warehouse_location`.' },
+			{ artifact: '/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/angular/app/part/detail/part-detail.component.ts', finding: 'Separate subscriptions: `checkinsWithItemId` and `checkoutsWithItemId`.' },
+			{ artifact: '/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/server/src/publications/checkins.ts', finding: '`checkinsWithItemId` returns `Checkins.find({\'items.id\': id_item})`.' },
+			{ artifact: '/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/server/src/publications/checkouts.ts', finding: '`checkoutsWithItemId` returns `Checkouts.find({\'items.id\': id_item})`.' }
+		]
+	}
+});
+assert.equal(live4433DiagnosisResult.valid, true, live4433DiagnosisResult.blockers.join(' | '));
+assert.deepEqual(live4433DiagnosisResult.normalized?.owner_files, [
+	'h2sko/angular/app/part/detail/part-detail.component.html',
+	'h2sko/angular/app/part/detail/part-detail.component.ts',
+	'h2sko/server/src/publications/checkins.ts',
+	'h2sko/server/src/publications/checkouts.ts'
+]);
+assert.ok(live4433DiagnosisResult.normalized?.evidence.some((entry) => entry.type === 'code' && entry.ownerFiles?.includes('h2sko/server/src/publications/checkouts.ts')));
+assert.ok(live4433DiagnosisResult.evidenceQuality?.hasRootCauseEvidence);
+
+const live4433ContractAliasDiagnosisResult = validateResolveIOSupportDiagnosisGate({
+	support_diagnosis_gate: {
+		issue_case: {
+			customer_symptom: 'Part inventory entered for Kermit appears under Midland in inventory reporting.',
+			reproduction_status: 'blocked_runtime',
+			reproduction_blocker: 'No accessible staged runtime Mongo/log artifact files were present; diagnosis is based on ticket attachment plus repository code-path evidence.'
+		},
+		issue_class: 'logic_rework',
+		accepted_hypothesis: 'Warehouse attribution drifts in `server/src/methods/report.ts` because `consumePartLayers` consumes non-matching warehouse layers via fallback when matching layers are absent, so Midland checkout activity can deplete Kermit-owned layers and later reconciliation preserves incorrect warehouse attribution.',
+		rejected_alternatives: [
+			'Frontend render/binding defect in report components.',
+			'Checkout form write-path storing wrong warehouse id/name.',
+			'Attachment asset (logo) defining business behavior.'
+		],
+		failing_path: 'Frontend reads warehouse from snapshot report rows -> backend `reportDailyInventorySnapshot`/`buildPartInventorySnapshotRows` -> `buildPartInventoryLayers` -> `consumePartLayers` fallback consumption in `server/src/methods/report.ts` causes cross-warehouse layer depletion.',
+		owner_files: ['server/src/methods/report.ts'],
+		proof_plan: {
+			before: 'Use a part with Kermit check-in quantity and later Midland checkout records for the same part.',
+			action: 'Run snapshot/report method for the affected day and inspect generated `Parts` rows for that part.',
+			after: 'Kermit-origin quantity remains attributed to Kermit; Midland no longer captures that quantity due to non-matching fallback consumption.',
+			business_proof_contract: {
+				setup_state: 'Part history contains explicit Kermit inventory add plus Midland checkout activity.',
+				action_under_test: 'Part layer warehouse consumption and attribution during snapshot generation.',
+				expected_business_state_change: 'Warehouse attribution follows true ownership (Kermit entry reports under Kermit).',
+				prohibited_false_pass: 'Build/route/screenshot-only pass without row-level warehouse assertion for the affected part.',
+				proof_artifacts: ['runner-evidence/diagnosis-gate.json', 'qa-artifacts/aiqa-business-assertion.json'],
+				dom_data_assertion: 'Affected part row warehouse value equals Kermit and is not Midland for Kermit-origin quantity.'
+			}
+		},
+		evidence: [
+			{ type: 'ticket_attachment', artifact: '.resolveio-support-context/attachments/Screenshot_2026-06-09_at_11.16.41_AM.png', detail: 'Used as symptom evidence for Kermit vs Midland mismatch context.' },
+			{ type: 'code', artifact: 'server/src/methods/report.ts:440-457', detail: '`consumePartLayers` consumes fallback non-matching warehouse layers.' },
+			{ type: 'code', artifact: 'server/src/methods/report.ts:577-583', detail: 'Checkout warehouse keys drive layer consumption path.' }
+		],
+		status: 'passed'
+	}
+});
+assert.equal(live4433ContractAliasDiagnosisResult.valid, true, live4433ContractAliasDiagnosisResult.blockers.join(' | '));
+assert.equal(live4433ContractAliasDiagnosisResult.normalized?.issue_class, 'missing_wrong_data');
+assert.match(live4433ContractAliasDiagnosisResult.normalized?.proof_plan.business_assertion || '', /Kermit/i);
+assert.match(live4433ContractAliasDiagnosisResult.normalized?.proof_plan.business_proof_contract?.data_or_dom_assertion || '', /Kermit/i);
+assert.ok(live4433ContractAliasDiagnosisResult.normalized?.evidence.some((entry) => entry.type === 'code' && entry.ownerFiles?.includes('server/src/methods/report.ts')));
+
+const live4433BlockedRuntimeStringDiagnosisResult = validateResolveIOSupportDiagnosisGate({
+	support_diagnosis_gate: {
+		issue_case: 'Ticket symptom: quantity entered for Kermit appears under Midland in inventory report output; runtime reproduction is blocked in this workspace because staged Mongo/log artifacts under `/var/ai-workspace/6a283cf6f78633bb8dbc0ef6` are not accessible here.',
+		issue_class: 'missing_wrong_data',
+		accepted_hypothesis: '`server/src/methods/report.ts` is the failing owner. In `consumePartLayers`, fallback consumption of non-matching warehouse layers can deplete Kermit-owned layers during Midland checkout replay, shifting final `warehouse_location` attribution to Midland.',
+		rejected_alternatives: [
+			'Frontend rendering defect in report view (UI prints backend `warehouse_location` directly).',
+			'Checkout write-path defect (selected yard is written to warehouse fields on submit path).'
+		],
+		failing_path: 'Report UI Warehouse column <- `reportDailyInventorySnapshot` <- `buildPartInventorySnapshotRows` <- `buildPartInventoryLayers` <- `consumePartLayers` fallback non-matching layer consumption (`server/src/methods/report.ts`).',
+		owner_files: ['server/src/methods/report.ts'],
+		proof_plan: {
+			before: 'Use an affected part with Kermit check-in quantity and later Midland checkout activity.',
+			action: 'Run snapshot/report generation for the affected date and inspect `Parts` rows for that part.',
+			after: 'Kermit-origin quantity remains under Kermit and is not attributed to Midland.',
+			business_proof_contract: {
+				setup_state: 'Part history contains explicit Kermit inventory add plus Midland checkout records for the same part.',
+				action_under_test: 'Warehouse-aware layer consumption and attribution in snapshot reconstruction.',
+				expected_business_state_change: 'Warehouse attribution matches true ownership source.',
+				prohibited_false_pass: 'Build pass, route load, or screenshot-only evidence without row-level warehouse assertion for the affected part.',
+				proof_artifacts: ['runner-evidence/diagnosis-gate.json', 'qa-artifacts/aiqa-business-assertion.json'],
+				dom_data_assertion: 'Affected part row(s) show `warehouse_location` = Kermit canonical yard name for Kermit-origin quantity, not Midland.'
+			}
+		},
+		evidence: [
+			{ type: 'ticket', artifact: '.resolveio-support-context/attachments/Screenshot_2026-06-09_at_11.16.41_AM.png', detail: 'Symptom evidence for Kermit vs Midland mismatch.' },
+			{ type: 'code', artifact: 'server/src/methods/report.ts:440-457', detail: '`consumePartLayers` consumes fallback non-matching layers.' },
+			{ type: 'code', artifact: 'server/src/methods/report.ts:577-583', detail: 'Checkout warehouse keys are passed into layer consumption.' },
+			{ type: 'code', artifact: 'server/src/methods/report.ts:487-548', detail: 'Post-consumption reconciliation preserves resulting attribution.' },
+			{ type: 'code', artifact: 'angular/app/report/part-inventory-snapshot/report-part-inventory-snapshot.component.ts', detail: 'Frontend displays backend `warehouse_location` without remapping.' }
+		],
+		status: 'passed'
+	}
+});
+assert.equal(live4433BlockedRuntimeStringDiagnosisResult.valid, true, live4433BlockedRuntimeStringDiagnosisResult.blockers.join(' | '));
+assert.equal(live4433BlockedRuntimeStringDiagnosisResult.normalized?.issue_case.reproduction_status, 'blocked');
+assert.match(live4433BlockedRuntimeStringDiagnosisResult.normalized?.issue_case.reproduction_blocker || '', /runtime reproduction is blocked/i);
+
+const live4433CurrentRunnerDiagnosisResult = validateResolveIOSupportDiagnosisGate({
+	support_diagnosis_gate: {
+		issue_case: {
+			id_support_ticket: '6a283cf6f78633bb8dbc0ef6',
+			support_ticket_number: '004433',
+			issue: 'Part inventory entered for Kermit is reported under Midland in pulled inventory output.',
+			reproduction: 'blocked',
+			blocking_artifacts: [
+				'/var/ai-workspace/6a283cf6f78633bb8dbc0ef6/mongo-context (record-level exports for checkins/checkouts/inventory-daily-snapshots not present)',
+				'/var/ai-workspace/6a283cf6f78633bb8dbc0ef6/logs-context (searchable runtime error/query logs not present)'
+			]
+		},
+		issue_class: 'missing_wrong_data',
+		accepted_hypothesis: {
+			statement: 'In `server/src/methods/report.ts`, part-layer reconciliation can attribute remaining quantity to the wrong warehouse because `consumePartLayers(...)` consumes `matchingLayers.concat(fallbackLayers)`, so a checkout with non-matching warehouse keys can still consume other-yard layers and leave the final layer assignment under a different warehouse.',
+			falsifiable_test: 'Reconstruct ticket part history from checkins/checkouts for the report date and verify whether checkout rows whose `id_warehouse_location/warehouse_location` do not match Kermit still consume Kermit layers in `consumePartLayers`.'
+		},
+		rejected_alternatives: [
+			{ alternative: 'Angular rendering bug in part detail warehouse column.', why_rejected: '`part-detail.component.html` renders `checkout.warehouse_location` directly.' },
+			{ alternative: 'Manual part inventory write path saves wrong warehouse.', why_rejected: '`addPartInventory()` writes selected yard fields.' }
+		],
+		failing_path: {
+			frontend_event_data_path: 'Part inventory/report pull that shows warehouse attribution for parts.',
+			backend_method_publication_query_path: '`server/src/methods/report.ts` -> `reportDailyInventorySnapshot` -> `buildPartInventoryLayers` -> `consumePartLayers`.',
+			data_path: '`checkins` + `checkouts` -> `inventory-daily-snapshots` rows.'
+		},
+		owner_files: ['server/src/methods/report.ts'],
+		proof_plan: {
+			before: 'Capture current report response rows for the affected part/date showing warehouse misattribution.',
+			action: 'Apply minimal fix inside `consumePartLayers` to stop consuming non-matching warehouse fallback layers for warehouse-scoped checkout consumption.',
+			after: 'Re-run same report path and assert affected part quantity is attributed to Kermit, not Midland.',
+			business_proof_contract: {
+				setup_state: 'Affected part has Kermit inventory entry (6 units) and later report currently shows Midland attribution.',
+				action_under_test: 'Run `reportDailyInventorySnapshot` for the ticket date/path used by customer.',
+				expected_business_state_change: 'Row for affected part quantity is assigned to Kermit warehouse identity.',
+				prohibited_false_pass: 'Build pass, route load, or screenshot-only proof without row-level data assertion on affected part warehouse.',
+				proof_artifacts: ['runner-evidence/diagnosis-gate.json', 'qa-artifacts/aiqa-business-assertion.json'],
+				dom_data_assertion: 'For target `metadata.id_part`, returned `rows` contain the affected quantity with `warehouse_location` mapped to Kermit, and do not misattribute that quantity to Midland.'
+			}
+		},
+		evidence: [
+			{ type: 'attachment', artifact: '/var/ai-workspace/6a283cf6f78633bb8dbc0ef6/attachments/Screenshot 2026-06-09 at 11.16.41AM.png', supports: 'Customer-observed warehouse mismatch context.' },
+			{ type: 'code', artifact: '/var/app/resolveio-ai-workspace/6a35ef09648b18962650d369/resolveio-all/h2sko/server/src/methods/report.ts', supports: 'Fallback layer consumption path in part inventory reconciliation is the smallest owning break path.' }
+		],
+		status: 'passed'
+	}
+});
+assert.equal(live4433CurrentRunnerDiagnosisResult.valid, true, live4433CurrentRunnerDiagnosisResult.blockers.join(' | '));
+assert.equal(live4433CurrentRunnerDiagnosisResult.normalized?.issue_case.reproduction_status, 'blocked');
+assert.match(live4433CurrentRunnerDiagnosisResult.normalized?.issue_case.customer_complaint || '', /Kermit.*Midland/i);
+assert.match(live4433CurrentRunnerDiagnosisResult.normalized?.issue_case.reproduction_blocker || '', /mongo-context/i);
+assert.deepEqual(live4433CurrentRunnerDiagnosisResult.normalized?.owner_files, ['server/src/methods/report.ts']);
+assert.ok(live4433CurrentRunnerDiagnosisResult.normalized?.accepted_hypothesis.evidence.some((entry) => /Fallback layer consumption path/i.test(entry)));
+
+const live4433TicketAttachmentOnlyDiagnosisResult = validateResolveIOSupportDiagnosisGate({
+	support_diagnosis_gate: {
+		issue_case: 'Inventory entered for Kermit is reported under Midland in part inventory reporting.',
+		issue_class: 'missing_wrong_data',
+		accepted_hypothesis: 'The owning defect is in `server/src/methods/report.ts`: `consumePartLayers` consumes fallback non-matching warehouse layers when matching layers are unavailable, so Midland checkout replay can consume Kermit-owned layers and shift `warehouse_location` attribution.',
+		rejected_alternatives: [
+			'Frontend report rendering/binding bug.',
+			'Checkout write-path storing incorrect warehouse fields.',
+			'Logo/branding attachment affecting inventory behavior.'
+		],
+		failing_path: 'Report UI warehouse display -> `reportDailyInventorySnapshot` -> `buildPartInventorySnapshotRows` -> `buildPartInventoryLayers` -> `consumePartLayers` fallback non-matching layer consumption in `server/src/methods/report.ts`.',
+		owner_files: ['server/src/methods/report.ts'],
+		proof_plan: {
+			before: 'Use an affected part with Kermit check-in quantity and later Midland checkout activity for the same part.',
+			action: 'Run snapshot/report generation for the affected date and inspect generated `Parts` rows for that part.',
+			after: 'Kermit-origin quantity remains attributed to Kermit and is not attributed to Midland.',
+			business_proof_contract: {
+				setup_state: 'Part history contains explicit Kermit inventory add and Midland checkout records.',
+				action_under_test: 'Warehouse-aware layer consumption and attribution during snapshot reconstruction.',
+				expected_business_state_change: 'Reported warehouse attribution matches true ownership source.',
+				prohibited_false_pass: 'Build pass, route load, or screenshot-only proof without row-level warehouse assertion for the affected part.',
+				proof_artifacts: ['runner-evidence/diagnosis-gate.json', 'qa-artifacts/aiqa-business-assertion.json'],
+				dom_data_assertion: 'Affected part rows show `warehouse_location` = Kermit canonical yard name for Kermit-origin quantity, not Midland.'
+			}
+		},
+		evidence: [
+			{ type: 'attachment', artifact: '.resolveio-support-context/attachments/Screenshot_2026-06-09_at_11.16.41_AM.png', detail: 'Primary symptom evidence for Kermit vs Midland mismatch.' },
+			{ type: 'code', artifact: 'server/src/methods/report.ts:440-457', detail: '`consumePartLayers` consumes fallback non-matching layers.' },
+			{ type: 'code', artifact: 'server/src/methods/report.ts:577-583', detail: 'Checkout warehouse keys are passed into layer consumption.' },
+			{ type: 'code', artifact: 'server/src/methods/report.ts:487-548', detail: 'Reconciliation after consumption preserves resulting attribution.' },
+			{ type: 'code', artifact: 'angular/app/report/part-inventory-snapshot/report-part-inventory-snapshot.component.ts', detail: 'Frontend displays backend `warehouse_location` directly.' }
+		],
+		status: 'passed'
+	}
+});
+assert.equal(live4433TicketAttachmentOnlyDiagnosisResult.valid, true, live4433TicketAttachmentOnlyDiagnosisResult.blockers.join(' | '));
+assert.equal(live4433TicketAttachmentOnlyDiagnosisResult.normalized?.issue_case.reproduction_status, 'classified');
+
+const classifiedFeatureRequestWithoutEvidence = validateResolveIOSupportDiagnosisGate({
+	support_diagnosis_gate: {
+		issue_case: 'Customer requested a new QC manager screen for sample testing.',
+		issue_class: 'feature_request',
+		accepted_hypothesis: 'This is net-new feature scope because no QC manager route/module exists.',
+		rejected_alternatives: [{ hypothesis: 'Existing QC manager is broken.', why_rejected: 'No QC manager route exists.' }],
+		failing_path: 'none_existing route/module',
+		owner_files: [
+			'/var/app/resolveio-ai-workspace/job/resolveio-all/h2sko/angular/app/dashboard/dashboard.routing.ts',
+			'/var/app/resolveio-ai-workspace/job/resolveio-all/h2sko/server/src/client-routes.ts'
+		],
+		proof_plan: [{
+			action: 'Add QC manager route and persist a sample-testing record.',
+			proof_required: 'Saved QC sample record appears in the manager list with pass/fail status.'
+		}],
+		status: 'passed'
+	}
+});
+assert.equal(classifiedFeatureRequestWithoutEvidence.valid, true);
+assert.ok(classifiedFeatureRequestWithoutEvidence.normalized?.evidence.some((entry) => entry.type === 'ticket'));
+assert.ok(classifiedFeatureRequestWithoutEvidence.normalized?.evidence.some((entry) => entry.type === 'code' && entry.ownerFiles?.includes('h2sko/angular/app/dashboard/dashboard.routing.ts')));
+
+const malformedStructuredDiagnosisResult = validateResolveIOSupportDiagnosisGate({
+	issue_case: {
+		reproduction_status: 'reproduced'
+	},
+	issue_class: 'missing_wrong_data',
+	accepted_hypothesis: {
+		statement: 'syncChemicalYardInventoryLocations repopulates every chemical yard list.',
+		evidence: [{ summary: 'Dry-run proof exists.' }]
+	},
+	rejected_alternatives: [{ summary: 'Route auth was not the cause.' }],
+	failing_path: {
+		backend: 'geochem/server/src/methods/chemicals.ts'
+	},
+	owner_files: [{ path: 'geochem/server/src/methods/chemicals.ts' }],
+	proof_plan: {},
+	evidence: [{ type: 'mongo' as const, summary: 'Bossier yard before/after dry-run proof.' }],
+	status: 'passed'
+});
+assert.equal(malformedStructuredDiagnosisResult.valid, false);
+assert.equal(malformedStructuredDiagnosisResult.status, 'incomplete');
+assert.equal(malformedStructuredDiagnosisResult.normalized?.status, 'incomplete');
+assert.deepEqual(malformedStructuredDiagnosisResult.normalized?.owner_files, ['geochem/server/src/methods/chemicals.ts']);
+assert.equal(malformedStructuredDiagnosisResult.normalized?.owner_files.some((entry) => entry === '[object Object]'), false);
+assert.ok(malformedStructuredDiagnosisResult.blockers.some((blocker) => /issue_case\.customer_complaint/i.test(blocker)));
+assert.ok(malformedStructuredDiagnosisResult.blockers.some((blocker) => /proof_plan\.action/i.test(blocker)));
+
+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)));
+assert.equal(validProbePlan.qaRows.length, 1);
+assert.equal(validProbePlan.activeQaRow?.requires_aiqa_business_assertion, true);
+assert.match(validProbePlan.activeQaRow?.expected_dom_or_data_proof || '', /dropdown DOM snapshot|included\/excluded row proof|disabled driver/i);
+
+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 routeOnlyReproductionDiagnosis = validateResolveIOSupportDiagnosisGate({
+	...validDiagnosis,
+	evidence: [
+		{ type: 'ticket' as const, summary: 'Ticket reports disabled driver selection in BOL workflow.' },
+		{ type: 'browser' as const, summary: 'Route loaded and screenshot captured.', artifactPath: 'qa-artifacts/004999-route-loaded.png' },
+		{ type: 'code' as const, summary: 'Publication lacks disabled-user filter.' }
+	]
+});
+assert.equal(routeOnlyReproductionDiagnosis.valid, false);
+assert.equal(routeOnlyReproductionDiagnosis.evidenceQuality?.routeOnlyReproductionEvidenceCount, 1);
+assert.equal(routeOnlyReproductionDiagnosis.evidenceQuality?.businessReproductionEvidenceCount, 0);
+assert.ok(routeOnlyReproductionDiagnosis.blockers.some((blocker) => /route-load or screenshot-only/i.test(blocker)));
+assert.ok(routeOnlyReproductionDiagnosis.proofMatrix?.blockers.some((blocker) => /business reproduction evidence/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 structuredOwnerEvidenceDiagnosis = validateResolveIOSupportDiagnosisGate({
+	...validDiagnosis,
+	failing_path: {
+		...validDiagnosis.failing_path,
+		frontend: 'Driver select consumes candidate records.',
+		backend: 'Driver publication produces the candidate list.'
+	},
+	evidence: [
+		{ type: 'ticket' as const, summary: 'Ticket reports disabled driver selection in BOL workflow.' },
+		{ type: 'qa' as const, summary: 'Browser QA reproduced disabled driver selection.', artifactPath: 'qa-artifacts/004999-disabled-driver-before.json' },
+		{ type: 'code' as const, summary: 'Frontend driver select owner file inspected.', ownerFiles: ['geochem/angular/app/bol/new/bol-new.component.ts'] },
+		{ type: 'code' as const, summary: 'Backend driver publication owner file inspected.', ownerFiles: ['geochem/server/src/publications/drivers.ts'] }
+	]
+});
+assert.equal(structuredOwnerEvidenceDiagnosis.valid, true);
+assert.equal(structuredOwnerEvidenceDiagnosis.proofMatrix?.ownerFileCoverage.every((entry) => entry.covered), true);
+
+const unsupportedOwnerProofMatrix = buildResolveIOSupportDiagnosisProofMatrix({
+	...validDiagnosis,
+	owner_files: [
+		...validDiagnosis.owner_files,
+		'geochem/server/src/methods/unrelated-driver-cleanup.ts'
+	]
+});
+assert.equal(unsupportedOwnerProofMatrix.status, 'incomplete');
+assert.ok(unsupportedOwnerProofMatrix.blockers.some((blocker) => /not tied to failing_path or structured evidence ownerFiles/i.test(blocker)));
+
+const unsupportedOwnerDiagnosis = validateResolveIOSupportDiagnosisGate({
+	...validDiagnosis,
+	owner_files: [
+		...validDiagnosis.owner_files,
+		'geochem/server/src/methods/unrelated-driver-cleanup.ts'
+	]
+});
+assert.equal(unsupportedOwnerDiagnosis.valid, false);
+assert.ok(unsupportedOwnerDiagnosis.blockers.some((blocker) => /Proof matrix owner_files/i.test(blocker)));
+
+const ownerScopedRepairContract = buildResolveIOSupportOwnerScopedRepairContract({
+	diagnosisGate: validDiagnosis,
+	changedFiles: validDiagnosis.owner_files,
+	now: '2026-06-06T00:00:12.000Z'
+});
+assert.equal(ownerScopedRepairContract.status, 'ready');
+assert.equal(ownerScopedRepairContract.sourceEditsAllowed, true);
+assert.equal(ownerScopedRepairContract.canRunWithoutCodexMonitor, true);
+assert.deepEqual(ownerScopedRepairContract.ownerFiles, validDiagnosis.owner_files);
+assert.equal(ownerScopedRepairContract.patchUnits.length, validDiagnosis.owner_files.length);
+assert.ok(ownerScopedRepairContract.requiredEvidenceAfterRepair.some((entry) => /AIQaBusinessAssertion/i.test(entry)));
+assert.ok(ownerScopedRepairContract.forbiddenActions.some((entry) => /outside owner_files/i.test(entry)));
+
+const pricingDiagnosisWithProjectRootChangedFile = {
+	issue_case: {
+		customer_complaint: 'Pricing upload completes, but the import does not attach every expected pricing row.',
+		expected_result: 'Imported pricing rows are saved and attached to the pricing workflow after upload.',
+		observed_result: 'Upload succeeds, but only part of the pricing data is attached/imported.',
+		route_module: '/dashboard/manage/pricing',
+		account_customer_context: '004345 production pricing import templates',
+		reproduction_status: 'reproduced' as const
+	},
+	issue_class: 'upload_import' as const,
+	accepted_hypothesis: {
+		statement: 'The production pricing import view and backend import method disagree on imported-row attachment/count handling.',
+		falsifiable_test: 'Run the uploaded pricing template through the production pricing import flow and compare attached rows to the persisted import result.',
+		evidence: [
+			'Ticket 004345 reports upload now works but importing/attaching every row is still incomplete.',
+			'Production pricing import view and pricing method are the only files on the verified upload/import path.'
+		]
+	},
+	rejected_alternatives: ['Route/auth failure rejected because the pricing route loads and upload completes.', 'Frac/one-off pricing views rejected because the complaint is production pricing import.'],
+	failing_path: {
+		frontend: 'angular/app/widgets/pricing/sale/production/viewcustomer/pricing-sale-production-viewcustomer.component.ts import action',
+		backend: 'server/src/methods/pricing.ts import persistence',
+		description: 'Production pricing import flow dispatches to backend pricing import persistence and then shows/attaches imported rows.'
+	},
+	owner_files: [
+		'angular/app/widgets/pricing/sale/production/viewcustomer/pricing-sale-production-viewcustomer.component.ts',
+		'server/src/methods/pricing.ts'
+	],
+	proof_plan: {
+		before: 'Run the attached production pricing template and observe that imported/attached row count is incomplete.',
+		action: 'Upload and import the production pricing template from the pricing view.',
+		after: 'Every valid uploaded pricing row is attached and visible/persisted in the pricing import result.',
+		business_assertion: 'Production pricing import attaches every valid uploaded row and reports the persisted imported count.',
+		route: '/dashboard/manage/pricing',
+		data_assertion: 'Mongo persisted pricing rows for the import match the import result row count.',
+		business_proof_contract: {
+			issue_class: 'upload_import' as const,
+			setup_state: 'Production pricing template contains multiple valid rows to import.',
+			action_under_test: 'Upload and import the production pricing template.',
+			expected_business_state_change: 'Every valid uploaded row is attached/persisted and the import result count matches persisted rows.',
+			prohibited_false_pass: 'Upload success, route load, screenshot, or scorecard alone is not acceptance.',
+			proof_artifacts: ['004345 import result JSON', '004345 Mongo pricing row delta', '004345 pricing import screenshot'],
+			data_or_dom_assertion: 'Imported row count equals persisted pricing row count and the imported rows are visible in the pricing workflow.'
+		}
+	},
+	evidence: [
+		{ type: 'ticket' as const, summary: 'Ticket 004345 says upload works but not all pricing import data attaches.' },
+		{
+			type: 'code' as const,
+			summary: 'Production pricing view owns the upload/import action.',
+			ownerFiles: ['angular/app/widgets/pricing/sale/production/viewcustomer/pricing-sale-production-viewcustomer.component.ts']
+		},
+		{
+			type: 'code' as const,
+			summary: 'Pricing method owns import persistence and row count.',
+			ownerFiles: ['server/src/methods/pricing.ts']
+		},
+		{ type: 'qa' as const, summary: 'Runtime import proof artifact compares uploaded rows to persisted pricing rows.', artifactPath: 'qa-artifacts/004345-production-pricing-import-proof.json' }
+	],
+	status: 'passed' as const
+};
+const pricingProjectRootDiff = buildResolveIOSupportOwnerScopedRepairContract({
+	diagnosisGate: pricingDiagnosisWithProjectRootChangedFile,
+	changedFiles: [
+		'geochem/angular/app/widgets/pricing/sale/production/viewcustomer/pricing-sale-production-viewcustomer.component.ts',
+		'geochem/server/src/methods/pricing.ts'
+	],
+	now: '2026-06-06T00:00:12.500Z'
+});
+assert.equal(pricingProjectRootDiff.status, 'ready');
+assert.deepEqual(pricingProjectRootDiff.outsideOwnerFiles, []);
+
+const blockedOwnerScopedRepairContract = buildResolveIOSupportOwnerScopedRepairContract({
+	diagnosisGate: validDiagnosis,
+	changedFiles: [
+		...validDiagnosis.owner_files,
+		'geochem/server/src/methods/unrelated-driver-cleanup.ts'
+	],
+	now: '2026-06-06T00:00:13.000Z'
+});
+assert.equal(blockedOwnerScopedRepairContract.status, 'blocked');
+assert.equal(blockedOwnerScopedRepairContract.sourceEditsAllowed, false);
+assert.ok(blockedOwnerScopedRepairContract.outsideOwnerFiles.includes('geochem/server/src/methods/unrelated-driver-cleanup.ts'));
+assert.ok(blockedOwnerScopedRepairContract.blockers.some((blocker) => /outside owner_files/i.test(blocker)));
+
+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 placeholderDiagnosis = validateResolveIOSupportDiagnosisGate({
+	...validDiagnosis,
+	issue_case: {
+		...validDiagnosis.issue_case,
+		expected_result: 'Should work',
+		observed_result: 'Not working'
+	},
+	accepted_hypothesis: {
+		statement: 'There is probably a bug.',
+		falsifiable_test: 'Test the issue.',
+		evidence: ['Something is wrong.']
+	},
+	rejected_alternatives: ['Not route.'],
+	proof_plan: {
+		...validDiagnosis.proof_plan,
+		before: 'Before state.',
+		action: 'Test the ticket.',
+		after: 'It works.',
+		business_assertion: 'Issue is fixed.',
+		business_proof_contract: {
+			...validDiagnosis.proof_plan.business_proof_contract,
+			setup_state: 'Before state.',
+			action_under_test: 'Test the issue.',
+			expected_business_state_change: 'It works.',
+			data_or_dom_assertion: 'Looks right.'
+		}
+	}
+});
+assert.equal(placeholderDiagnosis.valid, false);
+assert.ok(placeholderDiagnosis.blockers.some((blocker) => /too generic|placeholder-like/i.test(blocker)));
+assert.ok(placeholderDiagnosis.blockers.some((blocker) => /accepted_hypothesis\.statement/i.test(blocker)));
+assert.ok(placeholderDiagnosis.blockers.some((blocker) => /proof_plan\.business_assertion/i.test(blocker)));
+
+const nonProductOwnerDiagnosis = validateResolveIOSupportDiagnosisGate({
+	...validDiagnosis,
+	owner_files: [
+		'qa-artifacts/disabled-driver-before.png',
+		'geochem/server/tests/drivers.test.ts'
+	]
+});
+assert.equal(nonProductOwnerDiagnosis.valid, false);
+assert.ok(nonProductOwnerDiagnosis.blockers.some((blocker) => /not tests\/docs\/artifacts\/logs\/screenshots/i.test(blocker)));
+
+const diagnosisPackOwnerDiagnosis = validateResolveIOSupportDiagnosisGate({
+	...validDiagnosis,
+	owner_files: [
+		'/var/app/resolveio-ai-workspace/job-1/resolveio-all/geochem/support-diagnosis-pack-abcd1234.json'
+	],
+	failing_path: {
+		...validDiagnosis.failing_path,
+		backend: '/var/app/resolveio-ai-workspace/job-1/resolveio-all/geochem/support-diagnosis-pack-abcd1234.json'
+	},
+	evidence: [
+		...validDiagnosis.evidence,
+		{
+			type: 'other' as const,
+			summary: 'Diagnosis pack path is evidence context, not an editable product owner file.',
+			artifactPath: '/var/app/resolveio-ai-workspace/job-1/resolveio-all/geochem/support-diagnosis-pack-abcd1234.json'
+		}
+	]
+});
+assert.equal(diagnosisPackOwnerDiagnosis.valid, false);
+assert.ok(diagnosisPackOwnerDiagnosis.blockers.some((blocker) => /broad or unsafe path|not tests\/docs\/artifacts\/logs\/screenshots/i.test(blocker)));
+
+const vagueArtifactDiagnosis = validateResolveIOSupportDiagnosisGate({
+	...validDiagnosis,
+	proof_plan: {
+		...validDiagnosis.proof_plan,
+		business_proof_contract: {
+			...validDiagnosis.proof_plan.business_proof_contract,
+			proof_artifacts: ['screenshot', 'browser trace']
+		}
+	}
+});
+assert.equal(vagueArtifactDiagnosis.valid, false);
+assert.ok(vagueArtifactDiagnosis.blockers.some((blocker) => /proof_artifacts are too generic/i.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 spoofedMetadataBusinessProofReadiness = evaluateResolveIOSupportBusinessProofReadiness({
+	diagnosisGate: validDiagnosis,
+	businessAssertions: [{
+		assertion: 'The route loaded and the page looks correct.',
+		status: 'pass',
+		workflow: 'Open the BOL route.',
+		route: validDiagnosis.proof_plan.route,
+		action: 'Open the route.',
+		expected: 'The page is visible.',
+		observed: 'The page rendered.',
+		dataProof: 'Screenshot captured.',
+		artifactPaths: ['qa-artifacts/generic-route-proof.png'],
+		metadata: { supportDiagnosisProof: true }
+	}]
+});
+assert.equal(spoofedMetadataBusinessProofReadiness.ready, false);
+assert.equal(spoofedMetadataBusinessProofReadiness.status, 'route_only');
+assert.equal(spoofedMetadataBusinessProofReadiness.reason, 'support_business_proof_route_only_or_acceptance_blocked');
+assert.ok(spoofedMetadataBusinessProofReadiness.blockers.some((blocker) => /Route probe|shell\/screenshot/i.test(blocker)));
+
+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 spoofedMetadataReplyPolicy = decideResolveIOSupportCustomerReplyPolicy({
+	diagnosisGate: validDiagnosis,
+	outcomeLabel: 'accepted',
+	confidence: { level: 'high', category: 'business_proof', shouldBlockPr: false },
+	businessAssertions: [{
+		assertion: 'The route loaded and the page looks correct.',
+		status: 'pass',
+		workflow: 'Open the BOL route.',
+		route: validDiagnosis.proof_plan.route,
+		action: 'Open the route.',
+		expected: 'The page is visible.',
+		observed: 'The page rendered.',
+		dataProof: 'Screenshot captured.',
+		artifactPaths: ['qa-artifacts/generic-route-proof.png'],
+		metadata: { supportDiagnosisProof: true }
+	}],
+	releaseStatus: 'completed'
+});
+assert.equal(spoofedMetadataReplyPolicy.action, 'hold_internal');
+assert.equal(spoofedMetadataReplyPolicy.reason, 'support_reply_rejects_route_only_business_proof');
+assert.equal(spoofedMetadataReplyPolicy.readinessContract?.canDraftCustomerReply, false);
+assert.equal(spoofedMetadataReplyPolicy.readinessContract?.status, 'blocked_until_business_proof');
+assert.ok(spoofedMetadataReplyPolicy.humanReviewPacket?.blockers.some((blocker) => /Route probe|shell\/screenshot/i.test(blocker)));
+
+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 legacy4433Diagnosis = extractResolveIOSupportDiagnosisGateFromText(JSON.stringify({
+	support_diagnosis_gate: {
+		status: 'passed',
+		issue_case: 'Part inventory was entered with warehouse Kermit, but later checkout/pull history showed warehouse Midland.',
+		issue_class: 'general_inquiry',
+		accepted_hypothesis: 'Repository evidence shows two independent warehouse fields are used by design: manual check-in saves checkin.yard/id_yard, while pull/checkout saves checkout.warehouse_location/id_warehouse_location.',
+		rejected_alternatives: [
+			'Publication rewrite/default hypothesis rejected: checkoutsWithItemId returns raw checkout docs without warehouse remap.',
+			'Permission/visibility gate hypothesis rejected: checkout warehouse cell is directly rendered from checkout.warehouse_location with no role/template guard.',
+			'Missing check-in warehouse persistence hypothesis rejected: addPartInventory stores selected yard into checkin.id_yard and checkin.yard.'
+		],
+		failing_path: {
+			route: '/part/detail/:id',
+			path_chain: [
+				'/part/checkout submit stores checkout warehouse fields',
+				'checkoutsWithItemId publishes checkout documents',
+				'Part Check-out History renders checkout.warehouse_location'
+			],
+			assessment: 'Observed output follows the checkout warehouse source.'
+		},
+		owner_files: [
+			'angular/app/part/checkout/part-checkout.component.ts',
+			'angular/app/part/detail/part-detail.component.ts',
+			'angular/app/part/detail/part-detail.component.html',
+			'server/src/publications/checkouts.ts'
+		],
+		proof_plan: [
+			'Read-only compare reported checkout document id_warehouse_location/warehouse_location with expected value for the event.',
+			'Read-only compare corresponding check-in document id_yard/yard for the same part/time window.'
+		],
+		evidence: [
+			'Ticket text reports Kermit entry then Midland print outcome.',
+			'part-detail component subscribes to checkoutsWithItemId for checkout history rows.',
+			'checkouts publication returns raw Checkouts.find({items.id: id_item}) data.',
+			'part-detail template renders checkout.warehouse_location directly.',
+			'part-checkout submit path persists checkout warehouse fields from selected checkout warehouse.'
+		]
+	}
+}));
+assert.ok(legacy4433Diagnosis);
+assert.equal(legacy4433Diagnosis?.issue_class, 'missing_wrong_data');
+assert.equal(legacy4433Diagnosis?.issue_case.reproduction_status, 'classified');
+assert.match(legacy4433Diagnosis?.issue_case.customer_complaint || '', /Kermit/);
+assert.match(legacy4433Diagnosis?.proof_plan.business_assertion || '', /Kermit|Midland/);
+assert.ok(legacy4433Diagnosis?.evidence.some((entry) => entry.type === 'ticket'));
+assert.ok(legacy4433Diagnosis?.evidence.some((entry) => entry.type === 'code' && entry.ownerFiles.includes('server/src/publications/checkouts.ts')));
+const legacy4433Validation = validateResolveIOSupportDiagnosisGate(legacy4433Diagnosis);
+assert.equal(legacy4433Validation.valid, true, legacy4433Validation.blockers.join(' | '));
+
+const workflowBehavior4433Diagnosis = extractResolveIOSupportDiagnosisGateFromText(JSON.stringify({
+	support_diagnosis_gate: {
+		status: 'passed',
+		issue_case: 'General Inquiry: repository evidence indicates existing behavior (not a confirmed runtime failure).',
+		issue_class: 'workflow_behavior',
+		accepted_hypothesis: 'The warehouse shown in later inventory pull/print comes from checkout records (`id_warehouse_location`/`warehouse_location`), while the June 1 entry used check-in fields (`id_yard`/`yard`); these sources are separate and can differ (Kermit vs Midland).',
+		rejected_alternatives: [
+			{
+				hypothesis: 'Midland is hardcoded/defaulted in checkout UI.',
+				reason: 'Checkout requires explicit warehouse selection; no Midland hardcode/default path found in checkout component.'
+			},
+			{
+				hypothesis: 'Print/history warehouse is derived from check-in yard and mapped incorrectly.',
+				reason: 'Pick-ticket/history render checkout warehouse fields directly.'
+			},
+			{
+				hypothesis: 'Checkout publication rewrites warehouse values.',
+				reason: 'checkouts publication returns stored checkout docs without remapping from check-ins.'
+			}
+		],
+		failing_path: 'Manual part check-in stored with Kermit yard -> later part checkout stored with Midland warehouse -> pull/print and checkout history display checkout warehouse fields (Midland).',
+		owner_files: [
+			'angular/app/part/checkout/part-checkout.component.ts',
+			'angular/app/document/pick-ticket/report-doc-pick-ticket.component.html',
+			'angular/app/part/detail/part-detail.component.ts',
+			'server/src/publications/checkouts.ts'
+		],
+		proof_plan: [
+			{
+				action: 'Reproduce with one part: manual check-in at Kermit, then checkout selecting Midland.',
+				proof_required: 'Check-in history shows Kermit while checkout history/pick-ticket show Midland.'
+			},
+			{
+				action: 'If desired behavior is warehouse inheritance from latest check-in, log as behavior change.',
+				proof_required: 'Feature Request approved for auto-default/lock checkout warehouse from latest check-in yard.'
+			}
+		],
+		evidence: [
+			{
+				type: 'artifact',
+				path: '.resolveio-support-context/manual-ticket.request.txt',
+				detail: 'Reporter states June 1 Kermit entry and later Midland print.'
+			},
+			{
+				type: 'artifact',
+				path: '.resolveio-support-context/attachments/Screenshot_2026-06-09_at_11.16.41_AM.png',
+				detail: 'Screenshot shows Kermit in check-in row and Midland in checkout history rows.'
+			},
+			{
+				type: 'code',
+				path: 'angular/app/part/checkout/part-checkout.component.ts',
+				detail: 'Checkout payload persists selected warehouse fields into checkouts.'
+			},
+			{
+				type: 'code',
+				path: 'angular/app/document/pick-ticket/report-doc-pick-ticket.component.html',
+				detail: 'Rendered warehouse is from checkout data (`data.warehouse_location` / `part.warehouse_location`).'
+			},
+			{
+				type: 'code',
+				path: 'angular/app/part/detail/part-detail.component.ts',
+				detail: 'Checkout history sourced from checkoutsWithItemId.'
+			},
+			{
+				type: 'code',
+				path: 'server/src/publications/checkouts.ts',
+				detail: 'Publication returns checkout docs directly.'
+			}
+		]
+	}
+}));
+assert.ok(workflowBehavior4433Diagnosis);
+assert.equal(workflowBehavior4433Diagnosis?.issue_class, 'missing_wrong_data');
+assert.match(workflowBehavior4433Diagnosis?.issue_case.customer_complaint || '', /Kermit/);
+assert.ok(workflowBehavior4433Diagnosis?.evidence.some((entry) => entry.type === 'ticket' && /Reporter/.test(entry.summary)));
+assert.ok(workflowBehavior4433Diagnosis?.evidence.some((entry) => entry.type === 'browser' && /Screenshot/.test(entry.summary)));
+assert.ok(workflowBehavior4433Diagnosis?.evidence.some((entry) => entry.type === 'code' && entry.ownerFiles.includes('server/src/publications/checkouts.ts')));
+const workflowBehavior4433Validation = validateResolveIOSupportDiagnosisGate(workflowBehavior4433Diagnosis);
+assert.equal(workflowBehavior4433Validation.valid, true, workflowBehavior4433Validation.blockers.join(' | '));
+
+const rationale4433Diagnosis = extractResolveIOSupportDiagnosisGateFromText(JSON.stringify({
+	support_diagnosis_gate: {
+		issue_case: {
+			classification: 'General Inquiry',
+			rationale: 'The traced repository path shows the displayed warehouse is sourced from checkout records, while manual inventory entry stores yard on check-in records; this is a cross-flow expectation mismatch rather than a proven defect in the shown code path.',
+			behavior: 'requested_behavior_change'
+		},
+		issue_class: 'general_inquiry',
+		accepted_hypothesis: {
+			summary: 'Part Detail checkout history renders `checkouts.warehouse_location`, and checkout warehouse is set from the warehouse selected during checkout. Manual inventory check-ins persist `checkins.id_yard/yard` separately, so entering inventory at Kermit does not force later checkout/history warehouse away from Midland.',
+			evidence_refs: [
+				'angular/app/part/detail/part-detail.component.ts:67',
+				'angular/app/part/detail/part-detail.component.html:196',
+				'server/src/publications/checkouts.ts:8',
+				'angular/app/part/checkout/part-checkout.component.ts:275',
+				'angular/app/part/checkout/part-checkout.component.ts:413',
+				'server/src/models/checkin.model.ts:10',
+				'server/src/models/part.model.ts:13'
+			]
+		},
+		rejected_alternatives: [
+			{
+				hypothesis: 'Checkout publication remaps warehouse values at read time.',
+				rejection_reason: 'checkoutsWithItemId returns raw checkout documents with no warehouse transformation.',
+				evidence: 'server/src/publications/checkouts.ts:8-10'
+			},
+			{
+				hypothesis: 'Checkout form hardcodes/defaults Midland.',
+				rejection_reason: 'Warehouse value is synchronized from selected id_warehouse_location; no hardcoded Midland assignment in traced flow.',
+				evidence: 'angular/app/part/checkout/part-checkout.component.ts:418-427'
+			}
+		],
+		failing_path: {
+			reported_path: 'User entered part inventory at Kermit and later saw Midland when pulling inventory.',
+			verified_path: 'Part Detail -> Part Check-out History uses checkout publication data and renders checkout.warehouse_location; check-in yard is a separate persisted field path.'
+		},
+		owner_files: [
+			'angular/app/part/detail/part-detail.component.ts',
+			'angular/app/part/detail/part-detail.component.html',
+			'server/src/publications/checkouts.ts',
+			'angular/app/part/checkout/part-checkout.component.ts',
+			'server/src/models/checkin.model.ts',
+			'server/src/models/part.model.ts'
+		],
+		proof_plan: [
+			'Verify the warehouse column binding source in Part Check-out History.',
+			'Verify checkout submit persistence source for id_warehouse_location and warehouse_location.',
+			'Verify model separation between global part quantity and check-in yard fields.'
+		],
+		evidence: [
+			{
+				file: '.resolveio-support-context/manual-ticket.request.txt:1-4',
+				fact: 'Ticket states inventory entered at Kermit and later pulled/printed as Midland.'
+			},
+			{
+				file: 'angular/app/part/detail/part-detail.component.ts:67-73',
+				fact: 'History subscribes to publications.checkoutsWithItemId(this.id).'
+			},
+			{
+				file: 'angular/app/part/detail/part-detail.component.html:196',
+				fact: 'Warehouse cell renders checkout.warehouse_location.'
+			},
+			{
+				file: 'server/src/publications/checkouts.ts:8-10',
+				fact: 'Publication returns raw checkouts by item id.'
+			},
+			{
+				file: 'angular/app/part/checkout/part-checkout.component.ts:275-282',
+				fact: 'Checkout payload is built from form values on submit.'
+			},
+			{
+				file: 'angular/app/part/checkout/part-checkout.component.ts:413-427',
+				fact: 'Warehouse value is set from selected yard (id_warehouse_location).'
+			},
+			{
+				file: 'server/src/models/checkin.model.ts:10-11',
+				fact: 'Check-in model persists yard and id_yard.'
+			},
+			{
+				file: 'server/src/models/part.model.ts:13-14',
+				fact: 'Part model tracks global quantity only (quantity, quantity_string).'
+			}
+		],
+		status: 'passed'
+	}
+}));
+assert.ok(rationale4433Diagnosis);
+assert.equal(rationale4433Diagnosis?.issue_class, 'missing_wrong_data');
+assert.match(rationale4433Diagnosis?.issue_case.customer_complaint || '', /Kermit/);
+assert.equal(rationale4433Diagnosis?.issue_case.reproduction_status, 'classified');
+assert.ok(rationale4433Diagnosis?.evidence.some((entry) => entry.type === 'ticket'));
+assert.ok(rationale4433Diagnosis?.evidence.some((entry) => entry.type === 'code' && entry.ownerFiles.includes('server/src/publications/checkouts.ts')));
+assert.ok(rationale4433Diagnosis?.accepted_hypothesis.evidence.some((entry) => /part-detail\.component\.ts/.test(entry)));
+assert.ok(rationale4433Diagnosis?.rejected_alternatives.some((entry) => /rejected because|Checkout publication remaps/i.test(entry)));
+const rationale4433Validation = validateResolveIOSupportDiagnosisGate(rationale4433Diagnosis);
+assert.equal(rationale4433Validation.valid, true, rationale4433Validation.blockers.join(' | '));
+
+const dataVisibility4433Diagnosis = extractResolveIOSupportDiagnosisGateFromText(JSON.stringify({
+	support_diagnosis_gate: {
+		issue_case: {
+			request_classification: 'General Inquiry',
+			classification_rationale: 'The observed Kermit vs Midland mismatch is explained by existing code paths that read/write different persisted fields (check-in yard vs checkout warehouse), with no evidence of a broken guard or transformation.',
+			behavior_type: 'Requested behavior change, not existing behavior failure'
+		},
+		issue_class: 'data_visibility_mapping',
+		accepted_hypothesis: {
+			statement: 'Part Detail -> Part Check-out History intentionally renders checkout.warehouse_location from checkout documents, while manual inventory entry stores checkin.id_yard/checkin.yard on check-in documents. These are separate flows and are not auto-synchronized.',
+			code_evidence: [
+				'angular/app/part/detail/part-detail.component.ts:67-73',
+				'angular/app/part/detail/part-detail.component.html:196',
+				'server/src/publications/checkouts.ts:8-10',
+				'angular/app/part/checkout/part-checkout.component.ts:275-282',
+				'angular/app/part/checkout/part-checkout.component.ts:413-427',
+				'server/src/models/checkin.model.ts:10-11',
+				'server/src/models/part.model.ts:13-14'
+			]
+		},
+		rejected_alternatives: [
+			{
+				hypothesis: 'Warehouse value is remapped during checkout publication read.',
+				why_rejected: 'checkoutsWithItemId returns raw checkout rows via Checkouts.find with no remap logic.',
+				evidence: ['server/src/publications/checkouts.ts:8-10']
+			},
+			{
+				hypothesis: 'Checkout form hardcodes Midland.',
+				why_rejected: 'Checkout warehouse text is set from selected id_warehouse_location yard lookup.',
+				evidence: ['angular/app/part/checkout/part-checkout.component.ts:413-427']
+			}
+		],
+		failing_path: {
+			reported: 'User entered inventory at Kermit and later saw Midland when pulling/viewing inventory history.',
+			verified: 'Part Detail checkout history subscribes to checkout records and renders checkout.warehouse_location; check-in yard is stored separately on check-in records.'
+		},
+		owner_files: [
+			'angular/app/part/detail/part-detail.component.ts',
+			'angular/app/part/detail/part-detail.component.html',
+			'server/src/publications/checkouts.ts',
+			'angular/app/part/checkout/part-checkout.component.ts',
+			'server/src/models/checkin.model.ts',
+			'server/src/models/part.model.ts'
+		],
+		proof_plan: [
+			{
+				step: 'Verify the Part Check-out History warehouse column source.',
+				proof_required: 'Confirm subscription source and template binding use checkout warehouse field.'
+			},
+			{
+				step: 'Verify checkout warehouse persistence source.',
+				proof_required: 'Confirm selected id_warehouse_location drives persisted warehouse_location.'
+			}
+		],
+		evidence: [
+			{
+				file: '.resolveio-support-context/manual-ticket.request.txt:1-4',
+				fact: 'Reporter states inventory entered at Kermit and later displayed as Midland.'
+			},
+			{
+				file: 'angular/app/part/detail/part-detail.component.ts:67-73',
+				fact: 'History source is publications.checkoutsWithItemId(this.id).'
+			},
+			{
+				file: 'angular/app/part/detail/part-detail.component.html:196',
+				fact: 'Warehouse column renders checkout.warehouse_location.'
+			},
+			{
+				file: 'server/src/publications/checkouts.ts:8-10',
+				fact: 'Publication returns raw checkout documents by item id.'
+			},
+			{
+				file: 'angular/app/part/checkout/part-checkout.component.ts:413-427',
+				fact: 'warehouse_location is synchronized from selected yard id.'
+			},
+			{
+				file: 'server/src/models/checkin.model.ts:10-11',
+				fact: 'Check-in model stores yard and id_yard.'
+			},
+			{
+				file: 'server/src/models/part.model.ts:13-14',
+				fact: 'Part model stores global quantity and quantity_string only.'
+			}
+		],
+		status: 'passed'
+	}
+}));
+assert.ok(dataVisibility4433Diagnosis);
+assert.equal(dataVisibility4433Diagnosis?.issue_class, 'missing_wrong_data');
+assert.equal(dataVisibility4433Diagnosis?.issue_case.reproduction_status, 'classified');
+assert.match(dataVisibility4433Diagnosis?.issue_case.customer_complaint || '', /Kermit/);
+assert.ok(dataVisibility4433Diagnosis?.accepted_hypothesis.evidence.some((entry) => /checkouts\.ts/.test(entry)));
+const dataVisibility4433Validation = validateResolveIOSupportDiagnosisGate(dataVisibility4433Diagnosis);
+assert.equal(dataVisibility4433Validation.valid, true, dataVisibility4433Validation.blockers.join(' | '));
+
+const behaviorInterpretation4433Diagnosis = extractResolveIOSupportDiagnosisGateFromText(JSON.stringify({
+	support_diagnosis_gate: {
+		status: 'passed',
+		issue_case: 'On /part/detail, the customer is comparing two different tables: June 1 Kermit appears in check-in history, while Midland appears in part check-out history.',
+		issue_class: 'general_inquiry',
+		accepted_hypothesis: {
+			summary: 'This is existing intended behavior, not a runtime failure: checkout rows show the warehouse used at checkout time, independent of prior check-in warehouse.',
+			rationale: 'The UI renders separate check-in and check-out sections, and the checkout table binds directly to checkout warehouse fields from checkout records. No permission/template guard hides or rewrites this field for this path.'
+		},
+		rejected_alternatives: [
+			{
+				hypothesis: 'Permission/role gate caused warehouse field mismatch between users.',
+				why_rejected: 'No role/helper gate wraps these history tables; only edit/delete buttons are wrapped with user-role checks.'
+			},
+			{
+				hypothesis: 'A report method overwrote warehouse to Midland on this detail screen.',
+				why_rejected: 'This screen is populated from publications, not reportPartInventory/reportDailyInventorySnapshot.'
+			},
+			{
+				hypothesis: 'Checkout query is incorrectly filtering to Midland.',
+				why_rejected: 'Publication query is items.id equals id_item, so all checkout warehouses for that part are expected.'
+			}
+		],
+		failing_path: {
+			type: 'behavior_interpretation',
+			route: '/part/detail/:id',
+			module_permission: 'Part module detail route; no table-level permission gate on the warehouse columns in these history sections.',
+			template_chain: 'part-detail template renders separate Other Part Check-in History and Part Check-out History blocks; checkout warehouse column is checkout.warehouse_location.',
+			helper_chain: 'No isUserX/isRoleY helper gates used for these table rows/columns.',
+			publication_chain: 'part-detail subscribes to checkinsWithItemId and checkoutsWithItemId; each publication returns records by item id from checkins/checkouts collections.'
+		},
+		owner_files: [
+			'/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/angular/app/part/detail/part-detail.component.html',
+			'/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/angular/app/part/detail/part-detail.component.ts',
+			'/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/server/src/publications/checkins.ts',
+			'/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/server/src/publications/checkouts.ts'
+		],
+		proof_plan: [
+			'Validate the screenshot table title/columns against part-detail template sections.',
+			'Trace part-detail subscriptions to confirm each table data source.',
+			'Trace publication queries to confirm checkout warehouse semantics.',
+			'Classify as General Inquiry (existing behavior) unless customer explicitly requests changed display logic.'
+		],
+		evidence: [
+			{
+				file: '/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/.resolveio-support-context/manual-ticket.request.txt',
+				detail: 'Reporter says 6 units entered in Kermit and later inventory pull showed Midland.'
+			},
+			{
+				file: '/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/.resolveio-support-context/attachments/Screenshot_2026-06-09_at_11.16.41_AM.png',
+				detail: 'Visible table is Part Check-out History showing Midland rows, while separate check-in context shows Kermit.'
+			},
+			{
+				file: '/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/angular/app/part/detail/part-detail.component.html',
+				detail: 'Separate UI blocks exist for check-ins and check-outs; checkout table prints checkout.warehouse_location.'
+			},
+			{
+				file: '/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/angular/app/part/detail/part-detail.component.ts',
+				detail: 'Component loads checkins via checkinsWithItemId and checkouts via checkoutsWithItemId.'
+			},
+			{
+				file: '/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/server/src/publications/checkouts.ts',
+				detail: 'checkoutsWithItemId returns Checkouts.find items.id equals id_item.'
+			},
+			{
+				file: '/var/app/resolveio-ai-workspace/6a35dfb2feca513d5ef50c00/resolveio-all/h2sko/server/src/publications/checkins.ts',
+				detail: 'checkinsWithItemId returns Checkins.find items.id equals id_item.'
+			}
+		]
+	}
+}));
+assert.ok(behaviorInterpretation4433Diagnosis);
+assert.equal(behaviorInterpretation4433Diagnosis?.issue_class, 'missing_wrong_data');
+assert.match(behaviorInterpretation4433Diagnosis?.issue_case.customer_complaint || '', /Kermit|Midland/);
+assert.ok(behaviorInterpretation4433Diagnosis?.owner_files.every((entry) => !/^var\/app\/resolveio-ai-workspace/.test(entry)));
+const behaviorInterpretation4433Validation = validateResolveIOSupportDiagnosisGate(behaviorInterpretation4433Diagnosis);
+assert.equal(behaviorInterpretation4433Validation.valid, true, behaviorInterpretation4433Validation.blockers.join(' | '));
+
+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 staleReproductionBundle = initializeResolveIOSupportV5State({
+	jobId: 'job-stale-repro',
+	ticketId: 'ticket-stale-repro',
+	ticketNumber: '004345',
+	title: 'Support ticket #004345',
+	description: 'Pricing upload imports rows but reports wrong verified count.',
+	approvedScopeRequirements: ['Replicate the upload issue with the attached pre-populated and blank templates'],
+	buildThreadKey: 'support:ticket-stale-repro:job:job-stale-repro:build',
+	qaThreadKey: 'support:ticket-stale-repro:job:job-stale-repro:qa',
+	now: '2026-06-06T00:00:31.000Z'
+});
+const staleBuildBeforeDiagnosis = staleReproductionBundle.supportV5MicrotaskLedger.find((task) => task.lane === 'build' && task.type === 'build_repair');
+assert.match(staleBuildBeforeDiagnosis?.objective || '', /Replicate the upload issue/i);
+const staleReproductionDiagnosed = recordResolveIOSupportV5Step(staleReproductionBundle, {
+	stepType: 'diagnosis_gate',
+	outcome: 'pass',
+	lane: 'build',
+	summary: diagnosisJson,
+	diagnosisGate: validDiagnosis,
+	now: '2026-06-06T00:00:32.000Z'
+});
+const staleBuildAfterDiagnosis = staleReproductionDiagnosed.supportV5MicrotaskLedger.find((task) => task.lane === 'build' && task.type === 'build_repair');
+assert.equal(staleBuildAfterDiagnosis?.status, 'pending');
+assert.equal(staleBuildAfterDiagnosis?.attempts, 0);
+assert.equal(staleBuildAfterDiagnosis?.blocker || '', '');
+assert.deepEqual(staleBuildAfterDiagnosis?.targetFiles, validDiagnosis.owner_files);
+assert.match(staleBuildAfterDiagnosis?.objective || '', /Patch the accepted root cause/i);
+assert.match(staleBuildAfterDiagnosis?.selfGate || '', /Do not re-run read-only reproduction as the repair/i);
+assert.match(staleBuildAfterDiagnosis?.acceptanceProof || '', /disabled driver is excluded|active driver remains selected/i);
+assert.equal(staleBuildAfterDiagnosis?.contextRefs.includes('accepted_hypothesis'), true);
+
+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 pricingDiagnosisWithProjectRootOwner = {
+	...validDiagnosis,
+	owner_files: ['server/src/methods/pricing.ts'],
+	failing_path: {
+		...validDiagnosis.failing_path,
+		backend: 'server/src/methods/pricing.ts'
+	},
+	evidence: [
+		...validDiagnosis.evidence,
+		{ type: 'code' as const, summary: 'Pricing import method owner file inspected.', ownerFiles: ['server/src/methods/pricing.ts'] }
+	]
+};
+assert.equal(changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles(pricingDiagnosisWithProjectRootOwner, [
+	'geochem/server/src/methods/pricing.ts'
+]).length, 0);
+assert.deepEqual(changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles(pricingDiagnosisWithProjectRootOwner, [
+	'geochem/server/src/methods/unrelated-pricing.ts'
+]), ['geochem/server/src/methods/unrelated-pricing.ts']);
+const pricingDiagnosisWithMixedProjectRootOwners = {
+	...validDiagnosis,
+	issue_case: {
+		...validDiagnosis.issue_case,
+		customer_complaint: 'Uploading production pricing workbooks leaves rows unimported or unclassified.',
+		expected_result: 'Every supported workbook row imports or receives an explicit duplicate/error classification.',
+		observed_result: 'Rows can be skipped without clear inserted/duplicate/error proof.',
+		route_module: 'Manage Pricing -> Sales -> Production import',
+		account_customer_context: 'Geo Chemicals ticket 004345',
+		reproduction_status: 'classified' as const
+	},
+	issue_class: 'missing_wrong_data' as const,
+	accepted_hypothesis: {
+		statement: 'Production pricing import skips attached workbook rows before insert.',
+		falsifiable_test: 'Upload both workbook variants and compare inserted or classified row count.',
+		evidence: [
+			'angular/app/widgets/pricing/sale/production/viewcustomer/pricing-sale-production-viewcustomer.component.ts builds the import payload.',
+			'server/src/methods/pricing.ts validates production pricing rows.'
+		]
+	},
+	failing_path: {
+		frontend: 'angular/app/widgets/pricing/sale/production/viewcustomer/pricing-sale-production-viewcustomer.component.ts',
+		backend: 'server/src/methods/pricing.ts',
+		description: 'Production pricing import upload path.'
+	},
+	owner_files: [
+		'angular/app/widgets/pricing/sale/production/viewcustomer/pricing-sale-production-viewcustomer.component.ts',
+		'server/src/methods/pricing.ts'
+	],
+	proof_plan: {
+		...validDiagnosis.proof_plan,
+		business_assertion: 'Uploaded workbook rows are inserted or explicitly classified.',
+		business_proof_contract: {
+			...validDiagnosis.proof_plan.business_proof_contract,
+			issue_class: 'missing_wrong_data' as const,
+			expected_business_state_change: 'Every uploaded pricing row is inserted, updated, unchanged, or rejected with an explicit reason.',
+			data_or_dom_assertion: 'Inserted plus classified rows equals uploaded candidate row count.'
+		}
+	},
+	evidence: [
+		{ type: 'code' as const, summary: 'Angular pricing import component is the frontend owner.', artifactPath: 'angular/app/widgets/pricing/sale/production/viewcustomer/pricing-sale-production-viewcustomer.component.ts', ownerFiles: ['angular/app/widgets/pricing/sale/production/viewcustomer/pricing-sale-production-viewcustomer.component.ts'] },
+		{ type: 'code' as const, summary: 'Pricing import method is the backend owner.', artifactPath: 'server/src/methods/pricing.ts', ownerFiles: ['server/src/methods/pricing.ts'] }
+	]
+};
+const mixedProjectRootOwnerValidation = validateResolveIOSupportDiagnosisGate(pricingDiagnosisWithMixedProjectRootOwners);
+assert.equal(mixedProjectRootOwnerValidation.valid, true, mixedProjectRootOwnerValidation.blockers.join(' | '));
+assert.deepEqual(changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles(pricingDiagnosisWithMixedProjectRootOwners, [
+	'geochem/angular/app/widgets/pricing/sale/production/viewcustomer/pricing-sale-production-viewcustomer.component.ts',
+	'geochem/server/src/methods/pricing.ts',
+	'resolveio-all/geochem/angular/app/widgets/pricing/sale/production/viewcustomer/pricing-sale-production-viewcustomer.component.ts',
+	'/var/app/resolveio-ai-workspace/run-1/resolveio-all/geochem/server/src/methods/pricing.ts'
+]), []);
+assert.deepEqual(changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles(pricingDiagnosisWithMixedProjectRootOwners, [
+	'geochem/angular/app/widgets/pricing/sale/production/viewcustomer/pricing-sale-production-viewcustomer.component.ts',
+	'geochem/angular/app/widgets/pricing/sale/production/viewcustomer/unrelated.component.ts'
+]), ['geochem/angular/app/widgets/pricing/sale/production/viewcustomer/unrelated.component.ts']);
+
+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.equal(ownerScopedAutonomousDecision.rootCauseReadiness.ownerScopedRepairContractReady, true);
+assert.equal(ownerScopedAutonomousDecision.repairGate.ownerScopedRepairContract.status, 'ready');
+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.equal(ownerScopedAutonomousDecision.nextActionContract.decisionBasis.ownerScopedRepairContractReady, true);
+assert.equal(ownerScopedAutonomousDecision.nextActionContract.decisionBasis.ownerScopedRepairContractId, ownerScopedAutonomousDecision.repairGate.ownerScopedRepairContract.contractId);
+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);
+assert.equal(ownerScopedAutonomousDecision.managerExecutionPacket.proofResetContract.retryScope, 'owner_files_only');
+assert.equal(ownerScopedAutonomousDecision.managerExecutionPacket.proofResetContract.maxAttemptsBeforeFreshEvidence, 1);
+assert.ok(ownerScopedAutonomousDecision.managerExecutionPacket.proofResetContract.requiredResetEvidence.length > 0);
+
+const ownerScopedAutoRetryDecision = decideResolveIOSupportV5AutonomousNextAction({
+	bundle: diagnosedBundle,
+	changedFiles: ['geochem/angular/app/bol/new/bol-new.component.ts'],
+	autonomyPolicy: {
+		mode: 'auto_retry_within_budget',
+		currentSpendUsd: 2,
+		budgetHardUsd: 10,
+		expectedValueScore: 0.4,
+		evidenceStrength: 'material',
+		materialEvidence: true
+	}
+});
+assert.equal(ownerScopedAutoRetryDecision.action, 'run_owner_scoped_repair');
+assert.equal(ownerScopedAutoRetryDecision.autonomyPolicy?.mode, 'auto_retry_within_budget');
+assert.equal(ownerScopedAutoRetryDecision.autonomyPolicy?.canAutoDispatch, true);
+assert.equal(ownerScopedAutoRetryDecision.nextActionContract.safeToAutoRun, true);
+assert.equal(ownerScopedAutoRetryDecision.nextActionContract.decisionBasis.autonomyCanAutoDispatch, true);
+assert.equal(ownerScopedAutoRetryDecision.nextActionContract.decisionBasis.autonomyExpectedValuePositive, true);
+assert.equal(ownerScopedAutoRetryDecision.managerExecutionPacket.status, 'auto_ready');
+
+const approvedUnderSixAutopilotDecision = decideResolveIOSupportV5AutonomousNextAction({
+	bundle: diagnosedBundle,
+	changedFiles: ['geochem/angular/app/bol/new/bol-new.component.ts'],
+	requireAutonomyApprovalForProductRepair: true,
+	autonomyApproval: {
+		contract_id: 'support-autonomy-under-six-approved',
+		status: 'approved_autopilot',
+		approved: true,
+		approved_at: '2026-06-06T00:02:30.000Z',
+		approved_by: 'operator',
+		estimated_hours: 2,
+		max_auto_hours_without_approval: 6,
+		bug_not_bug: 'bug',
+		bug_not_bug_classification_approved: true,
+		after_approval_autopilot_until_a_grade: true,
+		target_grade: 'A',
+		qa_screenshots_required: true,
+		before_action_after_business_proof_required: true,
+		aiqa_business_assertion_required: true,
+		owner_files: validDiagnosis.owner_files,
+		approved_owner_files: validDiagnosis.owner_files,
+		required_completion_evidence: [
+			'A-grade execution/artifacts/pull_request review',
+			'QA screenshots with captions',
+			'AIQaBusinessAssertion before/action/after business proof',
+			'changed files subset of approved owner_files'
+		]
+	}
+});
+assert.equal(approvedUnderSixAutopilotDecision.action, 'run_owner_scoped_repair');
+assert.equal(approvedUnderSixAutopilotDecision.autonomyApproval?.autopilotApprovalBoundaryValid, true);
+assert.equal(approvedUnderSixAutopilotDecision.autonomyApproval?.estimatedHours, 2);
+assert.equal(approvedUnderSixAutopilotDecision.productRepairDispatchGuard?.status, 'allowed');
+assert.equal(approvedUnderSixAutopilotDecision.productRepairDispatchGuard?.autoContinueAfterApproval, true);
+assert.equal(approvedUnderSixAutopilotDecision.productRepairDispatchGuard?.terminalTarget, 'A-grade PR with QA screenshots, AIQaBusinessAssertion before/action/after proof, source commit proof, and changed files inside owner_files');
+assert.equal(approvedUnderSixAutopilotDecision.nextActionContract.safeToAutoRun, true);
+assert.equal(approvedUnderSixAutopilotDecision.nextActionContract.canRunWithoutCodexMonitor, true);
+assert.equal(approvedUnderSixAutopilotDecision.nextActionContract.decisionBasis.autonomyApprovalApproved, true);
+assert.equal(approvedUnderSixAutopilotDecision.nextActionContract.decisionBasis.approvedScopeHours, 2);
+assert.equal(approvedUnderSixAutopilotDecision.nextActionContract.decisionBasis.afterApprovalAutopilotUntilAGrade, true);
+assert.equal(approvedUnderSixAutopilotDecision.nextActionContract.decisionBasis.leSixHourScopeCanAutofixAfterApproval, true);
+assert.equal(approvedUnderSixAutopilotDecision.nextActionContract.decisionBasis.ownerFilesChangedSinceApproval, false);
+assert.equal(approvedUnderSixAutopilotDecision.productRepairDispatchGuard?.ownerFilesChangedSinceApproval, false);
+assert.equal(approvedUnderSixAutopilotDecision.managerExecutionPacket.status, 'auto_ready');
+
+const approvedScopeOwnerFileDriftDecision = decideResolveIOSupportV5AutonomousNextAction({
+	bundle: diagnosedBundle,
+	changedFiles: ['geochem/angular/app/bol/new/bol-new.component.ts'],
+	requireAutonomyApprovalForProductRepair: true,
+	autonomyApproval: {
+		contract_id: 'support-autonomy-owner-file-drift',
+		status: 'approved_autopilot',
+		approved: true,
+		approved_at: '2026-06-06T00:02:35.000Z',
+		approved_by: 'operator',
+		estimated_hours: 2,
+		max_auto_hours_without_approval: 6,
+		bug_not_bug: 'bug',
+		bug_not_bug_classification_approved: true,
+		after_approval_autopilot_until_a_grade: true,
+		target_grade: 'A',
+		owner_files: [...validDiagnosis.owner_files, 'geochem/server/src/methods/unapproved-scope.ts'],
+		approved_owner_files: validDiagnosis.owner_files,
+		current_owner_files: [...validDiagnosis.owner_files, 'geochem/server/src/methods/unapproved-scope.ts'],
+		required_completion_evidence: [
+			'A-grade execution/artifacts/pull_request review',
+			'QA screenshots with captions',
+			'AIQaBusinessAssertion before/action/after business proof',
+			'changed files subset of approved owner_files'
+		]
+	}
+});
+assert.equal(approvedScopeOwnerFileDriftDecision.autonomyApproval?.autopilotApprovalBoundaryValid, false);
+assert.equal(approvedScopeOwnerFileDriftDecision.autonomyApproval?.ownerFilesChangedSinceApproval, true);
+assert.deepEqual(approvedScopeOwnerFileDriftDecision.autonomyApproval?.ownerFilesAddedSinceApproval, ['geochem/server/src/methods/unapproved-scope.ts']);
+assert.equal(approvedScopeOwnerFileDriftDecision.productRepairDispatchGuard?.status, 'blocked');
+assert.equal(approvedScopeOwnerFileDriftDecision.productRepairDispatchGuard?.requiresOwnerFileReapproval, true);
+assert.equal(approvedScopeOwnerFileDriftDecision.productRepairDispatchGuard?.ownerFilesChangedSinceApproval, true);
+assert.deepEqual(approvedScopeOwnerFileDriftDecision.productRepairDispatchGuard?.ownerFilesAddedSinceApproval, ['geochem/server/src/methods/unapproved-scope.ts']);
+assert.equal(approvedScopeOwnerFileDriftDecision.nextActionContract.safeToAutoRun, false);
+assert.equal(approvedScopeOwnerFileDriftDecision.nextActionContract.requiresHumanApproval, true);
+assert.equal(approvedScopeOwnerFileDriftDecision.nextActionContract.decisionBasis.ownerFilesChangedSinceApproval, true);
+assert.equal(approvedScopeOwnerFileDriftDecision.nextActionContract.decisionBasis.requiresOperatorApprovalForAnyScopeChange, true);
+assert.equal(approvedScopeOwnerFileDriftDecision.managerExecutionPacket.status, 'manual_required');
+
+const approvedScopeFingerprintDriftDecision = decideResolveIOSupportV5AutonomousNextAction({
+	bundle: diagnosedBundle,
+	changedFiles: ['geochem/angular/app/bol/new/bol-new.component.ts'],
+	requireAutonomyApprovalForProductRepair: true,
+	autonomyApproval: {
+		contract_id: 'support-autonomy-scope-fingerprint-drift',
+		status: 'approved_autopilot',
+		approved: true,
+		approved_at: '2026-06-06T00:02:37.000Z',
+		approved_by: 'operator',
+		estimated_hours: 2,
+		max_auto_hours_without_approval: 6,
+		bug_not_bug: 'bug',
+		bug_not_bug_classification_approved: true,
+		after_approval_autopilot_until_a_grade: true,
+		target_grade: 'A',
+		owner_files: validDiagnosis.owner_files,
+		approved_owner_files: validDiagnosis.owner_files,
+		scope_fingerprint: 'current-scope-fingerprint',
+		previous_scope_fingerprint: 'approved-scope-fingerprint'
+	}
+});
+assert.equal(approvedScopeFingerprintDriftDecision.autonomyApproval?.autopilotApprovalBoundaryValid, true);
+assert.equal(approvedScopeFingerprintDriftDecision.autonomyApproval?.scopeChangedSinceApproval, false);
+assert.equal(approvedScopeFingerprintDriftDecision.productRepairDispatchGuard?.status, 'allowed');
+assert.equal(approvedScopeFingerprintDriftDecision.productRepairDispatchGuard?.requiresScopeReapproval, false);
+assert.equal(approvedScopeFingerprintDriftDecision.nextActionContract.safeToAutoRun, true);
+assert.equal(approvedScopeFingerprintDriftDecision.nextActionContract.requiresHumanApproval, false);
+assert.equal(approvedScopeFingerprintDriftDecision.nextActionContract.decisionBasis.scopeChangedSinceApproval, false);
+assert.notEqual(approvedScopeFingerprintDriftDecision.managerExecutionPacket.status, 'manual_required');
+
+const approvedDiagnosisFingerprintDriftDecision = decideResolveIOSupportV5AutonomousNextAction({
+	bundle: diagnosedBundle,
+	changedFiles: ['geochem/angular/app/bol/new/bol-new.component.ts'],
+	requireAutonomyApprovalForProductRepair: true,
+	autonomyApproval: {
+		contract_id: 'support-autonomy-diagnosis-fingerprint-drift',
+		status: 'approved_autopilot',
+		approved: true,
+		approved_at: '2026-06-06T00:02:38.000Z',
+		approved_by: 'operator',
+		estimated_hours: 2,
+		max_auto_hours_without_approval: 6,
+		bug_not_bug: 'bug',
+		bug_not_bug_classification_approved: true,
+		after_approval_autopilot_until_a_grade: true,
+		target_grade: 'A',
+		owner_files: validDiagnosis.owner_files,
+		approved_owner_files: validDiagnosis.owner_files,
+		diagnosis_scope_included: true,
+		diagnosis_scope_valid: true,
+		diagnosis_scope_fingerprint: 'current-diagnosis-proof-plan',
+		previous_diagnosis_scope_fingerprint: 'approved-diagnosis-proof-plan',
+		diagnosis_scope_fields: ['issue_case', 'accepted_hypothesis', 'failing_path', 'proof_plan']
+	}
+});
+assert.equal(approvedDiagnosisFingerprintDriftDecision.autonomyApproval?.autopilotApprovalBoundaryValid, false);
+assert.equal(approvedDiagnosisFingerprintDriftDecision.autonomyApproval?.diagnosisScopeChangedSinceApproval, true);
+assert.equal(approvedDiagnosisFingerprintDriftDecision.autonomyApproval?.diagnosisScopeIncluded, true);
+assert.equal(approvedDiagnosisFingerprintDriftDecision.productRepairDispatchGuard?.status, 'blocked');
+assert.equal(approvedDiagnosisFingerprintDriftDecision.productRepairDispatchGuard?.requiresDiagnosisScopeReapproval, true);
+assert.equal(approvedDiagnosisFingerprintDriftDecision.nextActionContract.safeToAutoRun, false);
+assert.equal(approvedDiagnosisFingerprintDriftDecision.nextActionContract.requiresHumanApproval, true);
+assert.equal(approvedDiagnosisFingerprintDriftDecision.nextActionContract.decisionBasis.diagnosisScopeChangedSinceApproval, true);
+assert.equal(approvedDiagnosisFingerprintDriftDecision.managerExecutionPacket.status, 'manual_required');
+
+const overSixWithoutExplicitApprovalDecision = decideResolveIOSupportV5AutonomousNextAction({
+	bundle: diagnosedBundle,
+	changedFiles: ['geochem/angular/app/bol/new/bol-new.component.ts'],
+	requireAutonomyApprovalForProductRepair: true,
+	autonomyApproval: {
+		contract_id: 'support-autonomy-over-six-without-explicit',
+		status: 'approved_autopilot',
+		approved: true,
+		approved_at: '2026-06-06T00:02:40.000Z',
+		approved_by: 'operator',
+		estimated_hours: 7,
+		max_auto_hours_without_approval: 6,
+		over_max_auto_hours: true,
+		bug_not_bug: 'bug',
+		bug_not_bug_classification_approved: true,
+		after_approval_autopilot_until_a_grade: true,
+		target_grade: 'A',
+		owner_files: validDiagnosis.owner_files,
+		approved_owner_files: validDiagnosis.owner_files
+	}
+});
+assert.equal(overSixWithoutExplicitApprovalDecision.action, 'run_owner_scoped_repair');
+assert.equal(overSixWithoutExplicitApprovalDecision.autonomyApproval?.autopilotApprovalBoundaryValid, false);
+assert.equal(overSixWithoutExplicitApprovalDecision.autonomyApproval?.requiresOverLimitApproval, true);
+assert.equal(overSixWithoutExplicitApprovalDecision.autonomyApproval?.explicitOverLimitApproval, false);
+assert.equal(overSixWithoutExplicitApprovalDecision.productRepairDispatchGuard?.status, 'blocked');
+assert.equal(overSixWithoutExplicitApprovalDecision.productRepairDispatchGuard?.nextAction, 'approve_support_autonomy_over_limit');
+assert.equal(overSixWithoutExplicitApprovalDecision.nextActionContract.safeToAutoRun, false);
+assert.equal(overSixWithoutExplicitApprovalDecision.nextActionContract.requiresHumanApproval, true);
+assert.equal(overSixWithoutExplicitApprovalDecision.nextActionContract.decisionBasis.overMaxAutoHours, true);
+assert.equal(overSixWithoutExplicitApprovalDecision.nextActionContract.decisionBasis.maxAutoHoursWithoutApproval, 6);
+assert.equal(overSixWithoutExplicitApprovalDecision.managerExecutionPacket.status, 'manual_required');
+assert.equal(overSixWithoutExplicitApprovalDecision.humanDecisionRequest?.preferredChoiceId, 'approve_over_limit_autonomy');
+assert.ok(overSixWithoutExplicitApprovalDecision.humanDecisionRequest?.choices.some((choice) => choice.choiceId === 'approve_over_limit_autonomy' && choice.action === 'approve_support_autonomy_over_limit'));
+assert.ok(overSixWithoutExplicitApprovalDecision.nextActionContract.stopConditions.some((entry) => /over 6 hours/i.test(entry)));
+
+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.equal(outOfScopeAutonomousDecision.rootCauseReadiness.rootCauseFirstSatisfied, true);
+assert.equal(outOfScopeAutonomousDecision.rootCauseReadiness.ownerScopedRepairContractReady, false);
+assert.equal(outOfScopeAutonomousDecision.rootCauseReadiness.canEditProductCode, false);
+assert.equal(outOfScopeAutonomousDecision.nextActionContract.decisionBasis.ownerScopedRepairContractReady, false);
+assert.equal(outOfScopeAutonomousDecision.nextActionContract.decisionBasis.ownerScopedRepairContractId, outOfScopeAutonomousDecision.repairGate.ownerScopedRepairContract.contractId);
+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 and resolveio_support_ticket_codex_manager 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 approvedAutopilotContract = {
+	contract_id: 'support-autonomy-proof-ready-approved',
+	status: 'approved_autopilot',
+	approved: true,
+	approved_at: '2026-06-06T00:03:00.000Z',
+	approved_by: 'operator',
+	estimated_hours: 2,
+	max_auto_hours_without_approval: 6,
+	bug_not_bug: 'bug',
+	bug_not_bug_classification_approved: true,
+	after_approval_autopilot_until_a_grade: true,
+	target_grade: 'A',
+	qa_screenshots_required: true,
+	before_action_after_business_proof_required: true,
+	aiqa_business_assertion_required: true,
+	owner_files: validDiagnosis.owner_files,
+	approved_owner_files: validDiagnosis.owner_files,
+	required_completion_evidence: [
+		'A-grade execution/artifacts/pull_request review',
+		'QA screenshots with captions',
+		'AIQaBusinessAssertion before/action/after business proof',
+		'changed files subset of approved owner_files',
+		'pull_request_url'
+	]
+};
+const approvedAutopilotBusinessAssertions = [{
+	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-before-after-proof.png'],
+	metadata: { supportDiagnosisProof: true }
+}];
+const approvedAutopilotCreatePrDecision = decideResolveIOSupportV5AutonomousNextAction({
+	bundle: completedDiagnosedBundle,
+	changedFiles: validDiagnosis.owner_files,
+	businessAssertionStatus: 'pass',
+	businessAssertions: approvedAutopilotBusinessAssertions,
+	businessProofArtifacts: ['qa-artifacts/disabled-driver-before-after-proof.png'],
+	autonomyApproval: approvedAutopilotContract,
+	prReadinessContract: {
+		contract_id: 'support-pr-readiness-proof-ready-no-pr',
+		status: 'ready',
+		ready: true,
+		business_proof_ready: true,
+		diagnosis_valid: true,
+		passed_business_assertion_count: 1,
+		business_proof_artifacts: ['qa-artifacts/disabled-driver-before-after-proof.png'],
+		modified_files: validDiagnosis.owner_files,
+		pull_request_url: '',
+		merge_blocked_until_human_approval: true,
+		customer_reply_blocked_until_release_gate: true,
+		release_blocked_until_pr_review: true
+	}
+});
+assert.equal(approvedAutopilotCreatePrDecision.action, 'create_pr');
+assert.equal(approvedAutopilotCreatePrDecision.primaryCommand, 'createSupportTicketCodexPullRequestManual');
+assert.equal(approvedAutopilotCreatePrDecision.autopilotCompletionProgress?.activePhase, 'pr_packaging');
+assert.equal(approvedAutopilotCreatePrDecision.autopilotCompletionProgress?.status, 'ready_for_pr');
+assert.equal(approvedAutopilotCreatePrDecision.autopilotCompletionProgress?.nextAction, 'create_pr');
+assert.equal(approvedAutopilotCreatePrDecision.nextActionContract.decisionBasis.autopilotCompletionPhase, 'pr_packaging');
+assert.equal(approvedAutopilotCreatePrDecision.nextActionContract.decisionBasis.autopilotCompletionNextAction, 'create_pr');
+assert.equal(approvedAutopilotCreatePrDecision.managerExecutionPacket.retryScope, 'pr_packaging_only');
+assert.equal(approvedAutopilotCreatePrDecision.managerExecutionPacket.status, 'auto_ready');
+assert.ok(approvedAutopilotCreatePrDecision.forbiddenActions.some((entry) => /merge|release|deploy|customer/i.test(entry)));
+
+const approvedAutopilotPrReviewDecision = decideResolveIOSupportV5AutonomousNextAction({
+	bundle: completedDiagnosedBundle,
+	changedFiles: validDiagnosis.owner_files,
+	businessAssertionStatus: 'pass',
+	businessAssertions: approvedAutopilotBusinessAssertions,
+	businessProofArtifacts: ['qa-artifacts/disabled-driver-before-after-proof.png'],
+	autonomyApproval: approvedAutopilotContract,
+	prReadinessContract: {
+		contract_id: 'support-pr-readiness-proof-ready-with-pr',
+		status: 'ready',
+		ready: true,
+		business_proof_ready: true,
+		diagnosis_valid: true,
+		passed_business_assertion_count: 1,
+		business_proof_artifacts: ['qa-artifacts/disabled-driver-before-after-proof.png'],
+		modified_files: validDiagnosis.owner_files,
+		pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4999',
+		pull_request_status: 'OPEN',
+		merge_blocked_until_human_approval: true,
+		customer_reply_blocked_until_release_gate: true,
+		release_blocked_until_pr_review: true
+	}
+});
+assert.equal(approvedAutopilotPrReviewDecision.action, 'run_a_grade_pr_review');
+assert.equal(approvedAutopilotPrReviewDecision.primaryCommand, 'run_support_a_grade_pr_review');
+assert.equal(approvedAutopilotPrReviewDecision.autopilotCompletionProgress?.activePhase, 'pr_review');
+assert.equal(approvedAutopilotPrReviewDecision.autopilotCompletionProgress?.status, 'in_progress');
+assert.equal(approvedAutopilotPrReviewDecision.autopilotCompletionProgress?.pullRequestUrl, 'https://github.com/resolveio/resolveio-all/pull/4999');
+assert.equal(approvedAutopilotPrReviewDecision.autopilotCompletionProgress?.prReviewReady, false);
+assert.equal(approvedAutopilotPrReviewDecision.nextActionContract.decisionBasis.autopilotCompletionReady, false);
+assert.equal(approvedAutopilotPrReviewDecision.managerExecutionPacket.retryScope, 'pr_review_only');
+assert.equal(approvedAutopilotPrReviewDecision.managerExecutionPacket.status, 'auto_ready');
+
+const approvedAutopilotPrBusinessProofReviewDecision = decideResolveIOSupportV5AutonomousNextAction({
+	bundle: completedDiagnosedBundle,
+	changedFiles: validDiagnosis.owner_files,
+	businessAssertionStatus: 'pass',
+	businessAssertions: approvedAutopilotBusinessAssertions,
+	businessProofArtifacts: ['qa-artifacts/disabled-driver-before-after-proof.png'],
+	autonomyApproval: approvedAutopilotContract,
+	prReadinessContract: {
+		contract_id: 'support-pr-readiness-proof-ready-with-pr',
+		status: 'ready',
+		ready: true,
+		business_proof_ready: true,
+		diagnosis_valid: true,
+		passed_business_assertion_count: 1,
+		business_proof_artifacts: ['qa-artifacts/disabled-driver-before-after-proof.png'],
+		modified_files: validDiagnosis.owner_files,
+		pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4999',
+		pull_request_status: 'OPEN',
+		merge_blocked_until_human_approval: true,
+		customer_reply_blocked_until_release_gate: true,
+		release_blocked_until_pr_review: true
+	},
+	prReviewContract: {
+		contract_id: 'support-pr-review-needs-business-proof',
+		status: 'blocked',
+		ready: false,
+		strict_gate_passed: false,
+		strict_gate_reason: 'missing_before_action_after_business_proof',
+		failure_class: 'business_proof',
+		blocker_fingerprint: 'bf-business-proof',
+		evidence_hash: 'ev-business-proof',
+		next_action: 'run_business_proof_qa',
+		blockers: ['Strict gate failed: missing before/action/after business proof.'],
+		continuation_contract: {
+			action: 'run_business_proof_qa',
+			failure_class: 'business_proof',
+			blocker_fingerprint: 'bf-business-proof',
+			evidence_hash: 'ev-business-proof'
+		}
+	}
+});
+assert.equal(approvedAutopilotPrBusinessProofReviewDecision.action, 'run_business_proof_qa');
+assert.equal(approvedAutopilotPrBusinessProofReviewDecision.managerExecutionPacket.retryScope, 'business_proof_only');
+assert.equal(approvedAutopilotPrBusinessProofReviewDecision.managerExecutionPacket.proofResetContract.startingFailureClass, 'business_proof');
+assert.equal(approvedAutopilotPrBusinessProofReviewDecision.managerExecutionPacket.proofResetContract.startingBlockerFingerprint, 'bf-business-proof');
+assert.equal(approvedAutopilotPrBusinessProofReviewDecision.managerExecutionPacket.proofResetContract.startingEvidenceHash, 'ev-business-proof');
+assert.ok(approvedAutopilotPrBusinessProofReviewDecision.managerExecutionPacket.proofResetContract.requiredResetEvidence.some((entry) => /changed evidence_hash|AIQaBusinessAssertion|fresh artifact/i.test(entry)));
+assert.ok(approvedAutopilotPrBusinessProofReviewDecision.blockers.some((entry) => /blocker_fingerprint:bf-business-proof/.test(entry)));
+
+const approvedAutopilotPrOwnerRepairReviewDecision = decideResolveIOSupportV5AutonomousNextAction({
+	bundle: completedDiagnosedBundle,
+	changedFiles: validDiagnosis.owner_files,
+	businessAssertionStatus: 'pass',
+	businessAssertions: approvedAutopilotBusinessAssertions,
+	businessProofArtifacts: ['qa-artifacts/disabled-driver-before-after-proof.png'],
+	autonomyApproval: approvedAutopilotContract,
+	prReadinessContract: {
+		contract_id: 'support-pr-readiness-proof-ready-with-pr',
+		status: 'ready',
+		ready: true,
+		business_proof_ready: true,
+		diagnosis_valid: true,
+		passed_business_assertion_count: 1,
+		business_proof_artifacts: ['qa-artifacts/disabled-driver-before-after-proof.png'],
+		modified_files: validDiagnosis.owner_files,
+		pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4999',
+		pull_request_status: 'OPEN',
+		merge_blocked_until_human_approval: true,
+		customer_reply_blocked_until_release_gate: true,
+		release_blocked_until_pr_review: true
+	},
+	prReviewContract: {
+		contract_id: 'support-pr-review-needs-owner-repair',
+		status: 'blocked',
+		ready: false,
+		strict_gate_passed: false,
+		strict_gate_reason: 'grade_below_target',
+		failure_class: 'grade_below_target',
+		blocker_fingerprint: 'bf-owner-repair',
+		evidence_hash: 'ev-owner-repair',
+		next_action: 'run_owner_scoped_repair',
+		blockers: ['Grades are below A threshold.'],
+		continuation_contract: {
+			action: 'run_owner_scoped_repair',
+			failure_class: 'grade_below_target',
+			blocker_fingerprint: 'bf-owner-repair',
+			evidence_hash: 'ev-owner-repair'
+		}
+	}
+});
+assert.equal(approvedAutopilotPrOwnerRepairReviewDecision.action, 'run_owner_scoped_repair');
+assert.equal(approvedAutopilotPrOwnerRepairReviewDecision.managerExecutionPacket.retryScope, 'owner_files_only');
+assert.equal(approvedAutopilotPrOwnerRepairReviewDecision.managerExecutionPacket.proofResetContract.startingFailureClass, 'grade_below_target');
+assert.equal(approvedAutopilotPrOwnerRepairReviewDecision.managerExecutionPacket.proofResetContract.startingBlockerFingerprint, 'bf-owner-repair');
+assert.equal(approvedAutopilotPrOwnerRepairReviewDecision.managerExecutionPacket.proofResetContract.startingEvidenceHash, 'ev-owner-repair');
+assert.ok(approvedAutopilotPrOwnerRepairReviewDecision.blockers.some((entry) => /blocker_fingerprint:bf-owner-repair/.test(entry)));
+
+const approvedAutopilotAgradePrDecision = decideResolveIOSupportV5AutonomousNextAction({
+	bundle: completedDiagnosedBundle,
+	changedFiles: validDiagnosis.owner_files,
+	businessAssertionStatus: 'pass',
+	businessAssertions: approvedAutopilotBusinessAssertions,
+	businessProofArtifacts: ['qa-artifacts/disabled-driver-before-after-proof.png'],
+	autonomyApproval: approvedAutopilotContract,
+	prReadinessContract: {
+		contract_id: 'support-pr-readiness-proof-ready-with-pr',
+		status: 'ready',
+		ready: true,
+		business_proof_ready: true,
+		diagnosis_valid: true,
+		passed_business_assertion_count: 1,
+		business_proof_artifacts: ['qa-artifacts/disabled-driver-before-after-proof.png'],
+		modified_files: validDiagnosis.owner_files,
+		pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4999',
+		pull_request_status: 'OPEN',
+		merge_blocked_until_human_approval: true,
+		customer_reply_blocked_until_release_gate: true,
+		release_blocked_until_pr_review: true
+	},
+	prReviewContract: {
+		contract_id: 'support-pr-review-a-grade',
+		status: 'passed',
+		ready: true,
+		strict_gate_passed: true,
+		execution_grade: 'A',
+		artifacts_grade: 'A',
+		pull_request_grade: 'A',
+		pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4999',
+		evidence_refs: ['qa-artifacts/disabled-driver-before-after-proof.png']
+	}
+});
+assert.equal(approvedAutopilotAgradePrDecision.action, 'park_manual');
+assert.equal(approvedAutopilotAgradePrDecision.primaryCommand, 'review_a_grade_pr_and_release_gate');
+assert.equal(approvedAutopilotAgradePrDecision.autopilotCompletionProgress?.activePhase, 'park_before_merge_release_customer');
+assert.equal(approvedAutopilotAgradePrDecision.autopilotCompletionProgress?.status, 'complete');
+assert.equal(approvedAutopilotAgradePrDecision.autopilotCompletionProgress?.prReviewReady, true);
+assert.equal(approvedAutopilotAgradePrDecision.nextActionContract.decisionBasis.autopilotCompletionReady, true);
+assert.equal(approvedAutopilotAgradePrDecision.managerExecutionPacket.status, 'manual_required');
+
+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 and resolveio_support_ticket_codex_manager 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 staleEvidenceProbeContract = buildResolveIOSupportEvidenceProbeContract({
+	diagnosisGate: validDiagnosis,
+	issueClassProbePlan: validProbePlan,
+	evidenceFreshness: staleEvidenceFreshness,
+	requiredEvidence: staleEvidenceFreshness.requiredResetEvidence,
+	now: '2026-06-06T00:00:40.000Z'
+});
+assert.equal(staleEvidenceProbeContract.status, 'ready');
+assert.equal(staleEvidenceProbeContract.evidenceOnly, true);
+assert.equal(staleEvidenceProbeContract.productRepairAllowed, false);
+assert.equal(staleEvidenceProbeContract.canRunWithoutCodexMonitor, true);
+assert.equal(staleEvidenceProbeContract.probeType, 'issue_class_probe');
+assert.equal(staleEvidenceProbeContract.issueClass, validDiagnosis.issue_class);
+assert.equal(staleEvidenceProbeContract.activeRoute, validDiagnosis.proof_plan.route);
+assert.equal(staleEvidenceProbeContract.startingEvidenceHash, 'same');
+assert.equal(staleEvidenceProbeContract.sameFailureCount, 2);
+assert.ok(staleEvidenceProbeContract.requiredNewSignals.some((signal) => /changed evidenceHash/i.test(signal)));
+assert.ok(staleEvidenceProbeContract.requiredArtifacts.some((artifact) => /AIQaBusinessAssertion|dropdown DOM snapshot/i.test(artifact)));
+assert.ok(staleEvidenceProbeContract.acceptableEvidence.some((entry) => /AIQaBusinessAssertion|before\/action\/after|DOM|Mongo|data/i.test(entry)));
+assert.ok(staleEvidenceProbeContract.forbiddenActions.some((entry) => /product-code|repair loop/i.test(entry)));
+assert.equal(validateResolveIOSupportEvidenceProbeContract(staleEvidenceProbeContract).valid, true);
+
+const malformedEvidenceProbeContract = validateResolveIOSupportEvidenceProbeContract({
+	...staleEvidenceProbeContract,
+	requiredNewSignals: [],
+	requiredArtifacts: [],
+	forbiddenActions: []
+});
+assert.equal(malformedEvidenceProbeContract.valid, false);
+assert.ok(malformedEvidenceProbeContract.blockers.some((blocker) => /new signal|artifact|forbid product-code/i.test(blocker)));
+
+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.nextActionContract.decisionBasis.evidenceProbeContractReady, true);
+assert.equal(repeatedAutonomousDecision.nextActionContract.decisionBasis.evidenceProbeContractId, repeatedAutonomousDecision.evidenceProbeContract?.contractId);
+assert.equal(repeatedAutonomousDecision.evidenceProbeContract?.status, 'ready');
+assert.equal(repeatedAutonomousDecision.evidenceProbeContract?.productRepairAllowed, false);
+assert.ok(repeatedAutonomousDecision.evidenceProbeContract?.nextCommands.includes('execute_active_issue_class_probe_evidence_only'));
+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 monitorOnlyRepeatedDecision = 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',
+	autonomyPolicy: {
+		mode: 'monitor_only',
+		currentSpendUsd: 2,
+		budgetHardUsd: 10
+	}
+});
+assert.equal(monitorOnlyRepeatedDecision.action, 'collect_new_evidence');
+assert.equal(monitorOnlyRepeatedDecision.autonomyPolicy?.mode, 'monitor_only');
+assert.equal(monitorOnlyRepeatedDecision.autonomyPolicy?.canAutoDispatch, false);
+assert.equal(monitorOnlyRepeatedDecision.nextActionContract.safeToAutoRun, false);
+assert.equal(monitorOnlyRepeatedDecision.nextActionContract.canRunWithoutCodexMonitor, false);
+assert.equal(monitorOnlyRepeatedDecision.nextActionContract.requiresHumanApproval, true);
+assert.equal(monitorOnlyRepeatedDecision.nextActionContract.codexFallbackRequired, false);
+assert.equal(monitorOnlyRepeatedDecision.nextActionContract.decisionBasis.autonomyCanAutoDispatch, false);
+assert.equal(monitorOnlyRepeatedDecision.nextActionContract.decisionBasis.autonomyMode, 'monitor_only');
+assert.equal(monitorOnlyRepeatedDecision.managerExecutionPacket.status, 'manual_required');
+assert.equal(monitorOnlyRepeatedDecision.humanDecisionRequest?.status, 'waiting_for_operator');
+assert.equal(monitorOnlyRepeatedDecision.humanDecisionRequest?.autoDispatchAllowed, false);
+
+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/);
+
+const inventoryDiagnosisPrompt = buildResolveIOSupportV5MicrotaskPrompt({
+	bundle: initializeResolveIOSupportV5State({
+		jobId: 'job-004433',
+		ticketId: 'ticket-004433',
+		ticketNumber: '004433',
+		title: 'Support ticket #004433',
+		description: 'Inventory issue. On June 1 Danny entered pad inventory as 6 units in Kermit warehouse. When inventory was pulled later, it printed at Midland warehouse.',
+		approvedScopeRequirements: ['Inventory pad quantity entered for Kermit warehouse is printing under Midland warehouse.'],
+		existing: {
+			supportV5DiagnosisGate: {
+				issue_case: {
+					customer_complaint: '',
+					expected_result: '',
+					observed_result: '',
+					route_module: '',
+					account_customer_context: '',
+					reproduction_status: 'reproduced'
+				},
+				issue_class: 'missing_wrong_data',
+				accepted_hypothesis: {
+					statement: 'Existing check-in and checkout warehouse fields may be crossed in the inventory print path.',
+					falsifiable_test: '',
+					evidence: []
+				},
+				rejected_alternatives: [],
+				failing_path: {
+					description: 'Inventory print path for the part detail workflow.'
+				},
+				owner_files: [
+					'var/app/resolveio-ai-workspace/6a35ce5d939a82c734da7e67/resolveio-all/h2sko/angular/app/part/detail/part-detail.component.html',
+					'var/app/resolveio-ai-workspace/6a35ce5d939a82c734da7e67/resolveio-all/h2sko/angular/app/document/pick-ticket/report-doc-pick-ticket.component.html'
+				],
+				proof_plan: {},
+				evidence: [],
+				status: 'passed'
+			}
+		} as any,
+		now: '2026-06-06T00:06:00.000Z'
+	}),
+	lane: 'build',
+	stage: 'support-diagnosis-gate'
+});
+assert.match(inventoryDiagnosisPrompt.prompt, /Starter only/);
+assert.match(inventoryDiagnosisPrompt.prompt, /Inventory print path for the part detail workflow/);
+assert.match(inventoryDiagnosisPrompt.prompt, /h2sko\/angular\/app\/part\/detail\/part-detail\.component\.html/);
+assert.doesNotMatch(inventoryDiagnosisPrompt.prompt, /customer_complaint":""/);
+assert.doesNotMatch(inventoryDiagnosisPrompt.prompt, /var\/app\/resolveio-ai-workspace/);
+
+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');