@resolveio/server-lib 22.3.220 → 22.3.221

package/tests/ai-run-evidence.test.ts

@@ -0,0 +1,3773 @@
+import * as assert from 'node:assert/strict';
+import {
+	buildAIRun,
+	buildAIRunCost,
+	buildAIQaRun,
+	classifyAIRunOutcome,
+	normalizeOpenAIUsageRowsForCosting,
+	redactAIRunTrainingExample
+} from '../src/util/ai-run-evidence';
+import {
+	buildAICoderAIRunFromEvidence,
+	buildAssistantAIRunFromEvidence,
+	buildSupportAIRunFromEvidence
+} from '../src/util/ai-run-evidence-adapters';
+import {
+	classifyAIRunFailureClass,
+	decideAIRunRetry
+} from '../src/util/ai-run-evidence-eval';
+import { estimateOpenAIUsageCost } from '../src/util/openai-usage-cost';
+
+const routeOnlyQa = buildAIQaRun({
+	infraChecks: [
+		{ name: 'puppeteer_require', status: 'pass' },
+		{ name: 'chrome_executable', status: 'pass' }
+	],
+	compile: { status: 'pass', artifactPath: '.build-output/build-client.log' },
+	routeProbes: [{
+		route: '/billing/dashboard',
+		status: 'pass',
+		screenshot: 'qa-artifacts/route-ready.jpg',
+		caption: 'Route loaded.'
+	}]
+});
+
+assert.equal(routeOnlyQa.outcome, 'route_only_pass');
+assert.equal(routeOnlyQa.gateResults.some((gate) => gate.key === 'qa_business_assertion' && gate.status === 'blocked'), true);
+assert.equal(classifyAIRunOutcome({ qa: routeOnlyQa }).outcome, 'qa_incomplete');
+assert.equal(classifyAIRunOutcome({ qa: routeOnlyQa, scorecardPassed: true }).outcome, 'false_pass');
+
+const infraFailedQa = buildAIQaRun({
+	infraChecks: [
+		{ name: 'puppeteer_require', status: 'blocked', message: 'Unable to require puppeteer.' }
+	]
+});
+assert.equal(infraFailedQa.outcome, 'infra_failed');
+assert.equal(classifyAIRunOutcome({ qa: infraFailedQa }).outcome, 'qa_infra_failed');
+
+const compileFailedQa = buildAIQaRun({
+	infraChecks: [{ name: 'chrome_executable', status: 'pass' }],
+	compile: { status: 'stale', staleEvidence: true, artifactPath: '.build-output/build-client.log' }
+});
+assert.equal(compileFailedQa.outcome, 'compile_failed');
+assert.equal(classifyAIRunOutcome({ qa: compileFailedQa }).outcome, 'build_failed');
+
+const businessPassedQa = buildAIQaRun({
+	infraChecks: [{ name: 'chrome_launch', status: 'pass' }],
+	compile: { status: 'pass' },
+	routeProbes: [{ route: '/report', status: 'pass' }],
+	businessAssertions: [{
+		assertion: 'Report exports include seeded rows.',
+		status: 'pass',
+		dataProof: '3 seeded rows rendered and exported.',
+		artifactPaths: ['qa-artifacts/report-proof.json']
+	}]
+});
+assert.equal(businessPassedQa.outcome, 'business_assertion_passed');
+assert.equal(classifyAIRunOutcome({
+	qa: businessPassedQa,
+	status: 'Passed',
+	phase: 'COMPLETE',
+	scorecardPassed: true,
+	deployStatus: 'pass',
+	publishStatus: 'published',
+	sampleDataStatus: 'pass'
+}).outcome, 'accepted');
+
+const supportSingularBusinessAssertionRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-singular-aiqa', ticket_number: '004345', subject: 'Pricing import support QA proof' },
+	job: {
+		_id: 'support-job-singular-aiqa',
+		supportQaBusinessAssertion: {
+			assertion: 'Pricing import persists rows from both attached workbooks.',
+			status: 'pass',
+			result: 'business_assertion_passed',
+			workflow: 'Upload each attached workbook through production pricing import path.',
+			route: '/manage/pricing',
+			before: 'Pricing import proof batch started.',
+			action: 'Ran deterministic specialized workflow proof.',
+			expected: 'Rows reach insertPricesFromImport.',
+			observed: 'Both workbooks produced valid rows.',
+			dataProof: 'validPriceRecords=22, insertPricesFromImportPayloadSize=22',
+			mongoDelta: { collection: 'pricing-items', inserted: 22 },
+			artifactPaths: ['qa-artifacts/support-business-proof-before-after.png'],
+			metadata: { supportDiagnosisProof: true }
+		}
+	}
+});
+assert.equal(supportSingularBusinessAssertionRun.qa?.outcome, 'business_assertion_passed');
+assert.equal(supportSingularBusinessAssertionRun.gates.some((gate) => gate.key === 'qa_business_assertion' && gate.status === 'pass'), true);
+
+const releaseBlocked = classifyAIRunOutcome({
+	qa: businessPassedQa,
+	scorecardPassed: true,
+	deployStatus: 'Backend health smoke failed',
+	publishStatus: 'No such remote origin',
+	sampleDataStatus: 'empty collections detected'
+});
+assert.equal(releaseBlocked.outcome, 'release_blocked');
+assert.ok(releaseBlocked.gates.some((gate) => gate.key === 'release' && gate.status === 'fail'));
+
+const builtRun = buildAIRun({
+	source: 'aicoder_app',
+	sourceIds: { appId: 'app-1', jobId: 'job-1' },
+	title: 'Layflat Pressure Optimizer',
+	status: 'Passed',
+	phase: 'COMPLETE',
+	events: [],
+	qa: businessPassedQa,
+	scorecardPassed: true,
+	deployStatus: 'pass',
+	publishStatus: 'published',
+	sampleDataStatus: 'pass'
+});
+assert.equal(builtRun.outcome, 'accepted');
+assert.equal(builtRun.sourceIds.appId, 'app-1');
+
+const cost = buildAIRunCost([
+	{ model: 'gpt-5.3-codex', category: 'review', input_tokens: 1000, cached_input_tokens: 100, output_tokens: 250, cost_estimate: 1.23456789 },
+	{ model: 'gpt-5.4-mini', category: 'qa', inputTokens: 200, outputTokens: 50, estimatedUsd: 0.12 },
+	{
+		model: 'gpt-5.3-codex',
+		category: 'manual-monitoring',
+		usage_source: 'manual_codex',
+		usage_surface: 'aicoder',
+		cost_basis: 'manual_estimate',
+		is_manual: true,
+		is_untracked: true,
+		untracked_reason: 'Sidecar Codex session watched the Layflat builder.',
+		input_tokens: 3000,
+		output_tokens: 700,
+		cost_estimate: 7.5
+	}
+]);
+assert.equal(cost.inputTokens, 4200);
+assert.equal(cost.cachedInputTokens, 100);
+assert.equal(cost.outputTokens, 1000);
+assert.equal(cost.categories.review.count, 1);
+assert.deepEqual(cost.models, ['gpt-5.3-codex', 'gpt-5.4-mini']);
+assert.equal(cost.sources?.manual_codex.estimatedUsd, 7.5);
+assert.equal(cost.sources?.manual_codex.manualCount, 1);
+assert.equal(cost.sources?.manual_codex.untrackedCount, 1);
+assert.equal(cost.surfaces?.aicoder.estimatedUsd, 7.5);
+assert.equal(cost.manualEstimatedUsd, 7.5);
+assert.equal(cost.untrackedEstimatedUsd, 7.5);
+assert.equal(cost.untrackedWarnings?.includes('Sidecar Codex session watched the Layflat builder.'), true);
+
+const costOnlyManual = buildAIRunCost([
+	{
+		model: 'codex-manual',
+		category: 'manual-codex',
+		usage_source: 'manual_codex',
+		usage_surface: 'support',
+		cost_basis: 'manual_estimate',
+		is_manual: true,
+		is_untracked: true,
+		untracked_reason: 'Codex sidecar monitored support runner 004421.',
+		input_tokens: 0,
+		output_tokens: 0,
+		total_tokens: 0,
+		cost_estimate: 23.75
+	}
+]);
+assert.equal(costOnlyManual.totalTokens, 0);
+assert.equal(costOnlyManual.estimatedUsd, 23.75);
+assert.equal(costOnlyManual.manualEstimatedUsd, 23.75);
+assert.equal(costOnlyManual.untrackedEstimatedUsd, 23.75);
+assert.equal(costOnlyManual.sources?.manual_codex.count, 1);
+assert.equal(costOnlyManual.surfaces?.support.estimatedUsd, 23.75);
+
+const normalizedUsageRows = normalizeOpenAIUsageRowsForCosting([
+	{
+		model: 'gpt-5.5',
+		category: 'ai-dashboard-codex:master:file-body',
+		id_conversation: 'thread-1',
+		timestamp: '2026-06-13T10:00:00.000Z',
+		input_tokens: 1000,
+		cached_input_tokens: 800,
+		output_tokens: 100,
+		total_tokens: 1100,
+		cost_estimate: 1
+	},
+	{
+		model: 'gpt-5.5',
+		category: 'ai-dashboard-codex:master:file-body',
+		id_conversation: 'thread-1',
+		timestamp: '2026-06-13T10:01:00.000Z',
+		input_tokens: 1500,
+		cached_input_tokens: 1000,
+		output_tokens: 140,
+		total_tokens: 1640,
+		cost_estimate: 1.4
+	}
+]);
+assert.equal(normalizedUsageRows[1].input_tokens, 500);
+assert.equal(normalizedUsageRows[1].cached_input_tokens, 200);
+assert.equal(normalizedUsageRows[1].output_tokens, 40);
+assert.equal(normalizedUsageRows[1].cost_estimate, 0.4);
+
+const cumulativeCost = buildAIRunCost([
+	{
+		model: 'gpt-5.5',
+		category: 'ai-dashboard-codex:master:file-body',
+		id_conversation: 'thread-1',
+		timestamp: '2026-06-13T10:00:00.000Z',
+		input_tokens: 1000,
+		cached_input_tokens: 800,
+		output_tokens: 100,
+		total_tokens: 1100,
+		cost_estimate: 1
+	},
+	{
+		model: 'gpt-5.5',
+		category: 'ai-dashboard-codex:master:file-body',
+		id_conversation: 'thread-1',
+		timestamp: '2026-06-13T10:01:00.000Z',
+		input_tokens: 1500,
+		cached_input_tokens: 1000,
+		output_tokens: 140,
+		total_tokens: 1640,
+		cost_estimate: 1.4
+	}
+]);
+assert.equal(cumulativeCost.inputTokens, 1500);
+assert.equal(cumulativeCost.cachedInputTokens, 1000);
+assert.equal(cumulativeCost.outputTokens, 140);
+assert.equal(cumulativeCost.estimatedUsd, 1.4);
+assert.equal(estimateOpenAIUsageCost('gpt-5.4-2026-03-10', 1000, 100, 500), 0.002875);
+assert.equal(estimateOpenAIUsageCost('gpt-5.3-codex', 1000, 100, 500), 0.00575);
+assert.equal(estimateOpenAIUsageCost('gpt-5.4-codex', 1000, 100, 500), 0.002875);
+assert.equal(estimateOpenAIUsageCost('codex-mini-latest', 1000, 100, 500), 0.000863);
+
+const redacted = redactAIRunTrainingExample({
+	runId: 'run-1',
+	source: 'ai_assistant',
+	inputSummary: 'Mongo URL mongodb://user:password@host/db and email test@example.com',
+	actionSummary: 'Used key sk-12345678901234567890',
+	outcome: 'rejected',
+	evidence: ['ghp_12345678901234567890 appears here']
+});
+assert.match(redacted.inputSummary, /\[redacted-mongo-url\]/);
+assert.match(redacted.inputSummary, /\[redacted-email\]/);
+assert.match(redacted.actionSummary, /\[redacted-secret\]/);
+assert.match(redacted.evidence[0], /\[redacted-secret\]/);
+
+const supportRootCauseEntryContract = {
+	contract_id: 'support-root-cause-entry-test',
+	version: 'support_root_cause_entry_v1',
+	status: 'required',
+	required_output: {
+		object_key: 'support_diagnosis_gate',
+		status: 'passed',
+		required_fields: [
+			'issue_case',
+			'issue_class',
+			'accepted_hypothesis',
+			'rejected_alternatives',
+			'failing_path',
+			'owner_files',
+			'proof_plan',
+			'evidence'
+		]
+	},
+	owner_file_policy: {
+		max_files: 8,
+		exact_files_only: true,
+		edits_outside_owner_files_require_revised_diagnosis: true
+	},
+	business_proof_policy: {
+		requires_aiqa_business_assertion: true,
+		requires_before_action_after: true,
+		route_load_screenshot_scorecard_model_claim_not_acceptance: true,
+		required_artifacts: ['runner-evidence/diagnosis-gate.json', 'qa-artifacts/aiqa-business-assertion.json']
+	},
+	failure_policy: {
+		repeated_failure_without_new_evidence_parks_run: true,
+		infra_compile_puppeteer_startup_failures_route_to_infra_repair: true,
+		similar_tickets_and_commits_are_advisory_only: true
+	},
+	issue_class_probes: [
+		'no_op_submit',
+		'missing_wrong_data',
+		'filter_query_mismatch',
+		'invoice_pdf_export',
+		'upload_import',
+		'route_auth_hydration',
+		'slow_query_performance'
+	].map((issueClass) => ({
+		issue_class: issueClass,
+		required_paths: ['frontend_event', 'backend_method'],
+		required_evidence: ['before/action/after business state'],
+		false_pass_blockers: ['route loaded only']
+	}))
+};
+
+const supportRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-004421', ticketNumber: '004421', title: 'QA route only false pass' },
+	job: {
+		_id: 'support-job-1',
+		status: 'Running',
+		phase: 'QA',
+			supportRootCauseEntryContract,
+			supportRootCauseSimilarFixHintContract: {
+				contract_id: 'support-similar-fix-hints-test',
+				version: 'support_similar_fix_hint_contract_v1',
+				status: 'advisory_only',
+				source: 'ai_runs_and_completed_support_jobs',
+				candidate_count: 3,
+				hint_count: 1,
+				owner_file_hints: ['server/src/publications/support-tickets.ts'],
+				ranked_hints: [{
+					rank: 1,
+					source: 'support_ticket',
+					score: 188,
+					ticket_number: '004333',
+					commit_sha: '2222222222222222222222222222222222222222',
+					issue_class: 'filter_query_mismatch',
+					owner_files: ['server/src/publications/support-tickets.ts'],
+					reason: 'issue_class:filter_query_mismatch; owner_file_overlap:server/src/publications/support-tickets.ts',
+					title: 'Prior accepted customer filter fix'
+				}],
+				usage_policy: {
+					similar_hints_are_not_proof: true,
+					fresh_reproduction_or_blocked_reproduction_required: true,
+					accepted_hypothesis_must_be_current_ticket_specific: true,
+					owner_files_require_current_ticket_evidence: true,
+					must_record_rejected_hints_or_alternatives: true
+				},
+				required_model_actions: [
+					'Inspect the top hint owner files only as starting candidates.',
+					'For every reused owner file, cite current-ticket code/data/browser/log evidence.'
+				]
+			},
+			supportV5DiagnosisGate: {
+				issue_case: {
+					customer_complaint: 'Support ticket list shows tickets from the wrong customer after applying a customer filter.',
+					expected_result: 'Only tickets for Customer B should appear when Customer B is selected.',
+					observed_result: 'A Customer A ticket remains visible while filtered to Customer B.',
+					route_module: '/support tickets list',
+					account_customer_context: 'Support admin reviewing ticket 004421 for Customer B.',
+					reproduction_status: 'reproduced'
+				},
+				issue_class: 'filter_query_mismatch',
+				status: 'passed',
+				accepted_hypothesis: {
+					statement: 'The ticket list query ignores the customer filter.',
+					falsifiable_test: 'Apply the Customer B filter and compare the returned rows with the persisted customer id for each ticket.',
+					evidence: ['QA artifact shows Customer A ticket visible while Customer B filter is active.']
+				},
+				rejected_alternatives: [
+					'Frontend select state was not the root cause because the network payload includes the selected Customer B filter.',
+					'Authentication was not the root cause because the affected support admin can load the ticket list route.'
+				],
+				failing_path: {
+					frontend: 'Support ticket customer filter submits selected customer id.',
+					backend: 'server/src/publications/support-tickets.ts ticket list publication',
+					data_query: 'Mongo ticket query does not constrain by selected customer id.',
+					description: 'Filter input reaches the backend, but the publication query returns rows outside the selected customer.'
+				},
+				owner_files: ['server/src/publications/support-tickets.ts'],
+				proof_plan: {
+					before: 'Customer A ticket appears while filtered to Customer B.',
+					action: 'Apply the Customer B filter and reload the ticket list.',
+					after: 'Only Customer B tickets are listed.',
+					business_assertion: 'The wrong-customer ticket is absent after filtering.',
+					data_assertion: 'Every returned ticket row has customerId equal to Customer B.',
+					artifact_expectation: 'QA stores before/action/after row snapshots and the filtered publication payload.',
+					business_proof_contract: {
+						issue_class: 'filter_query_mismatch',
+						setup_state: 'Seed or select one Customer A ticket and one Customer B ticket.',
+						action_under_test: 'Apply the Customer B filter on the support ticket list.',
+						expected_business_state_change: 'Rows outside Customer B are excluded while Customer B rows remain visible.',
+						prohibited_false_pass: 'Route load or non-empty table without row/customer proof.',
+						proof_artifacts: ['qa-artifacts/support-filter-before-after.json'],
+						data_or_dom_assertion: 'DOM rows and publication payload contain only Customer B ticket ids.'
+					}
+				},
+				evidence: [{
+					type: 'ticket',
+					summary: 'Ticket 004421 reports wrong-customer tickets appearing after a customer filter is applied.'
+				}, {
+					type: 'qa',
+					summary: 'Browser QA reproduced Customer A ticket visible while Customer B filter was active.',
+					artifactPath: 'qa-artifacts/support-filter-reproduction.json'
+				}, {
+					type: 'code',
+					summary: 'Publication owner file contains the query that returns support ticket rows.'
+				}]
+			},
+		supportV5AutonomousDecision: {
+			nextActionContract: {
+				contractId: 'support-next-action-safe-repair',
+				action: 'run_owner_scoped_repair',
+				label: 'Run owner-scoped repair',
+				primaryCommand: 'run_support_v5_owner_scoped_repair',
+				lane: 'build',
+				stepType: 'owner_scoped_repair',
+				safeToAutoRun: true,
+				requiresHumanApproval: false,
+				canRunWithoutCodexMonitor: true,
+				codexFallbackRequired: false,
+				rootCauseFirstSatisfied: true,
+				costRisk: 'expensive_model',
+				preconditions: ['SupportDiagnosisGate passed.'],
+				expectedStateTransition: 'Owner-scoped repair updates only the diagnosed publication owner file, then records business proof or parks on unchanged evidence.',
+				successEvidence: ['AIQaBusinessAssertion mapped to proof_plan.'],
+				stopConditions: ['Same failure class repeats without new evidence.'],
+				forbiddenActions: [
+					'Do not edit outside owner_files without a revised diagnosis gate.',
+					'Do not accept route-load-only proof as support completion.'
+				],
+				ownerFiles: ['server/src/publications/support-tickets.ts'],
+				nextCommands: ['run_support_v5_owner_scoped_repair'],
+				decisionBasis: {
+					diagnosisValid: true,
+					ownerFilesReady: true,
+					proofPlanReady: true,
+					businessProofReady: false,
+					evidenceFreshnessStatus: 'fresh',
+					evidenceStrength: 'medium',
+					failureClass: 'product_code',
+					sameFailureCount: 0,
+					hotfixCommitRequired: true,
+					liveHotfixBlockedUntilCommit: false
+				}
+			}
+		}
+	},
+	taskEvents: [{ message: 'Route loaded in browser.', phase: 'qa' }],
+	usageLedger: [{
+		model: 'codex-manual',
+		category: 'manual-codex-monitor',
+		usage_source: 'manual_codex',
+		usage_surface: 'support',
+		cost_basis: 'manual_estimate',
+		is_manual: true,
+		is_untracked: true,
+		untracked_reason: 'Codex sidecar monitored support runner 004421.',
+		total_tokens: 0,
+		cost_estimate: 18.25
+	}],
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004421', status: 'pass', screenshot: 'qa-artifacts/route.jpg' }],
+			hotfixEvidence: {
+				channel: 'backend_js',
+				target: {
+					host: 'backend.resolveio.com',
+					path: '/var/app/current/http/runner-manager-selftest.js'
+				},
+				compiledArtifactPath: 'dist/http/runner-manager-selftest.js',
+				remoteChecksumBefore: '1111111111111111111111111111111111111111111111111111111111111111',
+				remoteChecksumAfter: '2222222222222222222222222222222222222222222222222222222222222222',
+				sourceCommitSha: '6fd400e1d8c961c1e88820292c323e688fdcc0a4',
+				githubCommitUrl: 'https://github.com/resolveio/resolveio-all/commit/6fd400e1d8c961c1e88820292c323e688fdcc0a4',
+				gitCommitStatus: 'passed',
+				gitPushStatus: 'passed',
+				restartEvidence: 'nodejs and resolveio_support_ticket_codex_manager restarted on all support hosts',
+				healthCheckStatus: 'passed',
+				selfTestStatus: 'passed'
+			},
+			scorecardPassed: true
+		}
+	});
+assert.equal(supportRun.source, 'support_ticket');
+assert.equal(supportRun.sourceIds.ticketNumber, '004421');
+assert.equal(supportRun.outcome, 'false_pass');
+assert.equal(supportRun.metadata?.diagnosis?.issueClass, 'filter_query_mismatch');
+assert.equal(supportRun.metadata?.rootCauseEntryContract?.contractId, 'support-root-cause-entry-test');
+assert.equal(supportRun.metadata?.rootCauseEntryContract?.issueClassProbeCount, 7);
+	assert.deepEqual(supportRun.metadata?.diagnosis?.ownerFiles, ['server/src/publications/support-tickets.ts']);
+	assert.equal(supportRun.events.some((event) => event.category === 'support_diagnosis_evidence_pack'), true);
+	assert.equal(supportRun.gates.some((gate) => gate.key === 'support_diagnosis_evidence_pack' && gate.status === 'pass'), true);
+	assert.equal(supportRun.metadata?.diagnosisEvidencePack?.readOnly, true);
+	assert.equal(supportRun.metadata?.diagnosisEvidencePack?.sourceEditsAllowed, false);
+	assert.equal(supportRun.metadata?.diagnosisEvidencePack?.issueClassProbeCount, 7);
+	assert.equal(supportRun.events.some((event) => event.category === 'support_similar_fix_hint_contract'), true);
+	assert.equal(supportRun.gates.some((gate) => gate.key === 'support_similar_fix_hint_contract' && gate.status === 'pass'), true);
+	assert.equal(supportRun.metadata?.similarFixHintContract?.advisoryOnly, true);
+	assert.equal(supportRun.metadata?.similarFixHintContract?.ownerFilesRequireCurrentEvidence, true);
+	assert.equal(supportRun.metadata?.similarFixHintContract?.hintCount, 1);
+	assert.equal(supportRun.events.some((event) => event.category === 'support_diagnosis_proof_matrix'), true);
+	assert.equal(supportRun.gates.some((gate) => gate.key === 'support_diagnosis_proof_matrix' && gate.status === 'pass'), true);
+	assert.equal(supportRun.metadata?.diagnosisProofMatrix?.matrixStatus, 'ready');
+	assert.deepEqual(supportRun.metadata?.diagnosisProofMatrix?.uncoveredOwnerFiles, []);
+	assert.equal(supportRun.metadata?.diagnosisProofMatrix?.rootCauseEvidenceCount >= 1, true);
+	assert.equal(supportRun.metadata?.diagnosis?.proofMatrixStatus, 'ready');
+	assert.equal(supportRun.events.some((event) => event.category === 'support_owner_scoped_repair_contract'), true);
+	assert.equal(supportRun.gates.some((gate) => gate.key === 'support_owner_scoped_repair_contract' && gate.status === 'pass'), true);
+	assert.equal(supportRun.metadata?.ownerScopedRepairContract?.contractStatus, 'ready');
+	assert.equal(supportRun.metadata?.ownerScopedRepairContract?.sourceEditsAllowed, true);
+	assert.equal(supportRun.metadata?.ownerScopedRepairContract?.patchUnitCount, 1);
+	assert.equal(supportRun.metadata?.ownerScopedRepairContract?.requiredEvidenceAfterRepair.some((entry: string) => /AIQaBusinessAssertion/i.test(entry)), true);
+	assert.equal(supportRun.events.some((event) => event.category === 'support_issue_class_probe_plan'), true);
+	assert.equal(supportRun.gates.some((gate) => gate.key === 'support_issue_class_probe_plan' && gate.status === 'pass'), true);
+	assert.equal(supportRun.metadata?.issueClassProbePlan?.issueClassProbePlanReady, true);
+	assert.equal(supportRun.metadata?.issueClassProbePlan?.issueClass, 'filter_query_mismatch');
+	assert.equal(supportRun.events.some((event) => event.category === 'diagnosis_gate'), true);
+	assert.equal(supportRun.events.some((event) => event.category === 'support_root_cause_entry_contract'), true);
+	assert.equal(supportRun.gates.some((gate) => gate.key === 'support_root_cause_entry_contract' && gate.status === 'pass'), true);
+	assert.equal(supportRun.events.some((event) => event.category === 'support_next_action_contract'), true);
+	assert.equal(supportRun.gates.some((gate) => gate.key === 'support_next_action_contract' && gate.status === 'pass'), true);
+	assert.equal(supportRun.metadata?.nextActionContract?.canRunWithoutCodexMonitor, true);
+	assert.equal(supportRun.metadata?.nextActionContract?.hotfixCommitRequired, true);
+	assert.equal(supportRun.metadata?.nextActionContract?.liveHotfixBlockedUntilCommit, false);
+	assert.equal(supportRun.events.some((event) => event.category === 'support_manager_execution_packet'), true);
+	assert.equal(supportRun.gates.some((gate) => gate.key === 'support_manager_execution_packet' && gate.status === 'pass'), true);
+	assert.equal(supportRun.metadata?.managerExecutionPacket?.status, 'auto_ready');
+	assert.equal(supportRun.metadata?.managerExecutionPacket?.executeNow, true);
+	assert.equal(supportRun.metadata?.managerExecutionPacket?.canRunWithoutCodexMonitor, true);
+	assert.equal(supportRun.metadata?.managerExecutionPacket?.codexFallbackRequired, false);
+	assert.equal(supportRun.metadata?.managerExecutionPacket?.retryScope, 'owner_files_only');
+	assert.equal(supportRun.metadata?.managerExecutionPacket?.maxAttemptsBeforeFreshEvidence, 1);
+	assert.equal(supportRun.metadata?.managerExecutionPacket?.proofResetContract?.retryScope, 'owner_files_only');
+	assert.equal(supportRun.metadata?.managerExecutionPacket?.proofResetContract?.maxAttemptsBeforeFreshEvidence, 1);
+	assert.ok(supportRun.metadata?.managerExecutionPacket?.proofResetContract?.requiredResetEvidence?.length > 0);
+	assert.equal(supportRun.gates.some((gate) => gate.key === 'cost_observability' && gate.status === 'warn'), true);
+	assert.equal(supportRun.metadata?.costObservability?.externalCodexMonitorUsed, true);
+	assert.equal(supportRun.metadata?.costObservability?.manualEstimatedUsd, 18.25);
+	assert.ok(supportRun.metadata?.costObservability?.warnings?.some((warning: string) => /support runner 004421/i.test(warning)));
+	assert.equal(supportRun.events.some((event) => event.type === 'hotfix' && event.category === 'backend_js'), true);
+	assert.equal(supportRun.gates.some((gate) => gate.key === 'hotfix_evidence' && gate.status === 'pass'), true);
+	assert.equal(supportRun.gates.some((gate) => gate.key === 'hotfix_commit_proof' && gate.status === 'pass'), true);
+	assert.equal(supportRun.events.some((event) => event.category === 'hotfix_commit_proof' && event.metadata?.passed === true), true);
+	assert.equal(supportRun.metadata?.hotfixDurability?.commitProofPassed, true);
+		assert.equal(supportRun.metadata?.hotfixDurability?.commitBlocked, false);
+		assert.equal(supportRun.gates.some((gate) => gate.key === 'qa_business_assertion' && gate.status === 'blocked'), true);
+
+	const supportManagerContinuationRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			_id: 'ticket-manager-continuation',
+			ticketNumber: '004602',
+			title: 'Support manager continuation path',
+			automation: {
+				manager: {
+					status: 'parked',
+					last_continuation_contract: {
+						contract_id: 'support-continuation-selftest',
+						status: 'waiting_for_unblock',
+						action: 'run_evidence_probe',
+						required_state_transition: 'Evidence probe records a changed blocker/evidence hash, new artifact, or remains parked.'
+					},
+					last_operator_guidance_response: {
+						response_id: 'support-operator-guidance-response-selftest',
+						status: 'accepted',
+						accepted: true,
+						guidance_id: 'support-operator-guidance-selftest',
+						requested_action: 'run_evidence_probe',
+						submit_action: 'run_evidence_probe',
+						can_run_without_codex_monitor: true,
+						safe_to_autorun_after_input: false,
+						resume_unblock_contract: {
+							contract_id: 'support-resume-unblock-selftest-evidence',
+							action: 'run_evidence_probe',
+							allowed_after_input: ['run_evidence_probe'],
+							required_state_transition: 'Evidence probe records a changed blocker/evidence hash, new artifact, or remains parked.',
+							blocks_product_repair_until_changed_evidence: true,
+							proof_required_before_continuation: false
+						},
+						resume_unblock_response: {
+							contract_id: 'support-resume-unblock-selftest-evidence',
+							action: 'run_evidence_probe',
+							operator_evidence_summary: 'Operator attached a new failing QA row artifact for the evidence probe.',
+							artifact_paths: ['qa-artifacts/selftest-new-evidence.json'],
+							material_evidence_claimed: true,
+							material_evidence_signals: ['artifact_paths']
+						},
+						recorded_at: '2026-06-15T00:12:00.000Z'
+					},
+					last_operator_guidance_resume_dispatch: {
+						status: 'queued',
+						job_id: 'support-resume-job-selftest',
+						dispatch_action: 'run_evidence_probe'
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-manager-continuation',
+			status: 'Running',
+			phase: 'MANAGER_RECOVERY'
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'support_manager', status: 'pass' }],
+			compile: { status: 'pass' }
+		}
+	});
+	assert.equal(supportManagerContinuationRun.gates.some((gate) => gate.key === 'support_manager_continuation' && gate.status === 'pass'), true);
+	assert.equal(supportManagerContinuationRun.events.some((event) => event.category === 'support_manager_continuation'), true);
+	assert.equal(supportManagerContinuationRun.metadata?.managerContinuation?.managerStatus, 'parked');
+	assert.equal(supportManagerContinuationRun.metadata?.managerContinuation?.operatorGuidanceAccepted, true);
+	assert.equal(supportManagerContinuationRun.metadata?.managerContinuation?.resumeUnblockContractId, 'support-resume-unblock-selftest-evidence');
+	assert.equal(supportManagerContinuationRun.metadata?.managerContinuation?.resumeDispatchStatus, 'queued');
+	assert.equal(supportManagerContinuationRun.metadata?.managerContinuation?.canRunWithoutCodexMonitor, true);
+	assert.equal(supportManagerContinuationRun.metadata?.managerContinuation?.blocksProductRepairUntilChangedEvidence, true);
+	assert.equal(supportManagerContinuationRun.metadata?.managerContinuation?.materialEvidenceClaimed, true);
+	assert.ok(supportManagerContinuationRun.metadata?.managerContinuation?.artifactPaths?.includes('qa-artifacts/selftest-new-evidence.json'));
+
+	const blockedSupportAutonomyRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			_id: 'ticket-approval-blocked',
+			ticketNumber: '004600',
+			title: 'Support autonomy approval blocked',
+				automation: {
+					autoloop: {
+						last_approval_block: {
+							record_id: 'support-autoloop-approval-block-over-six',
+							status: 'blocked_autonomy_approval_required',
+							action: 'approve_support_autonomy_over_limit',
+							next_action: 'approve_support_autonomy_over_limit',
+							approval_contract_id: 'support-autonomy-approval-blocked',
+							scope_fingerprint: 'selftest-scope-over-six',
+							decision_kind: 'over_limit_approval_required',
+							requires_over_limit_approval: true,
+							on_the_fly_scope_change_approval_required: true,
+							target_grade: 'A',
+							required_terminal_state: 'A-grade PR with QA screenshots, AIQaBusinessAssertion before/action/after proof, source commit proof, and changed files inside owner_files',
+							reason: 'Iteration 1: Support autonomy approval required before product-code repair: over_6_hours_requires_operator_approval',
+							product_repair_dispatch_guard: {
+								status: 'blocked',
+								next_action: 'approve_support_autonomy_over_limit',
+								owner_files: ['server/src/publications/support-tickets.ts'],
+								blockers: ['over_6_hours_requires_operator_approval']
+							},
+							human_decision_request: {
+								request_id: 'support-autoloop-human-decision-over-six',
+								required: true,
+								status: 'waiting_for_operator',
+								decision_kind: 'over_limit_approval_required',
+								approval_action: 'approve_support_autonomy_over_limit',
+								preferred_choice_id: 'approve_over_limit_autonomy',
+								can_approve_from_console: true,
+								reason: 'Approve the current over-limit scope or keep the run parked.',
+								evidence: {
+									requires_over_limit_approval: true,
+									changed_files: ['server/src/publications/support-tickets.ts']
+								}
+							}
+						}
+					},
+					runner_console: {
+						autonomy_approval: {
+						contract_id: 'support-autonomy-approval-blocked',
+						status: 'approval_required',
+						approved: false,
+						estimated_hours: 8,
+						max_auto_hours_without_approval: 6,
+						over_max_auto_hours: true,
+						bug_not_bug: 'bug',
+						bug_not_bug_classification_approved: true,
+						decision_kind: 'over_limit_approval_required',
+						approval_action: 'approve_support_autonomy_over_limit',
+						preferred_choice_id: 'approve_over_limit_autonomy',
+						can_approve_from_console: true,
+						requires_over_limit_approval: true,
+						after_approval_autopilot_until_a_grade: true,
+						target_grade: 'A',
+						autopilot_completion_contract: {
+							mode: 'approved_scope_to_a_grade_pr',
+							status: 'waiting_for_operator_approval',
+							required_terminal_state: 'A-grade PR with QA screenshots, AIQaBusinessAssertion before/action/after proof, source commit proof, and changed files inside owner_files',
+							stop_or_park_conditions: ['over six hours without explicit over-limit approval']
+						},
+						qa_screenshots_required: true,
+						before_action_after_business_proof_required: true,
+						aiqa_business_assertion_required: true,
+						owner_files: ['server/src/publications/support-tickets.ts'],
+						approved_owner_files: ['server/src/publications/support-tickets.ts'],
+						required_completion_evidence: ['before/action/after AIQaBusinessAssertion', 'QA screenshots']
+					},
+					last_product_repair_dispatch_guard: {
+						guard: 'support_autonomy_product_repair_dispatch_guard',
+						status: 'blocked',
+						allowed: false,
+						action: 'run_owner_scoped_repair',
+						edits_product_code: true,
+						auto_continue_after_approval: false,
+						next_action: 'approve_support_autonomy_over_limit',
+						continuation_contract: {
+							mode: 'approved_scope_to_a_grade_pr',
+							status: 'waiting_for_operator_approval',
+							required_terminal_state: 'A-grade PR with QA screenshots, AIQaBusinessAssertion before/action/after proof, source commit proof, and changed files inside owner_files'
+						},
+						terminal_target: 'A-grade PR with QA screenshots, AIQaBusinessAssertion before/action/after proof, source commit proof, and changed files inside owner_files',
+						next_proof_phases: ['confirm_support_diagnosis_gate', 'run_business_proof_qa_with_screenshots'],
+						allowed_auto_actions: ['run_owner_scoped_repair', 'run_business_proof_qa'],
+						forbidden_actions: ['customer success reply before AIQaBusinessAssertion proof'],
+						requires_over_limit_approval: true,
+						owner_files: ['server/src/publications/support-tickets.ts'],
+						blockers: ['over_6_hours_requires_operator_approval']
+					}
+				},
+				manager: {
+					last_human_decision_request: {
+						request_id: 'support-autonomy-human-decision-blocked',
+						required: true,
+						status: 'pending',
+						decision_kind: 'over_limit_approval_required',
+						approval_action: 'approve_support_autonomy_over_limit',
+						preferred_choice_id: 'approve_over_limit_autonomy',
+						can_approve_from_console: true,
+						reason: 'Estimated work is above the six-hour autonomy ceiling.',
+						evidence: {
+							requires_over_limit_approval: true,
+							changed_files: ['server/src/publications/support-tickets.ts']
+						},
+						choices: [{
+							choice_id: 'approve_over_limit_autonomy',
+							action: 'approve_support_autonomy_over_limit',
+							label: 'Approve Over-Limit Autopilot',
+							safety: 'high'
+						}]
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-approval-blocked',
+			status: 'Running',
+			phase: 'BUILD'
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004600', status: 'pass', screenshot: 'qa-artifacts/support-approval-route.png' }],
+			businessAssertions: [{
+				assertion: 'Synthetic business proof would otherwise pass.',
+				status: 'pass',
+				action: 'Apply filter.',
+				expected: 'Only matching records appear.',
+				observed: 'Only matching records appeared.',
+				dataProof: 'Synthetic row proof.'
+			}],
+			scorecardPassed: true
+		}
+	});
+	assert.equal(blockedSupportAutonomyRun.outcome, 'manual_handoff');
+		assert.equal(blockedSupportAutonomyRun.gates.some((gate) => gate.key === 'support_autonomy_approval' && gate.status === 'blocked'), true);
+		assert.equal(blockedSupportAutonomyRun.gates.some((gate) => gate.key === 'support_product_repair_dispatch_guard' && gate.status === 'blocked'), true);
+		assert.equal(blockedSupportAutonomyRun.gates.some((gate) => gate.key === 'support_autoloop_approval_block' && gate.status === 'blocked'), true);
+		assert.equal(blockedSupportAutonomyRun.gates.some((gate) => gate.key === 'support_human_decision_request' && gate.status === 'blocked'), true);
+		assert.equal(blockedSupportAutonomyRun.events.some((event) => event.category === 'support_autonomy_approval'), true);
+		assert.equal(blockedSupportAutonomyRun.events.some((event) => event.category === 'support_autoloop_approval_block'), true);
+		assert.equal(blockedSupportAutonomyRun.metadata?.autonomyApproval?.requiresOverLimitApproval, true);
+		assert.equal(blockedSupportAutonomyRun.metadata?.autonomyApproval?.afterApprovalAutopilotUntilAGrade, true);
+		assert.equal(blockedSupportAutonomyRun.metadata?.autonomyApproval?.qaScreenshotsRequired, true);
+	assert.equal(blockedSupportAutonomyRun.metadata?.autonomyApproval?.terminalTarget, 'A-grade PR with QA screenshots, AIQaBusinessAssertion before/action/after proof, source commit proof, and changed files inside owner_files');
+	assert.equal(blockedSupportAutonomyRun.metadata?.productRepairDispatchGuard?.nextAction, 'approve_support_autonomy_over_limit');
+	assert.equal(blockedSupportAutonomyRun.metadata?.productRepairDispatchGuard?.continuationContractMode, 'approved_scope_to_a_grade_pr');
+		assert.ok(blockedSupportAutonomyRun.metadata?.productRepairDispatchGuard?.nextProofPhases?.includes('run_business_proof_qa_with_screenshots'));
+		assert.ok(blockedSupportAutonomyRun.metadata?.productRepairDispatchGuard?.forbiddenActions?.some((action: string) => /customer success reply/i.test(action)));
+		assert.equal(blockedSupportAutonomyRun.metadata?.humanDecisionRequest?.preferredChoiceId, 'approve_over_limit_autonomy');
+		assert.equal(blockedSupportAutonomyRun.metadata?.autoloopApprovalBlock?.nextAction, 'approve_support_autonomy_over_limit');
+	assert.equal(blockedSupportAutonomyRun.metadata?.autoloopApprovalBlock?.requiresOverLimitApproval, true);
+	assert.equal(blockedSupportAutonomyRun.metadata?.autoloopApprovalBlock?.humanDecisionPreferredChoiceId, 'approve_over_limit_autonomy');
+	assert.match(blockedSupportAutonomyRun.nextAction || '', /approve_support_autonomy_over_limit/);
+
+	const elapsedAutoloopApprovalRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			_id: 'ticket-autoloop-elapsed-approval',
+			ticketNumber: '004603',
+			title: 'Support autoloop elapsed runtime approval boundary',
+			automation: {
+				autoloop: {
+					status: 'stopped',
+					last_approval_block: {
+						record_id: 'support-autoloop-approval-block-elapsed',
+						status: 'blocked_elapsed_reapproval_required',
+						action: 'approve_support_autonomy_over_limit',
+						next_action: 'approve_support_autonomy_over_limit',
+						run_id: 'support-auto-improve-elapsed',
+						iteration: 2,
+						reason: 'Approved support autoloop runtime reached 6.25 hours, above the 6-hour approved runtime boundary.',
+						decision_kind: 'elapsed_wall_clock_reapproval_required',
+						requires_elapsed_reapproval: true,
+						requires_over_limit_approval: true,
+						elapsed_runtime_ms: 22500000,
+						elapsed_runtime_hours: 6.25,
+						max_approved_runtime_ms: 21600000,
+						max_approved_runtime_hours: 6,
+						max_wall_clock_ms: 21600000,
+						max_wall_clock_hours: 6,
+						human_decision_request: {
+							request_id: 'support-autonomy-elapsed-runtime',
+							required: true,
+							status: 'waiting_for_operator',
+							decision_kind: 'elapsed_wall_clock_reapproval_required',
+							approval_action: 'approve_support_autonomy_over_limit',
+							preferred_choice_id: 'approve_over_limit_autonomy'
+						}
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-elapsed-approval',
+			status: 'Stopped',
+			phase: 'AUTOLOOP'
+		},
+		now: '2026-06-17T12:00:00.000Z'
+	});
+	const elapsedApprovalGate = elapsedAutoloopApprovalRun.gates.find((gate) => gate.key === 'support_autoloop_approval_block');
+	assert.equal(elapsedAutoloopApprovalRun.outcome, 'manual_handoff');
+	assert.equal(elapsedApprovalGate?.status, 'blocked');
+	assert.equal(elapsedApprovalGate?.metadata?.requiresElapsedReapproval, true);
+	assert.equal(elapsedApprovalGate?.metadata?.elapsedRuntimeHours, 6.25);
+	assert.equal(elapsedApprovalGate?.metadata?.maxApprovedRuntimeHours, 6);
+	assert.equal(elapsedAutoloopApprovalRun.metadata?.autoloopApprovalBlock?.requiresElapsedReapproval, true);
+	assert.equal(elapsedAutoloopApprovalRun.metadata?.autoloopApprovalBlock?.elapsedRuntimeHours, 6.25);
+	assert.match(elapsedAutoloopApprovalRun.nextAction || '', /wall-clock boundary/i);
+
+	const stoppedSupportNoProgressRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			_id: 'ticket-autoloop-no-progress',
+			ticketNumber: '004602',
+			title: 'Support autoloop stopped with no new evidence',
+			automation: {
+				autoloop: {
+					run_id: 'support-autoloop-no-progress-run',
+					status: 'stopped',
+					handoff_required: true,
+					no_progress_streak: 2,
+					last_progress_signal: false,
+					last_progress_reasons: ['same_failing_check_fingerprint'],
+					last_evidence_changed: false,
+					last_evidence_reasons: ['same_diff_fingerprint', 'same_pr_status'],
+					last_strict_gate_reason: 'missing_aiqa_business_assertion',
+					last_error: 'No-progress rule triggered after 2 consecutive iterations without grade/PR/diff improvement.',
+					last_continuation_decision: {
+						action: 'park',
+						reason: 'same failure fingerprint and no new business proof evidence'
+					},
+					history: [{
+						iteration: 1,
+						progress_signal: false,
+						evidence_changed: false,
+						diff_fingerprint: 'diff:same',
+						failing_check_fingerprint: 'check:missing-aiqa',
+						strict_gate_reason: 'missing_aiqa_business_assertion',
+						continuation_decision: { action: 'park', reason: 'missing AIQaBusinessAssertion' }
+					}, {
+						iteration: 2,
+						progress_signal: false,
+						evidence_changed: false,
+						diff_fingerprint: 'diff:same',
+						failing_check_fingerprint: 'check:missing-aiqa',
+						strict_gate_reason: 'missing_aiqa_business_assertion',
+						continuation_decision: { action: 'park', reason: 'same blocker without new evidence' }
+					}]
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autoloop-no-progress',
+			status: 'Stopped',
+			phase: 'QA'
+		},
+		qaEvidence: {
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004602', status: 'pass', screenshot: 'qa-artifacts/support-no-progress-route.png' }],
+			scorecardPassed: true
+		}
+	});
+	const stoppedSupportNoProgressGate = stoppedSupportNoProgressRun.gates.find((gate) => gate.key === 'support_autoloop_no_progress');
+	assert.equal(stoppedSupportNoProgressRun.outcome, 'manual_handoff');
+	assert.equal(stoppedSupportNoProgressGate?.status, 'blocked');
+	assert.equal(stoppedSupportNoProgressGate?.metadata?.requiresNewEvidence, true);
+	assert.equal(stoppedSupportNoProgressGate?.metadata?.productRepairAllowed, false);
+	assert.equal(stoppedSupportNoProgressRun.events.some((event) => event.category === 'support_autoloop_no_progress'), true);
+	assert.equal(stoppedSupportNoProgressRun.metadata?.autoloopNoProgress?.requiresNewEvidence, true);
+	assert.match(stoppedSupportNoProgressRun.nextAction || '', /Collect new material evidence/i);
+
+	const approvedAutopilotTicket = {
+		_id: 'ticket-autopilot-approved',
+		ticketNumber: '004601',
+		title: 'Support approved autopilot completion',
+		automation: {
+			runner_console: {
+				autonomy_approval: {
+					contract_id: 'support-autonomy-approval-approved',
+					status: 'approved_autopilot',
+					approved: true,
+					approved_at: '2026-06-15T01:00:00.000Z',
+					approved_by: 'operator',
+					estimated_hours: 2,
+					max_auto_hours_without_approval: 6,
+					bug_not_bug: 'bug',
+					bug_not_bug_classification_approved: true,
+					decision_kind: 'approved_autopilot',
+					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: ['server/src/publications/support-tickets.ts'],
+					approved_owner_files: ['server/src/publications/support-tickets.ts'],
+					required_completion_evidence: [
+						'A-grade execution/artifacts/pull_request review',
+						'AIQaBusinessAssertion mapped to diagnosis proof_plan',
+						'before/action/after business proof',
+						'QA screenshot or trace'
+					],
+					autopilot_completion_contract: {
+						mode: 'approved_scope_to_a_grade_pr',
+						required_terminal_state: 'A-grade PR with QA screenshots, AIQaBusinessAssertion before/action/after proof, source commit proof, and changed files inside owner_files'
+					}
+				}
+			}
+		}
+	};
+	const postApprovalAutostartContract = {
+		contract_id: 'support-autonomy-post-approval-autostart-approved',
+		status: 'ready',
+		source: 'support_autonomy_approval',
+		approval_contract_id: 'support-autonomy-approval-approved',
+		approved: true,
+		auto_start_enabled: true,
+		method: 'runSupportTicketAutoImproveLoopManual',
+		options: {
+			max_iterations: 6,
+			iteration_timeout_ms: 1800000,
+			auto_create_pr: true,
+			execution_tier: 'small'
+		},
+		terminal_target: 'A-grade PR with QA screenshots, AIQaBusinessAssertion before/action/after proof, source commit proof, and changed files inside owner_files',
+		target_grade: 'A',
+		required_terminal_evidence: [
+			'A-grade execution/artifacts/pull_request review',
+			'AIQaBusinessAssertion mapped to diagnosis proof_plan',
+			'QA screenshot or trace'
+		],
+		allowed_auto_actions: ['run_owner_scoped_repair', 'run_business_proof_qa', 'create_pr'],
+		forbidden_without_reapproval: ['changing owner files without reapproval'],
+		blockers: [],
+		reason: 'Approval can resume the support auto-improve loop without external Codex monitoring.'
+	};
+	const approvedPostAutostartStartedRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			...approvedAutopilotTicket,
+			_id: 'ticket-autopilot-post-autostart-started',
+			automation: {
+				runner_console: {
+					autonomy_approval: approvedAutopilotTicket.automation.runner_console.autonomy_approval,
+					last_post_approval_autostart_contract: postApprovalAutostartContract,
+					last_post_approval_autostart: {
+						record_id: 'support-autonomy-post-approval-autostart-record-started',
+						status: 'started',
+						contract_id: postApprovalAutostartContract.contract_id,
+						approval_contract_id: 'support-autonomy-approval-approved',
+						auto_start_enabled: true,
+						method: 'runSupportTicketAutoImproveLoopManual',
+						run_id: 'support-auto-improve-run-004601',
+						result_status: 'started',
+						result: {
+							status: 'started',
+							run_id: 'support-auto-improve-run-004601'
+						},
+						blocks_manual_codex_monitoring: true,
+						can_continue_without_codex_monitor: true,
+						next_action: 'monitor_auto_improve_loop',
+						recorded_at: '2026-06-15T01:00:20.000Z'
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autopilot-post-autostart-started',
+			status: 'Running',
+			phase: 'BUILD'
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' }
+		}
+	});
+	assert.equal(approvedPostAutostartStartedRun.gates.some((gate) => gate.key === 'support_post_approval_autostart' && gate.status === 'pass'), true);
+	assert.equal(approvedPostAutostartStartedRun.events.some((event) => event.category === 'support_post_approval_autostart'), true);
+	assert.equal(approvedPostAutostartStartedRun.metadata?.postApprovalAutostart?.started, true);
+	assert.equal(approvedPostAutostartStartedRun.metadata?.postApprovalAutostart?.runId, 'support-auto-improve-run-004601');
+	assert.equal(approvedPostAutostartStartedRun.metadata?.postApprovalAutostart?.nextAction, 'monitor_auto_improve_loop');
+	assert.equal(approvedPostAutostartStartedRun.metadata?.postApprovalAutostart?.canContinueWithoutCodexMonitor, true);
+	assert.notEqual(approvedPostAutostartStartedRun.outcome, 'accepted');
+
+	const approvedPostAutostartBlockedRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			...approvedAutopilotTicket,
+			_id: 'ticket-autopilot-post-autostart-blocked',
+			automation: {
+				runner_console: {
+					autonomy_approval: approvedAutopilotTicket.automation.runner_console.autonomy_approval,
+					last_post_approval_autostart_contract: postApprovalAutostartContract,
+					last_post_approval_autostart: {
+						record_id: 'support-autonomy-post-approval-autostart-record-blocked',
+						status: 'blocked',
+						contract_id: postApprovalAutostartContract.contract_id,
+						approval_contract_id: 'support-autonomy-approval-approved',
+						auto_start_enabled: true,
+						method: 'runSupportTicketAutoImproveLoopManual',
+						result_status: 'global_busy',
+						result: {
+							status: 'global_busy',
+							active_ticket_id: 'ticket-active',
+							active_run_id: 'support-auto-improve-run-active'
+						},
+						failure_class: 'global_capacity',
+						blocker_fingerprint: 'post-autostart-global-capacity',
+						blocker_reason: 'Global support runner capacity blocked post-approval autostart.',
+						approval_boundary_valid: true,
+						can_retry_without_reapproval: true,
+						safe_retry_action: 'run_autoloop',
+						resume_contract: {
+							contract_id: 'support-post-approval-autostart-resume-global-capacity',
+							action: 'run_autoloop',
+							allowed_after_input: ['run_autoloop'],
+							approval_contract_id: 'support-autonomy-approval-approved',
+							scope_fingerprint: 'support-autonomy-approved-scope',
+							requires_same_approval_contract: true,
+							requires_same_scope_fingerprint: true,
+							can_run_without_codex_monitor: true,
+							blocks_product_repair_until_autoloop_started: true
+						},
+						can_continue_without_codex_monitor: false,
+						next_action: 'monitor_capacity_then_retry_autoloop',
+						recorded_at: '2026-06-15T01:00:21.000Z'
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autopilot-post-autostart-blocked',
+			status: 'Running',
+			phase: 'BUILD'
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }],
+			businessAssertions: [{
+				assertion: 'Synthetic business proof would otherwise pass.',
+				status: 'pass',
+				action: 'Apply support filter.',
+				expected: 'Only matching records appear.',
+				observed: 'Only matching records appeared.',
+				dataProof: 'Synthetic row proof.'
+			}]
+		}
+	});
+	assert.equal(approvedPostAutostartBlockedRun.outcome, 'manual_handoff');
+	assert.equal(approvedPostAutostartBlockedRun.gates.some((gate) => gate.key === 'support_post_approval_autostart' && gate.status === 'blocked'), true);
+	assert.equal(approvedPostAutostartBlockedRun.metadata?.postApprovalAutostart?.blocked, true);
+	assert.equal(approvedPostAutostartBlockedRun.metadata?.postApprovalAutostart?.failureClass, 'global_capacity');
+	assert.equal(approvedPostAutostartBlockedRun.metadata?.postApprovalAutostart?.blockerFingerprint, 'post-autostart-global-capacity');
+	assert.equal(approvedPostAutostartBlockedRun.metadata?.postApprovalAutostart?.approvalBoundaryValid, true);
+	assert.equal(approvedPostAutostartBlockedRun.metadata?.postApprovalAutostart?.canRetryWithoutReapproval, true);
+	assert.equal(approvedPostAutostartBlockedRun.metadata?.postApprovalAutostart?.safeRetryAction, 'run_autoloop');
+	assert.equal(approvedPostAutostartBlockedRun.metadata?.postApprovalAutostart?.resumeContract?.action, 'run_autoloop');
+	assert.equal(approvedPostAutostartBlockedRun.metadata?.postApprovalAutostart?.resumeContract?.requires_same_scope_fingerprint, true);
+	assert.equal(approvedPostAutostartBlockedRun.metadata?.postApprovalAutostart?.scopeFingerprint, 'support-autonomy-approved-scope');
+	assert.equal(approvedPostAutostartBlockedRun.metadata?.postApprovalAutostart?.activeRunId, 'support-auto-improve-run-active');
+	assert.match(String(approvedPostAutostartBlockedRun.nextAction || ''), /Retry the approved auto-improve loop/i);
+
+	const approvedPostResumeBlockedRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			...approvedAutopilotTicket,
+			_id: 'ticket-autopilot-post-resume-blocked',
+			automation: {
+				runner_console: {
+					autonomy_approval: approvedAutopilotTicket.automation.runner_console.autonomy_approval,
+					last_post_approval_autostart_contract: postApprovalAutostartContract,
+					last_post_approval_autostart: {
+						record_id: 'support-autonomy-post-approval-autostart-record-blocked-for-resume',
+						status: 'blocked',
+						contract_id: postApprovalAutostartContract.contract_id,
+						approval_contract_id: 'support-autonomy-approval-approved',
+						auto_start_enabled: true,
+						method: 'runSupportTicketAutoImproveLoopManual',
+						result_status: 'global_busy',
+						result: {
+							status: 'global_busy',
+							active_ticket_id: 'ticket-active',
+							active_run_id: 'support-auto-improve-run-active'
+						},
+						failure_class: 'global_capacity',
+						blocker_fingerprint: 'post-autostart-global-capacity',
+						blocker_reason: 'Global support runner capacity blocked post-approval autostart.',
+						approval_boundary_valid: true,
+						can_retry_without_reapproval: true,
+						safe_retry_action: 'run_autoloop',
+						resume_contract: {
+							contract_id: 'support-post-approval-autostart-resume-global-capacity',
+							action: 'run_autoloop',
+							allowed_after_input: ['run_autoloop'],
+							approval_contract_id: 'support-autonomy-approval-approved',
+							scope_fingerprint: 'support-autonomy-approved-scope',
+							requires_same_approval_contract: true,
+							requires_same_scope_fingerprint: true,
+							can_run_without_codex_monitor: true,
+							blocks_product_repair_until_autoloop_started: true
+						},
+						can_continue_without_codex_monitor: false,
+						next_action: 'monitor_capacity_then_retry_autoloop',
+						recorded_at: '2026-06-15T01:00:21.000Z'
+					},
+					last_post_approval_resume_attempt: {
+						attempt_id: 'support-post-approval-resume-blocked',
+						source: 'support_watchdog_post_approval_autostart_resume',
+						status: 'blocked',
+						action: 'run_autoloop',
+						contract_id: 'support-post-approval-autostart-resume-global-capacity',
+						approval_contract_id: 'support-autonomy-approval-approved',
+						scope_fingerprint: 'support-autonomy-approved-scope',
+						resume_contract: {
+							contract_id: 'support-post-approval-autostart-resume-global-capacity',
+							action: 'run_autoloop',
+							approval_contract_id: 'support-autonomy-approval-approved',
+							scope_fingerprint: 'support-autonomy-approved-scope',
+							can_run_without_codex_monitor: true
+						},
+						result_status: 'global_busy',
+						result: {
+							status: 'global_busy',
+							active_ticket_id: 'ticket-active',
+							active_run_id: 'support-auto-improve-run-active'
+						},
+						active_ticket_id: 'ticket-active',
+						active_run_id: 'support-auto-improve-run-active',
+						failure_class: 'global_capacity',
+						blocker_fingerprint: 'post-resume-global-capacity',
+						blocker_reason: 'Global support runner capacity still blocked approved autoloop resume.',
+						next_action: 'monitor_capacity_then_retry_autoloop',
+						can_continue_without_codex_monitor: false,
+						product_repair_allowed: false,
+						can_send_customer_reply: false,
+						recorded_at: '2026-06-15T01:00:22.000Z'
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autopilot-post-resume-blocked',
+			status: 'Running',
+			phase: 'BUILD'
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' }
+		}
+	});
+	assert.equal(approvedPostResumeBlockedRun.outcome, 'manual_handoff');
+	assert.equal(approvedPostResumeBlockedRun.gates.some((gate) => gate.key === 'support_post_approval_resume_attempt' && gate.status === 'blocked'), true);
+	assert.equal(approvedPostResumeBlockedRun.events.some((event) => event.category === 'support_post_approval_resume_attempt'), true);
+	assert.equal(approvedPostResumeBlockedRun.metadata?.postApprovalResumeAttempt?.blocked, true);
+	assert.equal(approvedPostResumeBlockedRun.metadata?.postApprovalResumeAttempt?.failureClass, 'global_capacity');
+	assert.equal(approvedPostResumeBlockedRun.metadata?.postApprovalResumeAttempt?.blockerFingerprint, 'post-resume-global-capacity');
+	assert.equal(approvedPostResumeBlockedRun.metadata?.postApprovalResumeAttempt?.productRepairAllowed, false);
+	assert.equal(approvedPostResumeBlockedRun.metadata?.postApprovalResumeAttempt?.canSendCustomerReply, false);
+	assert.match(String(approvedPostResumeBlockedRun.gates.find((gate) => gate.key === 'support_post_approval_resume_attempt')?.reason || ''), /resume/i);
+	assert.match(String(approvedPostResumeBlockedRun.nextAction || ''), /blocker fingerprint changes/i);
+
+	const approvedAutopilotIntakeChangedRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			...approvedAutopilotTicket,
+			_id: 'ticket-autopilot-intake-changed',
+			automation: {
+				runner_console: {
+					autonomy_approval: approvedAutopilotTicket.automation.runner_console.autonomy_approval,
+					last_intake_revision_contract: {
+						contract_id: 'support-intake-reapproval-scope-change',
+						status: 'approval_required',
+						requires_reapproval: true,
+						reason: 'Operator changed approval-impacting intake fields after bounded autonomy was approved; product repair is parked until reapproved.',
+						changed_fields: [{
+							field: 'issue_class',
+							previous: 'filter_query_mismatch',
+							next: 'missing_wrong_data'
+						}],
+						changed_field_names: ['issue_class'],
+						approval_impacting_edit_fields: ['classification', 'issue_class', 'route_module', 'expected_result', 'observed_result', 'affected_account_user', 'billable_policy'],
+						previous_autonomy_contract_id: 'support-autonomy-approval-approved',
+						previous_scope_fingerprint: 'scope-before',
+						next_scope_fingerprint: 'scope-after',
+						intake_scope_fingerprint: 'intake-scope-after',
+						blocks_product_repair: true,
+						blocks_auto_retry: true,
+						required_operator_action: 'approve_support_autonomy',
+						updated_by: 'operator',
+						updated_at: '2026-06-15T01:01:00.000Z'
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autopilot-intake-changed',
+			status: 'Running',
+			phase: 'BUILD'
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' }
+		}
+	});
+	assert.equal(approvedAutopilotIntakeChangedRun.outcome, 'manual_handoff');
+	assert.equal(approvedAutopilotIntakeChangedRun.gates.some((gate) => gate.key === 'support_intake_revision_contract' && gate.status === 'blocked'), true);
+	assert.equal(approvedAutopilotIntakeChangedRun.metadata?.intakeRevisionContract?.blocksProductRepair, true);
+	assert.deepEqual(approvedAutopilotIntakeChangedRun.metadata?.intakeRevisionContract?.changedFieldNames, ['issue_class']);
+	assert.match(String(approvedAutopilotIntakeChangedRun.nextAction || ''), /approve_support_autonomy/i);
+
+	const approvedAutopilotMissingClassificationRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			...approvedAutopilotTicket,
+			_id: 'ticket-autopilot-missing-classification',
+			automation: {
+				runner_console: {
+					autonomy_approval: {
+						...approvedAutopilotTicket.automation.runner_console.autonomy_approval,
+						contract_id: 'support-autonomy-missing-classification',
+						bug_not_bug: 'bug',
+						bug_not_bug_classification_approved: false
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autopilot-missing-classification',
+			status: 'Running',
+			phase: 'BUILD'
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }]
+		}
+	});
+	assert.equal(approvedAutopilotMissingClassificationRun.outcome, 'manual_handoff');
+	assert.equal(approvedAutopilotMissingClassificationRun.gates.some((gate) => gate.key === 'support_autonomy_approval' && gate.status === 'blocked'), true);
+	assert.equal(approvedAutopilotMissingClassificationRun.metadata?.autonomyApproval?.bugNotBugClassificationApproved, false);
+	assert.equal(approvedAutopilotMissingClassificationRun.metadata?.autonomyApproval?.autopilotApprovalBoundaryValid, false);
+	assert.ok(approvedAutopilotMissingClassificationRun.metadata?.autonomyApproval?.blockers?.some((blocker: string) => /Bug\/not-bug classification must be approved/i.test(blocker)));
+
+	const approvedAutopilotOverSixWithoutExplicitRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			...approvedAutopilotTicket,
+			_id: 'ticket-autopilot-over-six-without-explicit',
+			automation: {
+				runner_console: {
+					autonomy_approval: {
+						...approvedAutopilotTicket.automation.runner_console.autonomy_approval,
+						contract_id: 'support-autonomy-over-six-without-explicit',
+						estimated_hours: 7,
+						max_auto_hours_without_approval: 6,
+						over_max_auto_hours: true,
+						approve_over_six_hours: false,
+						approve_over_max_hours: false
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autopilot-over-six-without-explicit',
+			status: 'Running',
+			phase: 'BUILD'
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }]
+		}
+	});
+	assert.equal(approvedAutopilotOverSixWithoutExplicitRun.outcome, 'manual_handoff');
+	assert.equal(approvedAutopilotOverSixWithoutExplicitRun.gates.some((gate) => gate.key === 'support_autonomy_approval' && gate.status === 'blocked'), true);
+	assert.equal(approvedAutopilotOverSixWithoutExplicitRun.metadata?.autonomyApproval?.estimatedHours, 7);
+	assert.equal(approvedAutopilotOverSixWithoutExplicitRun.metadata?.autonomyApproval?.maxAutoHoursWithoutApproval, 6);
+	assert.equal(approvedAutopilotOverSixWithoutExplicitRun.metadata?.autonomyApproval?.explicitOverLimitApproval, false);
+	assert.ok(approvedAutopilotOverSixWithoutExplicitRun.metadata?.autonomyApproval?.blockers?.some((blocker: string) => /above the 6-hour autonomy ceiling/i.test(blocker)));
+
+	const approvedAutopilotOwnerDriftRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			...approvedAutopilotTicket,
+			_id: 'ticket-autopilot-owner-drift',
+			automation: {
+				runner_console: {
+					autonomy_approval: {
+						...approvedAutopilotTicket.automation.runner_console.autonomy_approval,
+						contract_id: 'support-autonomy-owner-drift',
+						owner_files: ['server/src/publications/support-tickets.ts', 'server/src/methods/unapproved-scope.ts'],
+						current_owner_files: ['server/src/publications/support-tickets.ts', 'server/src/methods/unapproved-scope.ts'],
+						approved_owner_files: ['server/src/publications/support-tickets.ts']
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autopilot-owner-drift',
+			status: 'Running',
+			phase: 'BUILD'
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }]
+		}
+	});
+	assert.equal(approvedAutopilotOwnerDriftRun.outcome, 'manual_handoff');
+	assert.equal(approvedAutopilotOwnerDriftRun.gates.some((gate) => gate.key === 'support_autonomy_approval' && gate.status === 'blocked'), true);
+	assert.equal(approvedAutopilotOwnerDriftRun.metadata?.autonomyApproval?.ownerFilesChangedSinceApproval, true);
+	assert.equal(approvedAutopilotOwnerDriftRun.metadata?.autonomyApproval?.approvedOwnerFileSetChanged, true);
+	assert.deepEqual(approvedAutopilotOwnerDriftRun.metadata?.autonomyApproval?.ownerFilesAddedSinceApproval, ['server/src/methods/unapproved-scope.ts']);
+
+	const approvedAutopilotScopeFingerprintDriftRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			...approvedAutopilotTicket,
+			_id: 'ticket-autopilot-scope-fingerprint-drift',
+			automation: {
+				runner_console: {
+					autonomy_approval: {
+						...approvedAutopilotTicket.automation.runner_console.autonomy_approval,
+						contract_id: 'support-autonomy-scope-fingerprint-drift',
+						scope_fingerprint: 'current-scope-fingerprint',
+						previous_scope_fingerprint: 'approved-scope-fingerprint'
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autopilot-scope-fingerprint-drift',
+			status: 'Running',
+			phase: 'BUILD'
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }]
+		}
+	});
+	assert.notEqual(approvedAutopilotScopeFingerprintDriftRun.outcome, 'manual_handoff');
+	assert.equal(approvedAutopilotScopeFingerprintDriftRun.gates.some((gate) => gate.key === 'support_autonomy_approval' && gate.status === 'blocked'), false);
+	assert.equal(approvedAutopilotScopeFingerprintDriftRun.metadata?.autonomyApproval?.scopeChangedSinceApproval, false);
+	assert.equal(approvedAutopilotScopeFingerprintDriftRun.metadata?.autonomyApproval?.previousScopeFingerprint, 'approved-scope-fingerprint');
+	assert.equal(approvedAutopilotScopeFingerprintDriftRun.metadata?.autonomyApproval?.blockers?.some((blocker: string) => /support scope changed/i.test(blocker)), false);
+
+	const approvedAutopilotRepairIntentOnlyBlockRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			...approvedAutopilotTicket,
+			_id: 'ticket-autopilot-repair-intent-only-block',
+			automation: {
+				runner_console: {
+					autonomy_approval: approvedAutopilotTicket.automation.runner_console.autonomy_approval,
+					product_repair_dispatch_guard: {
+						status: 'allowed',
+						allowed: true,
+						action: 'run_owner_scoped_repair',
+						next_action: 'run_business_proof_qa',
+						reason: 'Approved support autonomy allows this owner-scoped bug repair.',
+						owner_files: ['server/src/publications/support-tickets.ts'],
+						approved_owner_files: ['server/src/publications/support-tickets.ts']
+					},
+					last_autoloop_approval_block: {
+						status: 'blocked_autonomy_approval_required',
+						decision_kind: 'repair_intent_required',
+						requires_repair_intent: true,
+						reason: 'Support autonomy approval required before product-code repair: repair_intent_required_before_product_repair',
+						target_grade: 'A',
+						required_terminal_state: 'A-grade PR with QA screenshots, AIQaBusinessAssertion before/action/after proof, source commit proof, and changed files inside owner_files',
+						blockers: ['Autoloop is parked until planned implementation intent is defined.']
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autopilot-repair-intent-only-block',
+			status: 'Running',
+			phase: 'BUILD'
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }]
+		}
+	});
+	const repairIntentOnlyGate = approvedAutopilotRepairIntentOnlyBlockRun.gates.find((gate) => gate.key === 'support_autoloop_approval_block');
+	assert.notEqual(approvedAutopilotRepairIntentOnlyBlockRun.outcome, 'manual_handoff');
+	assert.equal(repairIntentOnlyGate?.status, 'warn');
+	assert.equal(repairIntentOnlyGate?.metadata?.staleRepairIntentOnlyBlockDowngraded, true);
+	assert.equal(approvedAutopilotRepairIntentOnlyBlockRun.gates.some((gate) => gate.key === 'support_autonomy_approval' && gate.status === 'blocked'), false);
+
+	const approvedAutopilotDiagnosisFingerprintDriftRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			...approvedAutopilotTicket,
+			_id: 'ticket-autopilot-diagnosis-fingerprint-drift',
+			automation: {
+				runner_console: {
+					autonomy_approval: {
+						...approvedAutopilotTicket.automation.runner_console.autonomy_approval,
+						contract_id: 'support-autonomy-diagnosis-fingerprint-drift',
+						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']
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autopilot-diagnosis-fingerprint-drift',
+			status: 'Running',
+			phase: 'BUILD'
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }]
+		}
+	});
+	assert.equal(approvedAutopilotDiagnosisFingerprintDriftRun.outcome, 'manual_handoff');
+	assert.equal(approvedAutopilotDiagnosisFingerprintDriftRun.gates.some((gate) => gate.key === 'support_autonomy_approval' && gate.status === 'blocked'), true);
+	assert.equal(approvedAutopilotDiagnosisFingerprintDriftRun.metadata?.autonomyApproval?.diagnosisScopeChangedSinceApproval, true);
+	assert.equal(approvedAutopilotDiagnosisFingerprintDriftRun.metadata?.autonomyApproval?.previousDiagnosisScopeFingerprint, 'approved-diagnosis-proof-plan');
+	assert.deepEqual(approvedAutopilotDiagnosisFingerprintDriftRun.metadata?.autonomyApproval?.diagnosisScopeFields, ['issue_case', 'accepted_hypothesis', 'failing_path', 'proof_plan']);
+	assert.ok(approvedAutopilotDiagnosisFingerprintDriftRun.metadata?.autonomyApproval?.blockers?.some((blocker: string) => /diagnosis\/proof scope changed/i.test(blocker)));
+
+	const prReadyNoPrContract = {
+		contract_id: 'support-pr-readiness-ready-no-pr',
+		status: 'ready',
+		ready: true,
+		reason: 'Business proof is ready and PR packaging can run.',
+		action: 'create_pr',
+		dispatch_action: 'create_pr',
+		method: 'createSupportTicketCodexPullRequestManual',
+		business_proof_ready: true,
+		diagnosis_valid: true,
+		job_phase: 'COMPLETE',
+		job_id: 'support-job-autopilot-approved',
+		pull_request_url: '',
+		pull_request_status: '',
+		passed_business_assertion_count: 1,
+		business_proof_artifacts: ['qa-artifacts/support-before-after-proof.png'],
+		modified_files: ['server/src/publications/support-tickets.ts'],
+		required_evidence: ['AIQaBusinessAssertion status=pass mapped to diagnosis proof_plan'],
+		next_action_after_pr: 'review_a_grade_pr_and_release_gate',
+		target_grade: 'A',
+		merge_blocked_until_human_approval: true,
+		customer_reply_blocked_until_release_gate: true,
+		release_blocked_until_pr_review: true
+	};
+	const approvedAutopilotNoPrRun = buildSupportAIRunFromEvidence({
+		ticket: approvedAutopilotTicket,
+		job: {
+			_id: 'support-job-autopilot-approved',
+			status: 'Closed',
+			phase: 'COMPLETE',
+			support_pr_readiness_contract: prReadyNoPrContract
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }],
+			businessAssertions: [{
+				assertion: 'The wrong-customer ticket is absent after filtering.',
+				status: 'pass',
+				before: 'Customer A ticket appears while filtered to Customer B.',
+				action: 'Apply the Customer B filter.',
+				expected: 'Only Customer B tickets are listed.',
+				observed: 'Only Customer B tickets are listed.',
+				dataProof: 'Every returned ticket row has customerId equal to Customer B.',
+				artifactPaths: ['qa-artifacts/support-before-after-proof.png'],
+				metadata: { supportDiagnosisProof: true }
+			}],
+			scorecardPassed: true
+		}
+	});
+	assert.equal(approvedAutopilotNoPrRun.outcome, 'release_blocked');
+	assert.equal(approvedAutopilotNoPrRun.gates.some((gate) => gate.key === 'support_pr_readiness_contract' && gate.status === 'pass'), true);
+	assert.equal(approvedAutopilotNoPrRun.gates.some((gate) => gate.key === 'support_autopilot_completion_contract' && gate.status === 'blocked'), true);
+	assert.equal(approvedAutopilotNoPrRun.metadata?.autopilotCompletion?.nextAction, 'create_pr');
+	assert.equal(approvedAutopilotNoPrRun.metadata?.autopilotCompletion?.businessProofReady, true);
+	assert.equal(approvedAutopilotNoPrRun.metadata?.autopilotCompletion?.hasScreenshotOrTrace, true);
+	assert.equal(approvedAutopilotNoPrRun.metadata?.prReadinessContract?.ready, true);
+	assert.equal(approvedAutopilotNoPrRun.metadata?.prReadinessContract?.mergeBlockedUntilHumanApproval, true);
+
+	const approvedAutopilotWithPrRun = buildSupportAIRunFromEvidence({
+		ticket: approvedAutopilotTicket,
+		job: {
+			_id: 'support-job-autopilot-approved-with-pr',
+			status: 'Closed',
+			phase: 'COMPLETE',
+			support_pr_readiness_contract: {
+				...prReadyNoPrContract,
+				contract_id: 'support-pr-readiness-ready-with-pr',
+				job_id: 'support-job-autopilot-approved-with-pr',
+				pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4601',
+				pull_request_status: 'OPEN'
+			}
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }],
+			businessAssertions: [{
+				assertion: 'The wrong-customer ticket is absent after filtering.',
+				status: 'pass',
+				before: 'Customer A ticket appears while filtered to Customer B.',
+				action: 'Apply the Customer B filter.',
+				expected: 'Only Customer B tickets are listed.',
+				observed: 'Only Customer B tickets are listed.',
+				dataProof: 'Every returned ticket row has customerId equal to Customer B.',
+				artifactPaths: ['qa-artifacts/support-before-after-proof.png'],
+				metadata: { supportDiagnosisProof: true }
+			}],
+			scorecardPassed: true
+		}
+	});
+	assert.equal(approvedAutopilotWithPrRun.outcome, 'false_pass');
+	assert.equal(approvedAutopilotWithPrRun.gates.some((gate) => gate.key === 'support_autopilot_completion_contract' && gate.status === 'blocked'), true);
+	assert.equal(approvedAutopilotWithPrRun.metadata?.autopilotCompletion?.nextAction, 'run_a_grade_pr_review');
+	assert.equal(approvedAutopilotWithPrRun.metadata?.autopilotCompletion?.pullRequestUrl, 'https://github.com/resolveio/resolveio-all/pull/4601');
+	assert.equal(approvedAutopilotWithPrRun.metadata?.autopilotCompletion?.prReviewReady, false);
+	assert.ok(approvedAutopilotWithPrRun.metadata?.autopilotCompletion?.missingCompletionEvidence?.some((entry: string) => /A-grade execution\/artifacts\/pull_request review/i.test(entry)));
+
+	const approvedAutopilotBlockedPrReviewRun = buildSupportAIRunFromEvidence({
+		ticket: approvedAutopilotTicket,
+		job: {
+			_id: 'support-job-autopilot-blocked-pr-review',
+			status: 'Closed',
+			phase: 'COMPLETE',
+			support_pr_readiness_contract: {
+				...prReadyNoPrContract,
+				contract_id: 'support-pr-readiness-blocked-pr-review',
+				job_id: 'support-job-autopilot-blocked-pr-review',
+				pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4601',
+				pull_request_status: 'OPEN'
+			},
+			support_pr_review_contract: {
+				contract_id: 'support-pr-review-blocked-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: {
+					contract_id: 'support-pr-review-blocked-business-proof-continuation',
+					status: 'blocked',
+					action: 'run_business_proof_qa',
+					failure_class: 'business_proof',
+					blocker_fingerprint: 'bf-business-proof',
+					evidence_hash: 'ev-business-proof',
+					required_evidence: ['fresh AIQaBusinessAssertion status=pass'],
+					reset_evidence_required: ['changed evidence_hash'],
+					stop_conditions: ['Stop if the same failure repeats without material evidence.'],
+					can_run_without_codex_monitor: true,
+					product_repair_allowed: false,
+					release_customer_side_effects_allowed: false
+				}
+			}
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }],
+			businessAssertions: [{
+				assertion: 'The wrong-customer ticket is absent after filtering.',
+				status: 'pass',
+				before: 'Customer A ticket appears while filtered to Customer B.',
+				action: 'Apply the Customer B filter.',
+				expected: 'Only Customer B tickets are listed.',
+				observed: 'Only Customer B tickets are listed.',
+				dataProof: 'Every returned ticket row has customerId equal to Customer B.',
+				artifactPaths: ['qa-artifacts/support-before-after-proof.png'],
+				metadata: { supportDiagnosisProof: true }
+			}],
+			scorecardPassed: true
+		}
+	});
+	assert.equal(approvedAutopilotBlockedPrReviewRun.outcome, 'false_pass');
+	assert.equal(approvedAutopilotBlockedPrReviewRun.metadata?.prReviewContract?.failureClass, 'business_proof');
+	assert.equal(approvedAutopilotBlockedPrReviewRun.metadata?.prReviewContract?.blockerFingerprint, 'bf-business-proof');
+	assert.equal(approvedAutopilotBlockedPrReviewRun.metadata?.prReviewContract?.evidenceHash, 'ev-business-proof');
+	assert.equal(approvedAutopilotBlockedPrReviewRun.metadata?.prReviewContract?.continuationContract?.action, 'run_business_proof_qa');
+
+	const approvedAutopilotReviewedPrRun = buildSupportAIRunFromEvidence({
+		ticket: approvedAutopilotTicket,
+		job: {
+			_id: 'support-job-autopilot-approved-reviewed-pr',
+			status: 'Closed',
+			phase: 'COMPLETE',
+			support_pr_readiness_contract: {
+				...prReadyNoPrContract,
+				contract_id: 'support-pr-readiness-ready-reviewed-pr',
+				job_id: 'support-job-autopilot-approved-reviewed-pr',
+				pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4601',
+				pull_request_status: 'OPEN'
+			},
+			support_pr_review_contract: {
+				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/4601',
+				evidence_refs: ['qa-artifacts/support-before-after-proof.png']
+			}
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }],
+			businessAssertions: [{
+				assertion: 'The wrong-customer ticket is absent after filtering.',
+				status: 'pass',
+				before: 'Customer A ticket appears while filtered to Customer B.',
+				action: 'Apply the Customer B filter.',
+				expected: 'Only Customer B tickets are listed.',
+				observed: 'Only Customer B tickets are listed.',
+				dataProof: 'Every returned ticket row has customerId equal to Customer B.',
+				artifactPaths: ['qa-artifacts/support-before-after-proof.png'],
+				metadata: { supportDiagnosisProof: true }
+			}],
+			scorecardPassed: true
+		}
+	});
+	assert.equal(approvedAutopilotReviewedPrRun.outcome, 'release_blocked');
+	assert.equal(approvedAutopilotReviewedPrRun.gates.some((gate) => gate.key === 'support_pr_review_contract' && gate.status === 'pass'), true);
+	assert.equal(approvedAutopilotReviewedPrRun.gates.some((gate) => gate.key === 'support_autopilot_completion_contract' && gate.status === 'pass'), true);
+	assert.equal(approvedAutopilotReviewedPrRun.gates.some((gate) => gate.key === 'support_release_customer_acceptance' && gate.status === 'blocked'), true);
+	assert.equal(approvedAutopilotReviewedPrRun.metadata?.autopilotCompletion?.prReviewReady, true);
+	assert.equal(approvedAutopilotReviewedPrRun.metadata?.releaseCustomerAcceptance?.releaseReady, false);
+	assert.equal(approvedAutopilotReviewedPrRun.metadata?.releaseCustomerAcceptance?.customerReplyReady, false);
+
+	const approvedAutopilotReleasedRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			...approvedAutopilotTicket,
+			automation: {
+				...approvedAutopilotTicket.automation,
+				release: {
+					push_master: {
+						status: 'completed',
+						pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4601',
+						merge_sha: 'abc123'
+					},
+					deploy_production: {
+						status: 'completed',
+						last_deploy_pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4601',
+						last_deploy_source_sha: 'abc123'
+					}
+				},
+				customer_reply_policy: {
+					readiness_contract: {
+						contractId: 'support-customer-reply-released',
+						status: 'draft_ready',
+						policyAction: 'draft_resolution_reply',
+						pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4601',
+						canDraftCustomerReply: true,
+						canSendCustomerReply: false,
+						requiresHumanApproval: true,
+						proofBacked: true,
+						businessProofReady: true,
+						releaseReady: true,
+						diagnosisReady: true,
+						issueClassProbePlanReady: true,
+						evidenceRefs: ['qa-artifacts/support-before-after-proof.png'],
+						requiredEvidence: ['AIQaBusinessAssertion status=pass']
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autopilot-approved-released',
+			status: 'Closed',
+			phase: 'COMPLETE',
+			support_pr_readiness_contract: {
+				...prReadyNoPrContract,
+				contract_id: 'support-pr-readiness-ready-released',
+				job_id: 'support-job-autopilot-approved-released',
+				pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4601',
+				pull_request_status: 'MERGED'
+			},
+			support_pr_review_contract: {
+				contract_id: 'support-pr-review-released-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/4601',
+				evidence_refs: ['qa-artifacts/support-before-after-proof.png']
+			}
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }],
+			businessAssertions: [{
+				assertion: 'The wrong-customer ticket is absent after filtering.',
+				status: 'pass',
+				before: 'Customer A ticket appears while filtered to Customer B.',
+				action: 'Apply the Customer B filter.',
+				expected: 'Only Customer B tickets are listed.',
+				observed: 'Only Customer B tickets are listed.',
+				dataProof: 'Every returned ticket row has customerId equal to Customer B.',
+				artifactPaths: ['qa-artifacts/support-before-after-proof.png'],
+				metadata: { supportDiagnosisProof: true }
+			}],
+			scorecardPassed: true
+		}
+	});
+	assert.equal(approvedAutopilotReleasedRun.outcome, 'accepted');
+	assert.equal(approvedAutopilotReleasedRun.gates.some((gate) => gate.key === 'support_release_customer_acceptance' && gate.status === 'pass'), true);
+	assert.equal(approvedAutopilotReleasedRun.metadata?.releaseCustomerAcceptance?.releaseReady, true);
+	assert.equal(approvedAutopilotReleasedRun.metadata?.releaseCustomerAcceptance?.customerReplyReady, true);
+	assert.equal(approvedAutopilotReleasedRun.metadata?.releaseCustomerAcceptance?.replyPrReferencePresent, true);
+
+	const approvedAutopilotMissingReplyPrRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			...approvedAutopilotTicket,
+			automation: {
+				...approvedAutopilotTicket.automation,
+				release: {
+					push_master: {
+						status: 'completed',
+						pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4601',
+						merge_sha: 'abc123'
+					},
+					deploy_production: {
+						status: 'completed',
+						last_deploy_pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4601',
+						last_deploy_source_sha: 'abc123'
+					}
+				},
+				customer_reply_policy: {
+					readiness_contract: {
+						contractId: 'support-customer-reply-missing-reply-pr',
+						status: 'draft_ready',
+						policyAction: 'draft_resolution_reply',
+						canDraftCustomerReply: true,
+						canSendCustomerReply: false,
+						requiresHumanApproval: true,
+						proofBacked: true,
+						businessProofReady: true,
+						releaseReady: true,
+						diagnosisReady: true,
+						issueClassProbePlanReady: true,
+						evidenceRefs: ['qa-artifacts/support-before-after-proof.png'],
+						requiredEvidence: ['AIQaBusinessAssertion status=pass']
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autopilot-missing-reply-pr',
+			status: 'Closed',
+			phase: 'COMPLETE',
+			support_pr_readiness_contract: {
+				...prReadyNoPrContract,
+				contract_id: 'support-pr-readiness-missing-reply-pr',
+				job_id: 'support-job-autopilot-missing-reply-pr',
+				pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4601',
+				pull_request_status: 'MERGED'
+			},
+			support_pr_review_contract: {
+				contract_id: 'support-pr-review-missing-reply-pr-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/4601',
+				evidence_refs: ['qa-artifacts/support-before-after-proof.png']
+			}
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }],
+			businessAssertions: [{
+				assertion: 'The wrong-customer ticket is absent after filtering.',
+				status: 'pass',
+				before: 'Customer A ticket appears while filtered to Customer B.',
+				action: 'Apply the Customer B filter.',
+				expected: 'Only Customer B tickets are listed.',
+				observed: 'Only Customer B tickets are listed.',
+				dataProof: 'Every returned ticket row has customerId equal to Customer B.',
+				artifactPaths: ['qa-artifacts/support-before-after-proof.png'],
+				metadata: { supportDiagnosisProof: true }
+			}],
+			scorecardPassed: true
+		}
+	});
+	assert.equal(approvedAutopilotMissingReplyPrRun.outcome, 'release_blocked');
+	assert.equal(approvedAutopilotMissingReplyPrRun.gates.some((gate) => gate.key === 'support_release_customer_acceptance' && gate.status === 'blocked'), true);
+	assert.equal(approvedAutopilotMissingReplyPrRun.metadata?.releaseCustomerAcceptance?.releaseReady, true);
+	assert.equal(approvedAutopilotMissingReplyPrRun.metadata?.releaseCustomerAcceptance?.replyPrReferencePresent, false);
+	assert.equal(approvedAutopilotMissingReplyPrRun.metadata?.releaseCustomerAcceptance?.customerReplyReady, false);
+	assert.ok(approvedAutopilotMissingReplyPrRun.metadata?.releaseCustomerAcceptance?.blockers?.some((blocker: string) => /missing the current PR reference/i.test(blocker)));
+
+	const approvedAutopilotStaleReleaseRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			...approvedAutopilotTicket,
+			automation: {
+				...approvedAutopilotTicket.automation,
+				release: {
+					push_master: {
+						status: 'completed',
+						pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4601',
+						merge_sha: 'old-sha'
+					},
+					deploy_production: {
+						status: 'completed',
+						last_deploy_pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4601',
+						last_deploy_source_sha: 'old-sha'
+					}
+				},
+				customer_reply_policy: {
+					readiness_contract: {
+						contractId: 'support-customer-reply-stale-release',
+						status: 'draft_ready',
+						policyAction: 'draft_resolution_reply',
+						pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4602',
+						canDraftCustomerReply: true,
+						canSendCustomerReply: false,
+						requiresHumanApproval: true,
+						proofBacked: true,
+						businessProofReady: true,
+						releaseReady: true,
+						diagnosisReady: true,
+						issueClassProbePlanReady: true,
+						evidenceRefs: ['qa-artifacts/support-before-after-proof.png'],
+						requiredEvidence: ['AIQaBusinessAssertion status=pass']
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autopilot-stale-release',
+			status: 'Closed',
+			phase: 'COMPLETE',
+			support_pr_readiness_contract: {
+				...prReadyNoPrContract,
+				contract_id: 'support-pr-readiness-stale-release',
+				job_id: 'support-job-autopilot-stale-release',
+				pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4602',
+				pull_request_status: 'OPEN'
+			},
+			support_pr_review_contract: {
+				contract_id: 'support-pr-review-stale-release-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/4602',
+				evidence_refs: ['qa-artifacts/support-before-after-proof.png']
+			}
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }],
+			businessAssertions: [{
+				assertion: 'The wrong-customer ticket is absent after filtering.',
+				status: 'pass',
+				before: 'Customer A ticket appears while filtered to Customer B.',
+				action: 'Apply the Customer B filter.',
+				expected: 'Only Customer B tickets are listed.',
+				observed: 'Only Customer B tickets are listed.',
+				dataProof: 'Every returned ticket row has customerId equal to Customer B.',
+				artifactPaths: ['qa-artifacts/support-before-after-proof.png'],
+				metadata: { supportDiagnosisProof: true }
+			}],
+			scorecardPassed: true
+		}
+	});
+	assert.equal(approvedAutopilotStaleReleaseRun.outcome, 'release_blocked');
+	assert.equal(approvedAutopilotStaleReleaseRun.gates.some((gate) => gate.key === 'support_release_customer_acceptance' && gate.status === 'blocked'), true);
+	assert.equal(approvedAutopilotStaleReleaseRun.metadata?.releaseCustomerAcceptance?.releaseReady, false);
+	assert.equal(approvedAutopilotStaleReleaseRun.metadata?.releaseCustomerAcceptance?.releasePrMatchesCurrent, false);
+	assert.equal(approvedAutopilotStaleReleaseRun.metadata?.releaseCustomerAcceptance?.deployPrMatchesCurrent, false);
+	assert.ok(approvedAutopilotStaleReleaseRun.metadata?.releaseCustomerAcceptance?.blockers?.some((blocker: string) => /different PR/i.test(blocker)));
+
+	const failedPrCreationRun = buildSupportAIRunFromEvidence({
+		ticket: {
+			...approvedAutopilotTicket,
+			automation: {
+				...approvedAutopilotTicket.automation,
+				codex: {
+					status: 'failed',
+					pull_request_status: 'failed',
+					pull_request_url: '',
+					error: 'Automatic PR creation failed: GitHub branch protection rejected the generated branch.'
+				},
+				release: {
+					push_master: {
+						status: 'pending_manual',
+						notes: 'Automatic PR creation failed: GitHub branch protection rejected the generated branch.'
+					}
+				}
+			}
+		},
+		job: {
+			_id: 'support-job-autopilot-pr-failed',
+			status: 'Closed',
+			phase: 'COMPLETE',
+			pullRequestStatus: 'FAILED',
+			pullRequestError: 'Automatic PR creation failed: GitHub branch protection rejected the generated branch.',
+			support_pr_readiness_contract: {
+				...prReadyNoPrContract,
+				contract_id: 'support-pr-readiness-failed-pr',
+				status: 'blocked',
+				ready: false,
+				job_id: 'support-job-autopilot-pr-failed',
+				pr_failure_status: 'FAILED',
+				blockers: ['Previous PR creation failed (FAILED).']
+			}
+		},
+		qaEvidence: {
+			infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+			compile: { status: 'pass' },
+			routeProbes: [{ route: '/support/004601', status: 'pass', screenshot: 'qa-artifacts/support-route.png' }],
+			businessAssertions: [{
+				assertion: 'The wrong-customer ticket is absent after filtering.',
+				status: 'pass',
+				before: 'Customer A ticket appears while filtered to Customer B.',
+				action: 'Apply the Customer B filter.',
+				expected: 'Only Customer B tickets are listed.',
+				observed: 'Only Customer B tickets are listed.',
+				dataProof: 'Every returned ticket row has customerId equal to Customer B.',
+				artifactPaths: ['qa-artifacts/support-before-after-proof.png'],
+				metadata: { supportDiagnosisProof: true }
+			}],
+			scorecardPassed: true
+		}
+	});
+	assert.equal(failedPrCreationRun.outcome, 'release_blocked');
+	assert.equal(failedPrCreationRun.gates.some((gate) => gate.key === 'support_pr_creation_result' && gate.status === 'fail'), true);
+	assert.equal(failedPrCreationRun.events.some((event) => event.category === 'support_pr_creation_result'), true);
+	assert.equal(failedPrCreationRun.metadata?.prCreationResult?.nextAction, 'repair_pr_creation_blocker');
+	assert.equal(failedPrCreationRun.metadata?.prCreationResult?.pullRequestStatus, 'failed');
+	assert.equal(failedPrCreationRun.metadata?.prCreationResult?.businessProofReady, true);
+
+	const supportRecoveryExecutionProofRun = buildSupportAIRunFromEvidence({
+		ticket: { _id: 'ticket-recovery-proof', ticketNumber: '004500', title: 'Recovery proof' },
+		job: {
+			_id: 'support-job-recovery-proof',
+			status: 'Running',
+			phase: 'REVIEW'
+		},
+		qaEvidence: {
+			managerRecoveryExecutionProof: {
+				contractId: 'mgr-execution-proof-1',
+				directiveId: 'mgr-directive-1',
+				surface: 'resolveio_support_runner',
+				dispatchAction: 'run_evidence_probe',
+				phase: 'evidence',
+				status: 'proof_ready',
+				canContinueRun: true,
+				canRunProductRepair: false,
+				canRunExpensiveModel: false,
+				canResetLoopBudget: true,
+				proofRequiredBeforeContinuation: true,
+				requiresNewEvidence: true,
+				newEvidence: true,
+				materialEvidence: true,
+				evidenceStrength: 'material',
+				evidenceSignals: ['evidence_hash_changed', 'artifact_paths_added'],
+				startingFailureClass: 'product_code',
+				startingBlockerFingerprint: 'before-fp',
+				startingEvidenceHash: 'before-hash',
+				latestFailureClass: 'product_code',
+				latestBlockerFingerprint: 'after-fp',
+				latestEvidenceHash: 'after-hash',
+				requiredEvidence: ['fresh issue-class probe artifact'],
+				missingEvidence: [],
+				artifactPaths: ['qa/recovery-after-dom-trace.json'],
+				changedFiles: [],
+				blockers: [],
+				nextAllowedAction: 'continue_gate',
+				forbiddenActions: ['Do not continue product-code repair until recovery execution proof is proof_ready.'],
+				createdAt: '2026-06-15T00:04:00.000Z'
+			}
+		}
+	});
+	const recoveryProofGate = supportRecoveryExecutionProofRun.gates.find((gate) => gate.key === 'manager_recovery_execution_proof');
+	assert.equal(recoveryProofGate?.status, 'pass');
+	assert.equal(supportRecoveryExecutionProofRun.events.some((event) => event.category === 'manager_recovery_execution_proof'), true);
+	assert.equal(supportRecoveryExecutionProofRun.metadata?.managerRecoveryExecutionProof?.canContinueRun, true);
+	assert.equal(supportRecoveryExecutionProofRun.metadata?.managerRecoveryExecutionProof?.canResetLoopBudget, true);
+
+	const supportBlockedRecoveryExecutionProofRun = buildSupportAIRunFromEvidence({
+		ticket: { _id: 'ticket-recovery-proof-blocked', ticketNumber: '004501', title: 'Recovery proof blocked' },
+		job: {
+			_id: 'support-job-recovery-proof-blocked',
+			status: 'Blocked',
+			phase: 'REVIEW',
+			managerRecoveryExecutionProof: {
+				contractId: 'mgr-execution-proof-2',
+				directiveId: 'mgr-directive-2',
+				surface: 'resolveio_support_runner',
+				dispatchAction: 'run_evidence_probe',
+				phase: 'evidence',
+				status: 'blocked_same_evidence',
+				canContinueRun: false,
+				canRunProductRepair: false,
+				canRunExpensiveModel: false,
+				canResetLoopBudget: false,
+				proofRequiredBeforeContinuation: true,
+				requiresNewEvidence: true,
+				newEvidence: false,
+				materialEvidence: false,
+				evidenceStrength: 'none',
+				evidenceSignals: [],
+				startingFailureClass: 'product_code',
+				startingBlockerFingerprint: 'same-fp',
+				startingEvidenceHash: 'same-hash',
+				latestFailureClass: 'product_code',
+				latestBlockerFingerprint: 'same-fp',
+				latestEvidenceHash: 'same-hash',
+				requiredEvidence: ['fresh issue-class probe artifact'],
+				missingEvidence: ['fresh issue-class probe artifact'],
+				artifactPaths: ['qa/recovery-before-dom-trace.json'],
+				changedFiles: [],
+				blockers: ['recovery_execution_same_evidence_after_dispatch'],
+				nextAllowedAction: 'collect_required_recovery_proof',
+				forbiddenActions: ['Do not continue product-code repair until recovery execution proof is proof_ready.'],
+				createdAt: '2026-06-15T00:05:00.000Z'
+			}
+		}
+	});
+	const blockedRecoveryProofGate = supportBlockedRecoveryExecutionProofRun.gates.find((gate) => gate.key === 'manager_recovery_execution_proof');
+	assert.equal(blockedRecoveryProofGate?.status, 'blocked');
+	assert.equal(supportBlockedRecoveryExecutionProofRun.metadata?.managerRecoveryExecutionProof?.canContinueRun, false);
+	assert.deepEqual(supportBlockedRecoveryExecutionProofRun.metadata?.managerRecoveryExecutionProof?.missingEvidence, ['fresh issue-class probe artifact']);
+
+	const supportAcceptedDiagnosisGate = {
+	issue_case: {
+		customer_complaint: 'Support ticket list shows tickets from the wrong customer after applying a customer filter.',
+		expected_result: 'Only tickets for Customer B should appear when Customer B is selected.',
+		observed_result: 'A Customer A ticket remains visible while filtered to Customer B.',
+		route_module: '/support tickets list',
+		account_customer_context: 'Support admin reviewing ticket 004430 for Customer B.',
+		reproduction_status: 'reproduced'
+	},
+	issue_class: 'filter_query_mismatch',
+	status: 'passed',
+	accepted_hypothesis: {
+		statement: 'The ticket list query ignores the customer filter.',
+		falsifiable_test: 'Apply the Customer B filter and verify every returned row belongs to Customer B.',
+		evidence: ['QA artifact shows Customer A ticket visible while Customer B filter is active.']
+	},
+	rejected_alternatives: [
+		'Frontend select state was rejected because the network payload includes the selected Customer B filter.',
+		'Authentication was rejected because the support admin can load the ticket list route.'
+	],
+	failing_path: {
+		frontend: 'Support ticket customer filter submits selected customer id.',
+		backend: 'server/src/publications/support-tickets.ts ticket list publication',
+		data_query: 'Mongo ticket query does not constrain by selected customer id.',
+		description: 'Filter input reaches the backend, but the publication query returns rows outside the selected customer.'
+	},
+	owner_files: ['server/src/publications/support-tickets.ts'],
+	proof_plan: {
+		before: 'Customer A ticket appears while filtered to Customer B.',
+		action: 'Apply the Customer B filter and reload the ticket list.',
+		after: 'Only Customer B tickets are listed.',
+		business_assertion: 'The wrong-customer ticket is absent after filtering.',
+		data_assertion: 'Every returned ticket row has customerId equal to Customer B.',
+		artifact_expectation: 'QA stores before/action/after row snapshots and the filtered publication payload.',
+		business_proof_contract: {
+			issue_class: 'filter_query_mismatch',
+			setup_state: 'Seed or select one Customer A ticket and one Customer B ticket.',
+			action_under_test: 'Apply the Customer B filter on the support ticket list.',
+			expected_business_state_change: 'Rows outside Customer B are excluded while Customer B rows remain visible.',
+			prohibited_false_pass: 'Route load or non-empty table without row/customer proof.',
+			proof_artifacts: ['qa-artifacts/support-filter-before-after.json', 'qa-artifacts/support-filter-payload.json'],
+			data_or_dom_assertion: 'DOM rows and publication payload contain only Customer B ticket ids.'
+		}
+	},
+	evidence: [{
+		type: 'ticket',
+		summary: 'Ticket 004430 reports wrong-customer tickets appearing after a customer filter is applied.'
+	}, {
+		type: 'qa',
+		summary: 'Browser QA reproduced Customer A ticket visible while Customer B filter was active.',
+		artifactPath: 'qa-artifacts/support-filter-reproduction.json'
+	}, {
+		type: 'code',
+		summary: 'Publication owner file contains the query that returns support ticket rows.'
+	}]
+};
+
+const supportBadProbePlanRun = buildSupportAIRunFromEvidence({
+	ticket: {
+		_id: 'ticket-bad-probe-plan',
+		ticketNumber: '004424',
+		title: 'Bad probe plan cannot be accepted',
+		accepted: true,
+		status: 'Resolved'
+	},
+	job: {
+		_id: 'support-job-bad-probe-plan',
+		status: 'Resolved',
+		phase: 'QA',
+		supportV5DiagnosisGate: {
+			issue_case: {
+				customer_complaint: 'Support ticket list shows tickets from the wrong customer after applying a customer filter.',
+				expected_result: 'Only tickets for Customer B should appear when Customer B is selected.',
+				observed_result: 'A Customer A ticket remains visible while filtered to Customer B.',
+				route_module: '/support tickets list',
+				account_customer_context: 'Support admin reviewing ticket 004424 for Customer B.',
+				reproduction_status: 'reproduced'
+			},
+			issue_class: 'filter_query_mismatch',
+			status: 'passed',
+			accepted_hypothesis: {
+				statement: 'The ticket list query ignores the customer filter.',
+				falsifiable_test: 'Apply the Customer B filter and verify every returned row belongs to Customer B.',
+				evidence: ['QA artifact shows Customer A ticket visible while Customer B filter is active.']
+			},
+			rejected_alternatives: [
+				'Frontend select state was rejected because the network payload includes the selected Customer B filter.',
+				'Auth was rejected because the support admin can load the ticket list route.'
+			],
+			failing_path: {
+				frontend: 'Support ticket customer filter submits selected customer id.',
+				backend: 'server/src/publications/support-tickets.ts ticket list publication',
+				data_query: 'Mongo ticket query does not constrain by selected customer id.',
+				description: 'Filter input reaches the backend, but the publication query returns rows outside the selected customer.'
+			},
+			owner_files: ['server/src/publications/support-tickets.ts'],
+			proof_plan: {
+				before: 'Customer A ticket appears while filtered to Customer B.',
+				action: 'Apply the Customer B filter and reload the ticket list.',
+				after: 'Only Customer B tickets are listed.',
+				business_assertion: 'The wrong-customer ticket is absent after filtering.',
+				data_assertion: 'Every returned ticket row has customerId equal to Customer B.',
+				artifact_expectation: 'QA stores before/action/after row snapshots and the filtered publication payload.'
+			},
+			evidence: [{
+				type: 'ticket',
+				summary: 'Ticket 004424 reports wrong-customer tickets after a customer filter is applied.'
+			}, {
+				type: 'qa',
+				summary: 'Browser QA reproduced Customer A ticket while Customer B filter was active.',
+				artifactPath: 'qa-artifacts/support-filter-reproduction.json'
+			}, {
+				type: 'code',
+				summary: 'Publication owner file contains the support ticket row query.'
+			}]
+		},
+		supportV5IssueClassProbePlan: {
+			planId: 'bad-probe-plan',
+			status: 'ready',
+			issue_class: 'filter_query_mismatch',
+			diagnosisValid: true,
+			probes: [{
+				issue_class: 'filter_query_mismatch',
+				probe_type: 'issue_class_probe',
+				failure_class: 'business',
+				objective: 'Verify the customer filter excludes wrong-customer rows.',
+				route: '',
+				action: '',
+				expected_evidence: '',
+				expected_business_proof: '',
+				required_artifacts: [],
+				state_transition: { before: '', action: '', after: '', assertion: '' },
+				acceptance_gate: 'route_probe',
+				blocks_acceptance_without_business_assertion: false
+			}],
+			requiredArtifacts: [],
+			acceptanceGate: 'route_probe',
+			falsePassBlockers: [],
+			blockers: [],
+			generatedAt: '2026-06-06T00:00:00.000Z'
+		},
+		supportV5AutonomousDecision: {
+			nextActionContract: {
+				contractId: 'support-next-action-business-qa',
+				action: 'run_business_proof_qa',
+				label: 'Run business proof QA',
+				primaryCommand: 'run_support_v5_business_proof_qa',
+				lane: 'qa',
+				stepType: 'business_proof',
+				safeToAutoRun: true,
+				requiresHumanApproval: false,
+				canRunWithoutCodexMonitor: true,
+				codexFallbackRequired: false,
+				rootCauseFirstSatisfied: true,
+				preconditions: ['SupportDiagnosisGate passed.'],
+				successEvidence: ['AIQaBusinessAssertion mapped to proof_plan.'],
+				stopConditions: ['Same failure class repeats without new evidence.'],
+				ownerFiles: ['server/src/publications/support-tickets.ts'],
+				decisionBasis: {
+					diagnosisValid: true,
+					ownerFilesReady: true,
+					proofPlanReady: true,
+					businessProofReady: true,
+					evidenceFreshnessStatus: 'fresh',
+					evidenceStrength: 'high',
+					failureClass: 'business',
+					sameFailureCount: 0
+				}
+			}
+		}
+	},
+	qaEvidence: {
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/support/004424', status: 'pass' }],
+		businessAssertions: [{
+			assertion: 'The wrong-customer ticket is absent after filtering.',
+			status: 'pass',
+			action: 'Apply the Customer B filter and reload the ticket list.',
+			expected: 'Only Customer B tickets are listed.',
+			observed: 'Only Customer B tickets are listed.',
+			dataProof: 'Every returned ticket row has customerId equal to Customer B.',
+			artifactPaths: ['qa-artifacts/support-filter-before-after.json'],
+			metadata: { proofPlanMatched: true, supportDiagnosisProof: true }
+		}]
+	}
+});
+const supportBadProbePlanGate = supportBadProbePlanRun.gates.find((gate) => gate.key === 'support_issue_class_probe_plan');
+assert.equal(supportBadProbePlanGate?.status, 'blocked');
+assert.equal(supportBadProbePlanRun.metadata?.issueClassProbePlan?.issueClassProbePlanReady, false);
+assert.equal(supportBadProbePlanRun.outcome, 'false_pass');
+assert.match(String(supportBadProbePlanRun.nextAction || ''), /IssueClassProbePlan/i);
+
+const supportInvalidRootCauseContractRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-invalid-root-cause', ticketNumber: '004422', title: 'Invalid root cause contract' },
+	job: {
+		_id: 'support-job-invalid-root-cause',
+		status: 'Running',
+		phase: 'Planning',
+		supportRootCauseEntryContract: {
+			contract_id: 'support-root-cause-entry-invalid',
+			required_output: {
+				object_key: 'support_diagnosis_gate',
+				required_fields: ['issue_case']
+			},
+			owner_file_policy: {
+				max_files: 50
+			},
+			business_proof_policy: {},
+			failure_policy: {},
+			issue_class_probes: [{ issue_class: 'no_op_submit' }]
+		}
+	}
+});
+const invalidRootCauseGate = supportInvalidRootCauseContractRun.gates.find((gate) => gate.key === 'support_root_cause_entry_contract');
+assert.equal(invalidRootCauseGate?.status, 'fail');
+assert.match(String(invalidRootCauseGate?.reason || ''), /missing required output fields|issue-class probes/i);
+
+const supportHotfixBlockedUntilCommitRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-hotfix-commit-blocked', ticketNumber: '004777', title: 'Hotfix must be committed' },
+	job: {
+		_id: 'support-hotfix-commit-blocked',
+		status: 'Running',
+		phase: 'Release',
+		support_v5_autonomous_decision: {
+			next_action_contract: {
+				contract_id: 'support-next-action-hotfix-blocked',
+				action: 'apply_live_hotfix',
+				label: 'Apply live hotfix',
+				primary_command: 'run_support_v5_live_hotfix',
+				lane: 'release',
+				step_type: 'hotfix',
+				safe_to_auto_run: false,
+				requires_human_approval: true,
+				can_run_without_codex_monitor: false,
+				codex_fallback_required: true,
+				codex_fallback_reason: 'Live hotfix cannot proceed until commit proof is pushed.',
+				success_evidence: ['sourceCommitSha', 'githubCommitUrl', 'gitCommitStatus=passed', 'gitPushStatus=passed'],
+				decision_basis: {
+					failure_class: 'release',
+					hotfix_commit_required: true,
+					live_hotfix_blocked_until_commit: true,
+					same_failure_count: 1
+				}
+			}
+		}
+	}
+});
+const supportHotfixBlockedGate = supportHotfixBlockedUntilCommitRun.gates.find((gate) => gate.key === 'support_next_action_contract');
+assert.equal(supportHotfixBlockedGate?.status, 'blocked');
+assert.match(String(supportHotfixBlockedGate?.reason || ''), /GitHub commit proof/i);
+assert.equal(supportHotfixBlockedGate?.metadata?.codexFallbackRequired, true);
+assert.equal(supportHotfixBlockedUntilCommitRun.metadata?.nextActionContract?.liveHotfixBlockedUntilCommit, true);
+
+const supportHotfixDurabilityRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-hotfix-durability', ticketNumber: '004779', title: 'Hotfix durability contract' },
+	job: {
+		_id: 'support-hotfix-durability',
+		status: 'Running',
+		phase: 'Release',
+		supportManagerHotfixDurabilityContract: {
+			contract_id: 'support-hotfix-durability-test',
+			required: true,
+			action: 'run_release_repair',
+			status: 'waiting_for_commit_proof',
+			can_prepare_hotfix_patch: true,
+			can_hotfix_backend: false,
+			live_hotfix_blocked_until_commit: true,
+			missing_commit_proof_fields: ['sourceCommitSha', 'githubCommitUrl', 'gitCommitStatus=passed', 'gitPushStatus=passed'],
+			next_safe_action: 'commit_and_push_hotfix_to_github'
+		}
+	}
+});
+const supportHotfixDurabilityGate = supportHotfixDurabilityRun.gates.find((gate) => gate.key === 'hotfix_durability_contract');
+assert.equal(supportHotfixDurabilityGate?.status, 'blocked');
+assert.equal(supportHotfixDurabilityGate?.metadata?.liveHotfixBlockedUntilCommit, true);
+assert.equal(supportHotfixDurabilityGate?.metadata?.commitFirstProtocolSatisfied, false);
+assert.equal(supportHotfixDurabilityRun.metadata?.hotfixDurability?.liveHotfixBlockedUntilCommit, true);
+assert.equal(supportHotfixDurabilityRun.metadata?.hotfixDurability?.commitFirstProtocolSatisfied, false);
+assert.equal(supportHotfixDurabilityRun.metadata?.hotfixDurability?.liveHotfixAllowed, false);
+assert.equal(supportHotfixDurabilityRun.metadata?.hotfixDurability?.canHotfixBackend, false);
+assert.equal(supportHotfixDurabilityRun.events.some((event) => event.category === 'hotfix_durability_contract'), true);
+
+const supportMissingNextActionContractRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-missing-next-action', ticketNumber: '004778', title: 'Support V5 missing next action' },
+	job: {
+		_id: 'support-missing-next-action',
+		status: 'Running',
+		phase: 'Manager',
+		supportWorkflowMode: 'support_v5',
+		supportV5SupervisorState: {
+			status: 'active',
+			activeStep: 'manager_recovery',
+			activeBlocker: 'Runner needs a structured next action.'
+		},
+		supportV5StepHistory: [{
+			lane: 'qa',
+			stepType: 'business_proof',
+			outcome: 'needs_repair',
+			failureClass: 'business',
+			blocker: 'Business proof missing after route-only QA.',
+			evidenceHash: 'route-only-no-next-action'
+		}]
+	}
+});
+const supportMissingNextActionGate = supportMissingNextActionContractRun.gates.find((gate) => gate.key === 'support_next_action_contract');
+assert.equal(supportMissingNextActionGate?.status, 'blocked');
+assert.equal(supportMissingNextActionGate?.metadata?.missingContract, true);
+assert.equal(supportMissingNextActionGate?.metadata?.canRunWithoutCodexMonitor, false);
+assert.equal(supportMissingNextActionGate?.metadata?.codexFallbackRequired, true);
+assert.equal(supportMissingNextActionContractRun.outcome, 'manual_handoff');
+assert.match(String(supportMissingNextActionContractRun.nextAction || ''), /validated next-action contract/i);
+assert.equal(supportMissingNextActionContractRun.metadata?.nextActionContract?.status, 'blocked');
+assert.equal(supportMissingNextActionContractRun.events.some((event) => event.category === 'support_next_action_contract'), true);
+const supportMissingManagerPacketGate = supportMissingNextActionContractRun.gates.find((gate) => gate.key === 'support_manager_execution_packet');
+assert.equal(supportMissingManagerPacketGate?.status, 'blocked');
+assert.equal(supportMissingManagerPacketGate?.metadata?.missingPacket, true);
+assert.equal(supportMissingNextActionContractRun.metadata?.managerExecutionPacket?.gateStatus, 'blocked');
+assert.equal(supportMissingNextActionContractRun.metadata?.managerExecutionPacket?.codexFallbackRequired, true);
+assert.equal(supportMissingNextActionContractRun.events.some((event) => event.category === 'support_manager_execution_packet'), true);
+
+const supportRepairBeforeDiagnosisRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-repair-before-diagnosis', ticketNumber: '004502', title: 'Repair started before diagnosis' },
+	job: {
+		_id: 'support-job-repair-before-diagnosis',
+		status: 'Running',
+		phase: 'Build',
+		supportV5StepHistory: [{
+			lane: 'build',
+			stepType: 'build_repair',
+			outcome: 'needs_repair',
+			failureClass: 'product_code',
+			blocker: 'Save action still fails.',
+			changedFiles: ['server/src/methods/support-ticket-save.ts'],
+			evidenceHash: 'repair-without-diagnosis'
+		}]
+	},
+	qaEvidence: {
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/support/004502', status: 'pass' }]
+	}
+});
+const supportRepairBeforeDiagnosisGate = supportRepairBeforeDiagnosisRun.gates.find((gate) => gate.key === 'support_diagnosis_before_repair');
+assert.equal(supportRepairBeforeDiagnosisGate?.status, 'blocked');
+assert.equal(supportRepairBeforeDiagnosisGate?.metadata?.diagnosisValid, false);
+assert.equal(supportRepairBeforeDiagnosisGate?.metadata?.allowedDispatchAction, 'run_read_only_diagnosis');
+assert.equal(supportRepairBeforeDiagnosisGate?.metadata?.productRepairAllowed, false);
+assert.equal(supportRepairBeforeDiagnosisRun.outcome, 'manual_handoff');
+assert.match(String(supportRepairBeforeDiagnosisGate?.reason || ''), /Support product repair is blocked/i);
+assert.match(String(supportRepairBeforeDiagnosisRun.nextAction || ''), /read-only support diagnosis/i);
+assert.equal(supportRepairBeforeDiagnosisRun.metadata?.diagnosisBeforeRepair?.allowedDispatchAction, 'run_read_only_diagnosis');
+assert.deepEqual(supportRepairBeforeDiagnosisRun.metadata?.diagnosisBeforeRepair?.changedFiles, ['server/src/methods/support-ticket-save.ts']);
+assert.equal(supportRepairBeforeDiagnosisRun.events.some((event) => event.category === 'support_diagnosis_before_repair'), true);
+
+const supportInScopeRepairRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-in-scope-repair', ticketNumber: '004503', title: 'In-scope support repair' },
+	job: {
+		_id: 'support-job-in-scope-repair',
+		status: 'Running',
+		phase: 'Build',
+		supportV5DiagnosisGate: supportAcceptedDiagnosisGate,
+		supportV5StepHistory: [{
+			lane: 'build',
+			stepType: 'build_repair',
+			outcome: 'pass',
+			failureClass: 'product_code',
+			summary: 'Owner-scoped publication repair completed.',
+			changedFiles: ['server/src/publications/support-tickets.ts', 'tests/support-ticket-filter.test.ts'],
+			evidenceHash: 'owner-scope-in-scope'
+		}]
+	},
+	qaEvidence: {
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/support', status: 'pass' }]
+	}
+});
+const supportInScopeGate = supportInScopeRepairRun.gates.find((gate) => gate.key === 'support_owner_file_scope');
+assert.equal(supportInScopeGate?.status, 'pass');
+assert.equal(supportInScopeGate?.metadata?.productRepairAllowed, true);
+assert.deepEqual(supportInScopeGate?.metadata?.outsideOwnerFiles, []);
+assert.equal(supportInScopeRepairRun.metadata?.ownerFileScope?.allowedTestFilesOutsideOwnerScope, true);
+assert.equal(supportInScopeRepairRun.events.some((event) => event.category === 'support_owner_file_scope'), true);
+
+const supportOutOfScopeRepairRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-out-of-scope-repair', ticketNumber: '004504', title: 'Out-of-scope support repair' },
+	job: {
+		_id: 'support-job-out-of-scope-repair',
+		status: 'Running',
+		phase: 'Build',
+		supportV5DiagnosisGate: supportAcceptedDiagnosisGate,
+		supportV5StepHistory: [{
+			lane: 'build',
+			stepType: 'build_repair',
+			outcome: 'needs_repair',
+			failureClass: 'product_code',
+			blocker: 'Repair touched an unrelated support method.',
+			changedFiles: ['server/src/publications/support-tickets.ts', 'server/src/methods/support-ticket-save.ts'],
+			evidenceHash: 'owner-scope-out-of-scope'
+		}]
+	},
+	qaEvidence: {
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/support', status: 'pass' }]
+	}
+});
+const supportOutOfScopeGate = supportOutOfScopeRepairRun.gates.find((gate) => gate.key === 'support_owner_file_scope');
+assert.equal(supportOutOfScopeGate?.status, 'blocked');
+assert.deepEqual(supportOutOfScopeGate?.metadata?.outsideOwnerFiles, ['server/src/methods/support-ticket-save.ts']);
+assert.equal(supportOutOfScopeGate?.metadata?.allowedDispatchAction, 'run_read_only_diagnosis');
+assert.equal(supportOutOfScopeRepairRun.outcome, 'manual_handoff');
+assert.match(String(supportOutOfScopeRepairRun.nextAction || ''), /Revise the SupportDiagnosisGate/i);
+assert.equal(supportOutOfScopeRepairRun.metadata?.ownerFileScope?.productRepairAllowed, false);
+assert.deepEqual(supportOutOfScopeRepairRun.metadata?.ownerFileScope?.outsideOwnerFiles, ['server/src/methods/support-ticket-save.ts']);
+
+const supportUnpushedHotfixRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-004421-hotfix', ticketNumber: '004421', title: 'Unpushed backend hotfix guard' },
+	job: {
+		_id: 'support-job-unpushed-hotfix',
+		status: 'Running',
+		phase: 'Release',
+		supportV5DiagnosisGate: supportAcceptedDiagnosisGate
+	},
+	qaEvidence: {
+		infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/support/004421', status: 'pass' }],
+		hotfixEvidence: {
+			channel: 'backend_js',
+			target: {
+				host: 'backend.resolveio.com',
+				path: '/var/app/current/http/runner-manager-selftest.js'
+			},
+			compiledArtifactPath: 'dist/http/runner-manager-selftest.js',
+			remoteChecksumBefore: '1111111111111111111111111111111111111111111111111111111111111111',
+			remoteChecksumAfter: '2222222222222222222222222222222222222222222222222222222222222222',
+			sourceCommitSha: '6fd400e1d8c961c1e88820292c323e688fdcc0a4',
+			githubCommitUrl: 'https://github.com/resolveio/resolveio-all/commit/6fd400e1d8c961c1e88820292c323e688fdcc0a4',
+			restartEvidence: 'nodejs and resolveio_support_ticket_codex_manager restarted on all support hosts',
+			healthCheckStatus: 'passed',
+			selfTestStatus: 'passed'
+		}
+	}
+});
+const supportUnpushedHotfixGate = supportUnpushedHotfixRun.gates.find((gate) => gate.key === 'hotfix_evidence');
+assert.equal(supportUnpushedHotfixGate?.status, 'fail');
+assert.match(String(supportUnpushedHotfixGate?.reason || ''), /gitPushStatus|GitHub/i);
+const supportUnpushedHotfixCommitGate = supportUnpushedHotfixRun.gates.find((gate) => gate.key === 'hotfix_commit_proof');
+assert.equal(supportUnpushedHotfixCommitGate?.status, 'blocked');
+assert.equal(supportUnpushedHotfixCommitGate?.metadata?.managerMustCommitBeforeHotfix, true);
+assert.equal(supportUnpushedHotfixRun.outcome, 'release_blocked');
+assert.equal(supportUnpushedHotfixRun.events.some((event) => event.type === 'hotfix' && event.metadata?.hotfixSatisfied === false), true);
+assert.equal(supportUnpushedHotfixRun.events.some((event) => event.category === 'hotfix_commit_proof' && event.metadata?.managerMustCommitBeforeHotfix === true), true);
+assert.equal(supportUnpushedHotfixRun.metadata?.hotfixDurability?.commitBlocked, true);
+assert.match(String(supportUnpushedHotfixRun.metadata?.hotfixDurability?.nextAction || ''), /Commit and push/i);
+
+const supportRepeatedFailureRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-repeated-failure', ticketNumber: '004500', title: 'Repeated support failure' },
+	job: {
+		_id: 'support-job-repeated-failure',
+		status: 'Running',
+		phase: 'Build',
+		supportV5Budget: { maxRepeatedNoProgress: 2 },
+		supportV5AutonomousDecision: {
+			evidenceProbeContract: {
+				contractId: 'support-evidence-probe-repeat',
+				status: 'ready',
+				probeType: 'issue_class_probe',
+				evidenceOnly: true,
+				productRepairAllowed: false,
+				canRunWithoutCodexMonitor: true,
+				issueClass: 'filter_query_mismatch',
+				planId: 'support-probe-plan-repeat',
+				activeRoute: '/support/004500',
+				actionUnderTest: 'Click Save on the failing support workflow.',
+				expectedBusinessProof: 'Save no longer throws TypeError and the persisted record updates.',
+				startingFailureClass: 'product_code',
+				startingBlockerFingerprint: 'save-typeerror',
+				startingEvidenceHash: 'save-typeerror-before',
+				sameFailureCount: 2,
+				requiredNewSignals: ['changed evidenceHash from the starting failure'],
+				requiredArtifacts: ['AIQaBusinessAssertion JSON artifact', 'network trace'],
+				acceptableEvidence: ['AIQaBusinessAssertion with before/action/after DOM/data proof'],
+				forbiddenActions: ['Do not edit product-code or source files during this evidence probe.'],
+				nextCommands: ['execute_active_issue_class_probe_evidence_only']
+			}
+		},
+		supportV5StepHistory: [
+			{
+				lane: 'repair',
+				stepType: 'workflow_build',
+				outcome: 'needs_repair',
+				failureClass: 'product_code',
+				blocker: 'Save action still throws TypeError.',
+				evidenceHash: 'save-typeerror-before',
+				artifactPaths: ['qa/save-before.log']
+			},
+			{
+				lane: 'repair',
+				stepType: 'workflow_build',
+				outcome: 'needs_repair',
+				failureClass: 'product_code',
+				blocker: 'Save action still throws TypeError.',
+				evidenceHash: 'save-typeerror-before',
+				artifactPaths: ['qa/save-before.log']
+			}
+		]
+	},
+	qaEvidence: {
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/support/004500', status: 'pass' }]
+	}
+});
+const repeatedFailureGate = supportRepeatedFailureRun.gates.find((gate) => gate.key === 'manager_no_blind_loop_policy');
+assert.equal(repeatedFailureGate?.status, 'blocked');
+assert.equal(repeatedFailureGate?.metadata?.action, 'park_repeated_failure');
+assert.equal(repeatedFailureGate?.metadata?.requiresNewEvidence, true);
+assert.equal(repeatedFailureGate?.metadata?.productRepairAllowed, false);
+assert.equal(supportRepeatedFailureRun.outcome, 'manual_handoff');
+assert.equal(supportRepeatedFailureRun.events.some((event) => event.category === 'manager_no_blind_loop_policy'), true);
+assert.equal(supportRepeatedFailureRun.metadata?.managerNoBlindLoopPolicy?.requiresNewEvidence, true);
+const repeatedEvidenceProbeGate = supportRepeatedFailureRun.gates.find((gate) => gate.key === 'support_evidence_probe_contract');
+assert.equal(repeatedEvidenceProbeGate?.status, 'pass');
+assert.equal(repeatedEvidenceProbeGate?.metadata?.evidenceOnly, true);
+assert.equal(repeatedEvidenceProbeGate?.metadata?.productRepairAllowed, false);
+assert.equal(repeatedEvidenceProbeGate?.metadata?.canRunWithoutCodexMonitor, true);
+assert.equal(supportRepeatedFailureRun.events.some((event) => event.category === 'support_evidence_probe_contract'), true);
+assert.equal(supportRepeatedFailureRun.metadata?.evidenceProbeContract?.contractId, 'support-evidence-probe-repeat');
+assert.equal(supportRepeatedFailureRun.metadata?.evidenceProbeContract?.probeType, 'issue_class_probe');
+assert.equal(supportRepeatedFailureRun.metadata?.evidenceProbeContract?.requiredNewSignals.some((signal: string) => /changed evidenceHash/i.test(signal)), true);
+
+const supportInfraRetryRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-infra-retry', ticketNumber: '004501', title: 'Support infra retry' },
+	job: {
+		_id: 'support-job-infra-retry',
+		status: 'Running',
+		phase: 'QA',
+		supportV5StepHistory: [{
+			lane: 'qa',
+			stepType: 'workflow_qa',
+			outcome: 'needs_repair',
+			failureClass: 'infra',
+			blocker: 'Chrome executable missing.',
+			evidenceHash: 'chrome-missing',
+			artifactPaths: ['qa/chrome-preflight.log']
+		}]
+	},
+	qaEvidence: {
+		infraChecks: [{ name: 'chrome_executable', status: 'blocked', message: 'Chrome executable missing.', path: 'qa/chrome-preflight.log' }]
+	}
+});
+const infraRetryGate = supportInfraRetryRun.gates.find((gate) => gate.key === 'manager_no_blind_loop_policy');
+assert.equal(infraRetryGate?.status, 'warn');
+assert.equal(infraRetryGate?.metadata?.action, 'retry_infra');
+assert.equal(infraRetryGate?.metadata?.productRepairFailure, false);
+assert.equal(infraRetryGate?.metadata?.dispatchAction, 'run_infra_repair');
+assert.equal(supportInfraRetryRun.outcome, 'qa_infra_failed');
+
+const supportCompilePreflightGateRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-compile-preflight', ticketNumber: '004502', title: 'Support compile preflight' },
+	job: {
+		_id: 'support-job-compile-preflight',
+		status: 'Running',
+		phase: 'QA',
+		supportV5PreflightGate: {
+			required: true,
+			status: 'compile_failed',
+			failureClass: 'compile',
+			blocksProductRepair: true,
+			blocksModelRepair: true,
+			nextCommand: 'run_support_v5_compile_repair',
+			evidenceHash: 'compile-preflight-hash',
+			compileResult: {
+				status: 'fail',
+				summary: 'Angular compile failed before browser QA.',
+				command: 'npm run build-prod',
+				artifactPath: 'qa-artifacts/preflight/compile.log',
+				failureClass: 'compile'
+			},
+			requiredEvidence: ['compile command output', 'new compile evidence hash or pass']
+		}
+	}
+});
+const supportCompilePreflightGate = supportCompilePreflightGateRun.gates.find((gate) => gate.key === 'support_preflight_gate');
+assert.equal(supportCompilePreflightGateRun.outcome, 'build_failed');
+assert.equal(supportCompilePreflightGate?.status, 'fail');
+assert.equal(supportCompilePreflightGate?.metadata?.failureClass, 'compile');
+assert.equal(supportCompilePreflightGate?.metadata?.nextCommand, 'run_support_v5_compile_repair');
+assert.equal(supportCompilePreflightGateRun.gates.some((gate) => gate.key === 'qa_compile' && gate.status === 'fail'), true);
+assert.equal(supportCompilePreflightGateRun.events.some((event) => event.category === 'support_preflight_gate' && event.type === 'qa_compile'), true);
+
+const supportStartupPreflightGateRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-startup-preflight', ticketNumber: '004503', title: 'Support startup preflight' },
+	job: {
+		_id: 'support-job-startup-preflight',
+		status: 'Running',
+		phase: 'QA',
+		supportV5PreflightGate: {
+			required: true,
+			status: 'infra_failed',
+			failureClass: 'infra',
+			blocksProductRepair: true,
+			blocksModelRepair: true,
+			nextCommand: 'run_support_v5_infra_repair',
+			evidenceHash: 'startup-preflight-hash',
+			checks: [{
+				name: 'server_startup',
+				status: 'fail',
+				summary: 'Local startup preflight failed before browser QA.',
+				artifactPaths: ['qa-artifacts/runner.log', 'qa-artifacts/server.log'],
+				failureClass: 'infra'
+			}],
+			requiredEvidence: ['startup preflight log', 'new infra evidence hash or pass']
+		}
+	}
+});
+const supportStartupPreflightGate = supportStartupPreflightGateRun.gates.find((gate) => gate.key === 'support_preflight_gate');
+assert.equal(supportStartupPreflightGateRun.outcome, 'qa_infra_failed');
+assert.equal(supportStartupPreflightGate?.status, 'fail');
+assert.equal(supportStartupPreflightGate?.metadata?.failureClass, 'infra');
+assert.equal(supportStartupPreflightGate?.metadata?.nextCommand, 'run_support_v5_infra_repair');
+assert.equal(supportStartupPreflightGateRun.gates.some((gate) => gate.key === 'qa_infra' && gate.status === 'blocked'), true);
+assert.equal(supportStartupPreflightGateRun.events.some((event) => event.category === 'support_preflight_gate' && event.type === 'qa_infra'), true);
+
+const supportGenericBusinessProofRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-004421', ticketNumber: '004421', title: 'Generic support proof' },
+	job: {
+		_id: 'support-job-generic-proof',
+		status: 'Closed',
+		phase: 'COMPLETE',
+		supportV5DiagnosisGate: supportAcceptedDiagnosisGate
+	},
+	qaEvidence: {
+		infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/support', status: 'pass' }],
+		scorecardPassed: true,
+		businessAssertions: [{
+			assertion: 'The route loads and the ticket page has visible controls.',
+			status: 'pass',
+			route: '/support',
+			action: 'Open the ticket page.',
+			expected: 'Visible controls render.',
+			observed: 'Visible controls rendered.',
+			dataProof: 'Screenshot showed page content.'
+		}]
+	}
+});
+assert.equal(supportGenericBusinessProofRun.outcome, 'false_pass');
+assert.equal(supportGenericBusinessProofRun.gates.some((gate) => gate.key === 'support_diagnosis_business_proof' && gate.status === 'blocked'), true);
+
+const supportBusinessProofRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-004430', ticketNumber: '004430', title: 'Filtered support ticket list' },
+	job: {
+		_id: 'support-job-2',
+		status: 'Closed',
+		phase: 'COMPLETE',
+		supportV5DiagnosisGate: supportAcceptedDiagnosisGate
+	},
+	qaEvidence: {
+		infraChecks: [{ name: 'puppeteer_require', status: 'pass' }],
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/support', status: 'pass' }],
+		businessAssertions: [{
+			assertion: 'Wrong-customer ticket is absent after applying the customer filter.',
+			status: 'pass',
+			route: '/support',
+			action: 'Apply customer filter and reload.',
+			expected: 'Only Customer B tickets are visible.',
+			observed: 'Customer A ticket was not rendered.',
+			dataProof: 'DOM and query proof matched the diagnosis proof plan.'
+		}]
+	}
+});
+assert.equal(supportBusinessProofRun.outcome, 'accepted');
+
+const supportJobStoredBusinessProofRun = buildSupportAIRunFromEvidence({
+	ticket: {
+		_id: 'ticket-004431',
+		ticketNumber: '004431',
+		title: 'Stored support business proof',
+		automation: {
+			customer_reply_policy: {
+				last_proof_backed_send_contract: {
+					contract_id: 'support-proof-backed-reply-send-stored-proof',
+					status: 'sent_after_manual_approval',
+					sent_at: '2026-06-06T00:05:00.000Z',
+					job_id: 'support-job-stored-proof',
+					action: 'draft_resolution_reply',
+					pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4431',
+					readiness_contract_id: 'support-customer-reply-stored-proof',
+					readiness_status: 'draft_ready',
+					proof_backed: true,
+					business_proof_ready: true,
+					release_ready: true,
+					diagnosis_ready: true,
+					issue_class_probe_plan_ready: true,
+					requires_human_approval: true,
+					message_hash: '8f434346648f6b96df89dda901c5176b',
+					recipients: ['customer@example.com'],
+					evidence_refs: ['qa-artifacts/stored-business-proof.json'],
+					required_evidence: ['AIQaBusinessAssertion status=pass', 'PR reference present'],
+					send_guard: {
+						allowed: true,
+						status: 'ready_for_manual_send',
+						direct_send_allowed: false,
+						manual_send_after_review_allowed: true,
+						requires_human_approval: true,
+						proof_backed: true,
+						business_proof_ready: true,
+						release_ready: true,
+						diagnosis_ready: true,
+						issue_class_probe_plan_ready: true,
+						confidence_level: 'high',
+						next_action: 'send_after_human_review',
+						pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4431'
+					}
+				}
+			}
+		}
+	},
+	job: {
+		_id: 'support-job-stored-proof',
+		status: 'Closed',
+		phase: 'COMPLETE',
+		supportV5DiagnosisGate: supportAcceptedDiagnosisGate,
+		supportQaValidationCursor: {
+			route_probe: { route: '/support', status: 'pass', screenshot: 'qa-artifacts/stored-route.png' },
+			business_assertions: [{
+				assertion: 'Wrong-customer ticket is absent after applying the customer filter.',
+				status: 'pass',
+				route: '/support',
+				action: 'Apply customer filter and reload.',
+				expected: 'Only Customer B tickets are visible.',
+				observed: 'Customer A ticket was not rendered.',
+				dataProof: 'DOM and query proof matched the diagnosis proof plan.',
+				artifactPaths: ['qa-artifacts/stored-business-proof.json'],
+				metadata: { supportDiagnosisProof: true }
+			}]
+		},
+		supportV5AutonomousDecision: {
+			business_proof_readiness: {
+				ready: true,
+				status: 'passed',
+				reason: 'Stored support business proof matched the diagnosis.',
+				artifact_paths: ['qa-artifacts/stored-business-proof.json']
+			},
+			customer_reply_policy: {
+				action: 'draft_resolution_reply',
+				canDraftCustomerReply: true,
+				canSendCustomerReply: false,
+				confidenceLevel: 'high',
+				safety: 'safe_to_draft',
+				reason: 'support_reply_resolution_draft_allowed_after_business_proof',
+				humanReviewPacket: {
+					reviewType: 'customer_resolution_reply',
+					primaryAction: 'review_customer_reply',
+					customerFacingDraftAllowed: true,
+					customerSendAllowed: false,
+					requiresHumanApproval: true,
+					evidenceRefs: ['qa-artifacts/stored-business-proof.json']
+				},
+				readinessContract: {
+					contractId: 'support-customer-reply-stored-proof',
+					status: 'draft_ready',
+					policyAction: 'draft_resolution_reply',
+					reviewType: 'customer_resolution_reply',
+					primaryCommand: 'review_customer_reply',
+					canDraftCustomerReply: true,
+					canSendCustomerReply: false,
+					requiresHumanApproval: true,
+					proofBacked: true,
+					businessProofReady: true,
+					releaseReady: true,
+					diagnosisReady: true,
+					issueClassProbePlanReady: true,
+					clarificationRequired: false,
+					reason: 'support_reply_resolution_draft_allowed_after_business_proof',
+					blockers: [],
+					requiredEvidence: ['AIQaBusinessAssertion status=pass'],
+					evidenceRefs: ['qa-artifacts/stored-business-proof.json'],
+					nextCommands: ['review_customer_reply'],
+					forbiddenActions: ['Do not send customer email without explicit human approval.'],
+					createdAt: '2026-06-06T00:00:00.000Z'
+				}
+			}
+		}
+	}
+});
+assert.equal(supportJobStoredBusinessProofRun.outcome, 'accepted');
+assert.equal(supportJobStoredBusinessProofRun.qa?.businessAssertions.length, 1);
+assert.equal(supportJobStoredBusinessProofRun.gates.some((gate) => gate.key === 'support_business_proof_readiness' && gate.status === 'pass'), true);
+assert.equal(supportJobStoredBusinessProofRun.metadata?.businessProofReadiness?.ready, true);
+assert.equal(supportJobStoredBusinessProofRun.gates.some((gate) => gate.key === 'support_customer_reply_policy' && gate.status === 'warn'), true);
+assert.equal(supportJobStoredBusinessProofRun.gates.some((gate) => gate.key === 'support_customer_reply_readiness' && gate.status === 'warn'), true);
+assert.equal(supportJobStoredBusinessProofRun.metadata?.customerReplyPolicy?.reviewType, 'customer_resolution_reply');
+assert.equal(supportJobStoredBusinessProofRun.metadata?.customerReplyPolicy?.canSendCustomerReply, false);
+assert.equal(supportJobStoredBusinessProofRun.metadata?.customerReplyReadiness?.status, 'draft_ready');
+assert.equal(supportJobStoredBusinessProofRun.metadata?.customerReplyReadiness?.proofBacked, true);
+assert.equal(supportJobStoredBusinessProofRun.gates.some((gate) => gate.key === 'support_proof_backed_customer_reply_send' && gate.status === 'pass'), true);
+assert.equal(supportJobStoredBusinessProofRun.events.some((event) => event.category === 'support_proof_backed_customer_reply_send'), true);
+assert.equal(supportJobStoredBusinessProofRun.metadata?.customerReplySend?.sentAfterManualApproval, true);
+assert.equal(supportJobStoredBusinessProofRun.metadata?.customerReplySend?.directSendAllowed, false);
+assert.equal(supportJobStoredBusinessProofRun.metadata?.customerReplySend?.pullRequestUrl, 'https://github.com/resolveio/resolveio-all/pull/4431');
+assert.equal(supportJobStoredBusinessProofRun.metadata?.customerReplySend?.messageHash, '8f434346648f6b96df89dda901c5176b');
+
+const supportBlockedCustomerReplySendRun = buildSupportAIRunFromEvidence({
+	ticket: {
+		_id: 'ticket-004431-blocked-send',
+		ticketNumber: '004431',
+		title: 'Blocked proof-backed send guard',
+		automation: {
+			customer_reply_policy: {
+				last_blocked_send_guard: {
+					allowed: false,
+					status: 'blocked',
+					action: 'draft_resolution_reply',
+					readiness_status: 'draft_ready',
+					confidence_level: 'low',
+					direct_send_allowed: false,
+					requires_human_approval: true,
+					proof_backed: true,
+					business_proof_ready: true,
+					release_ready: true,
+					diagnosis_ready: true,
+					issue_class_probe_plan_ready: true,
+					next_action: 'run_evidence_probe',
+					pull_request_url: 'https://github.com/resolveio/resolveio-all/pull/4431',
+					blockers: ['Proof-backed customer reply requires high confidence; got low.']
+				}
+			}
+		}
+	},
+	job: {
+		_id: 'support-job-blocked-send',
+		status: 'Review',
+		phase: 'CUSTOMER_REPLY'
+	}
+});
+const blockedReplySendGate = supportBlockedCustomerReplySendRun.gates.find((gate) => gate.key === 'support_proof_backed_customer_reply_send');
+assert.equal(blockedReplySendGate?.status, 'blocked');
+assert.equal(supportBlockedCustomerReplySendRun.metadata?.customerReplySend?.nextAction, 'run_evidence_probe');
+assert.equal(supportBlockedCustomerReplySendRun.metadata?.customerReplySend?.confidenceLevel, 'low');
+assert.ok(supportBlockedCustomerReplySendRun.metadata?.customerReplySend?.blockers?.some((blocker: string) => /high confidence/i.test(blocker)));
+
+const supportClarificationContractRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-004431', ticketNumber: '004431', title: 'Needs reproduction detail' },
+	job: {
+		_id: 'support-job-clarification-contract',
+		status: 'Blocked',
+		phase: 'REVIEW',
+		customerReplyPolicy: {
+			action: 'ask_clarification',
+			canDraftCustomerReply: true,
+			canSendCustomerReply: false,
+			confidenceLevel: 'low',
+			safety: 'needs_clarification',
+			reason: 'support_reply_waiting_on_customer_reproduction_detail',
+			clarificationQuestion: 'Can you provide the exact invoice number where the export fails?',
+			clarificationContract: {
+				contractId: 'support-clarification-invoice-export',
+				status: 'ready',
+				missingField: 'reproduction_blocker',
+				question: 'Can you provide the exact invoice number where the export fails?',
+				sourceBlockers: ['Need an invoice number to reproduce the PDF/export issue.'],
+				oneQuestionOnly: true,
+				customerFacingDraftAllowed: true,
+				customerSendAllowed: false,
+				parksTicketUntilCustomerReply: true,
+				nextCommands: ['review_customer_clarification', 'send_after_human_review', 'park_ticket_until_customer_reply'],
+				forbiddenActions: ['Do not run product repair from a guessed reproduction path.'],
+				requiredEvidence: ['missing_field=reproduction_blocker', 'one customer-facing question'],
+				createdAt: '2026-06-06T00:00:00.000Z'
+			},
+			humanReviewPacket: {
+				reviewType: 'customer_clarification',
+				primaryAction: 'review_customer_clarification',
+				question: 'Can you provide the exact invoice number where the export fails?',
+				customerFacingDraftAllowed: true,
+				customerSendAllowed: false,
+				requiresHumanApproval: true,
+				blockers: ['Need an invoice number to reproduce the PDF/export issue.']
+			},
+			readinessContract: {
+				contractId: 'support-customer-reply-clarification',
+				status: 'clarification_required',
+				policyAction: 'ask_clarification',
+				reviewType: 'customer_clarification',
+				primaryCommand: 'review_customer_clarification',
+				canDraftCustomerReply: true,
+				canSendCustomerReply: false,
+				requiresHumanApproval: true,
+				proofBacked: false,
+				businessProofReady: false,
+				releaseReady: true,
+				diagnosisReady: false,
+				issueClassProbePlanReady: false,
+				clarificationRequired: true,
+				reason: 'support_reply_waiting_on_customer_reproduction_detail',
+				blockers: ['Need an invoice number to reproduce the PDF/export issue.'],
+				requiredEvidence: ['one customer-facing question'],
+				evidenceRefs: [],
+				nextCommands: ['review_customer_clarification', 'park_ticket_until_customer_reply'],
+				forbiddenActions: ['Do not send customer email without explicit human approval.'],
+				createdAt: '2026-06-06T00:00:00.000Z'
+			}
+		}
+	}
+});
+const supportClarificationPolicyGate = supportClarificationContractRun.gates.find((gate) => gate.key === 'support_customer_reply_policy');
+assert.equal(supportClarificationPolicyGate?.status, 'warn');
+assert.equal(supportClarificationPolicyGate?.metadata?.clarificationContractStatus, 'ready');
+assert.equal(supportClarificationPolicyGate?.metadata?.clarificationMissingField, 'reproduction_blocker');
+assert.equal(supportClarificationPolicyGate?.metadata?.clarificationOneQuestionOnly, true);
+assert.equal(supportClarificationPolicyGate?.metadata?.clarificationParksTicket, true);
+const supportClarificationReadinessGate = supportClarificationContractRun.gates.find((gate) => gate.key === 'support_customer_reply_readiness');
+assert.equal(supportClarificationReadinessGate?.status, 'warn');
+assert.equal(supportClarificationReadinessGate?.metadata?.status, 'clarification_required');
+assert.equal(supportClarificationReadinessGate?.metadata?.primaryCommand, 'review_customer_clarification');
+assert.equal(supportClarificationContractRun.metadata?.customerReplyPolicy?.clarificationContract?.oneQuestionOnly, true);
+assert.equal(supportClarificationContractRun.metadata?.customerReplyPolicy?.clarificationContract?.parksTicketUntilCustomerReply, true);
+assert.equal(supportClarificationContractRun.metadata?.customerReplyPolicy?.canSendCustomerReply, false);
+assert.equal(supportClarificationContractRun.metadata?.customerReplyReadiness?.status, 'clarification_required');
+
+const supportRouteOnlyReadinessRun = buildSupportAIRunFromEvidence({
+	ticket: { _id: 'ticket-004432', ticketNumber: '004432', title: 'Stored route-only support proof' },
+	job: {
+		_id: 'support-job-route-only-readiness',
+		status: 'Closed',
+		phase: 'COMPLETE',
+		supportV5DiagnosisGate: supportAcceptedDiagnosisGate,
+		supportQaValidationCursor: {
+			workflow_probe: {
+				route: '/support',
+				status: 'pass',
+				screenshot: 'qa-artifacts/route-only.png',
+				message: 'Route loaded but no business assertion ran.'
+			}
+		},
+		supportV5AutonomousDecision: {
+			business_proof_readiness: {
+				ready: false,
+				status: 'route_only',
+				reason: 'Route probe is not business proof.',
+				blockers: ['Run the issue-class business assertion.'],
+				artifact_paths: ['qa-artifacts/route-only.png']
+			}
+		}
+	}
+});
+assert.notEqual(supportRouteOnlyReadinessRun.outcome, 'accepted');
+assert.equal(supportRouteOnlyReadinessRun.gates.some((gate) => gate.key === 'support_business_proof_readiness' && gate.status === 'blocked'), true);
+assert.equal(supportRouteOnlyReadinessRun.metadata?.businessProofReadiness?.status, 'route_only');
+
+const aicoderJourneyContract = {
+	app_archetype: 'optimizer',
+	primary_actor: 'Operations planner',
+	primary_goal: 'Create a saved hose pressure recommendation for a field route.',
+	primary_workflow_id: 'layflat-optimizer',
+	first_screen: {
+		route: '/dashboard/hub',
+		purpose: 'Command center showing active scenarios and next optimizer action.',
+		visible_cta: 'Start optimizer scenario',
+		next_step: 'Open assumptions for the seeded route.'
+	},
+	north_star_workflow: [{
+		position: 'first',
+		id: 'start-scenario',
+		route: '/dashboard/hub',
+		visible_cta: 'Start optimizer scenario',
+		data_input_or_selection: 'Select North Field route.',
+		method_or_calculation: 'local calculation path optimizerScenarioDraft',
+		expected_state_transition: 'Scenario assumptions panel opens.',
+		success_confirmation: 'Scenario ready badge appears.',
+		next_step_destination: '/dashboard/hub?scenario=active'
+	}, {
+		position: 'next',
+		id: 'run-optimizer',
+		route: '/dashboard/hub',
+		visible_cta: 'Run optimization',
+		data_input_or_selection: 'Confirm pressure limit, terrain, pump, and hose specs.',
+		method_or_calculation: 'local calculation path runLayflatPressureOptimizer and server method saveOptimizerResult',
+		expected_state_transition: 'Alternatives table and recommendation card update.',
+		success_confirmation: 'Recommendation calculated badge appears.',
+		next_step_destination: '/dashboard/hub?result=compare'
+	}, {
+		position: 'last',
+		id: 'save-report',
+		route: '/reports/optimizer',
+		visible_cta: 'Save recommendation report',
+		data_input_or_selection: 'Choose the recommended hose plan.',
+		method_or_calculation: 'server method publishOptimizerRecommendation',
+		expected_state_transition: 'Saved report row appears.',
+		success_confirmation: 'Recommendation saved message appears.',
+		final_result: 'Saved optimizer recommendation with exportable pressure report.'
+	}],
+	secondary_workflows: [
+		{ id: 'setup', route: '/manage/settings', purpose: 'Maintain pump defaults.' },
+		{ id: 'report-export', route: '/reports/optimizer', purpose: 'Review saved recommendations.' },
+		{ id: 'recovery', route: '/dashboard/hub', purpose: 'Handle invalid pressure states.' }
+	],
+	screen_sequence: [{
+		workflow_step_id: 'start-scenario',
+		route: '/dashboard/hub',
+		screen_purpose: 'Command center with seeded scenario and embedded optimizer action.',
+		visible_cta: 'Start optimizer scenario',
+		action: 'Open scenario assumptions',
+		method_or_calculation: 'local calculation path optimizerScenarioDraft',
+		expected_next_state: 'Scenario assumptions are visible.',
+		data_shown: 'Seeded route, elevation, pump, hose, and pressure-limit records.'
+	}, {
+		workflow_step_id: 'run-optimizer',
+		route: '/dashboard/hub',
+		screen_purpose: 'Run optimizer and compare alternatives.',
+		visible_cta: 'Run optimization',
+		action: 'Calculate pressure recommendation',
+		method_or_calculation: 'local calculation path runLayflatPressureOptimizer',
+		expected_next_state: 'Recommendation and alternatives update.',
+		data_shown: 'Comparison table and recommendation card.'
+	}, {
+		workflow_step_id: 'save-report',
+		route: '/reports/optimizer',
+		screen_purpose: 'Save and export recommendation report.',
+		visible_cta: 'Save recommendation report',
+		action: 'Persist recommendation report',
+		method_or_calculation: 'server method publishOptimizerRecommendation',
+		expected_next_state: 'Saved report row and export button visible.',
+		data_shown: 'Saved recommendation and calculated pressure.'
+	}],
+	data_story: {
+		seeded_scenario: 'North Field irrigation route with elevation changes, pumps, and hose alternatives.',
+		records: ['North Field route', 'Pump A', 'Pump B', '4-inch layflat hose', '6-inch layflat hose'],
+		relationships: ['Route uses pump options', 'Pump options feed hose alternatives', 'Optimization result belongs to scenario'],
+		non_empty_states: ['Dashboard KPIs show pressure and flow.', 'Reports table shows saved recommendation row.']
+	},
+	completion_states: [
+		'Recommendation card shows selected hose and pressure margin.',
+		'Report route lists saved recommendation with export action.'
+	],
+	qa_assertions: [{
+		id: 'login-hub',
+		workflow_step_id: 'start-scenario',
+		route: '/dashboard/hub',
+		coverage_tags: ['login', 'hub_action', 'non_empty_data'],
+		proof_kind: 'login',
+		action: 'Login and land on dashboard hub.',
+		expected_dom_or_data_proof: 'Hub shows seeded North Field scenario and non-empty KPIs.'
+	}, {
+		id: 'primary-hub-action',
+		workflow_step_id: 'start-scenario',
+		route: '/dashboard/hub',
+		coverage_tags: ['hub_action'],
+		proof_kind: 'hub_action',
+		action: 'Click Start optimizer scenario.',
+		expected_dom_or_data_proof: 'Scenario assumptions panel opens with seeded route and pump records.'
+	}, {
+		id: 'workflow-completion',
+		covers_workflow_step_ids: ['run-optimizer', 'save-report'],
+		route: '/dashboard/hub',
+		coverage_tags: ['workflow_completion', 'report_export'],
+		proof_kind: 'report_export',
+		action: 'Run optimization and save recommendation.',
+		expected_dom_or_data_proof: 'Saved recommendation report row appears with calculated pressure result.'
+	}, {
+		id: 'mobile-viewport',
+		covers_workflow_step_ids: ['start-scenario', 'run-optimizer', 'save-report'],
+		route: '/dashboard/hub',
+		coverage_tags: ['mobile', 'workflow_completion'],
+		proof_kind: 'mobile',
+		action: 'Repeat primary optimizer path at mobile viewport 390x844.',
+		expected_dom_or_data_proof: 'Mobile hub shows non-empty scenario and recommendation controls.',
+		viewport: '390x844 mobile'
+	}, {
+		id: 'empty-error-recovery',
+		workflow_step_id: 'start-scenario',
+		route: '/dashboard/hub',
+		coverage_tags: ['recovery'],
+		proof_kind: 'recovery',
+		action: 'Clear scenario input and submit invalid pressure limit.',
+		expected_dom_or_data_proof: 'Empty/error recovery message appears and Start optimizer scenario remains available.'
+	}]
+};
+const aicoderWorkflowQaRows = aicoderJourneyContract.qa_assertions.map((row, index) => ({
+	index: index + 1,
+	workflowId: 'layflat-optimizer',
+	stepId: row.id,
+	route: row.route,
+	action: row.action,
+	assertion: row.expected_dom_or_data_proof,
+	expectedState: row.expected_dom_or_data_proof,
+	status: 'pass',
+	artifactPaths: [`qa-artifacts/${row.id}.json`]
+}));
+const aicoderWorkflowBusinessAssertions = aicoderWorkflowQaRows.map((row) => ({
+	stepId: row.stepId,
+	workflowId: row.workflowId,
+	route: row.route,
+	action: row.action,
+	assertion: row.assertion,
+	status: 'pass',
+	observed: `${row.stepId} produced the expected visible workflow state.`,
+	dataProof: `${row.stepId} has observed DOM/data proof from seeded Layflat records.`,
+	artifactPaths: row.artifactPaths
+}));
+
+const aicoderRun = buildAICoderAIRunFromEvidence({
+	app: { _id: 'layflat-app', name: 'Layflat Pressure Optimizer', domain: 'layflat.resolveio.app' },
+	job: {
+		_id: 'aicoder-job-1',
+		phase: 'COMPLETE',
+		status: 'Passed',
+		managerHotfixEvidence: {
+			channel: 'backend_js',
+			target: {
+				host: 'backend.aicoder.resolveio.com',
+				path: '/var/app/current/http/runner-manager-selftest.js'
+			},
+			compiledArtifactPath: 'dist/http/runner-manager-selftest.js',
+			remoteChecksumAfter: '3333333333333333333333333333333333333333333333333333333333333333',
+			sourceCommitSha: '6fd400e1d8c961c1e88820292c323e688fdcc0a4',
+			githubCommitUrl: 'https://github.com/resolveio/resolveio-all/commit/6fd400e1d8c961c1e88820292c323e688fdcc0a4',
+			gitCommitStatus: 'passed',
+			gitPushStatus: 'passed',
+			restartEvidence: 'nodejs, resolveio_support_ticket_codex_manager, and resolveio_ai_server_watchdog_manager restarted on AICoder hosts',
+			healthCheckStatus: 'passed',
+			selfTestStatus: 'passed'
+		},
+		nextActionContract: {
+			contractId: 'aicoder-next-release-hotfix',
+			action: 'retry_same_step',
+			label: 'Repair Release Gate',
+			primaryCommand: 'repair_aicoder_release_gate',
+			lane: 'publish',
+			stepType: 'test_deploy',
+			safeToAutoRun: true,
+			requiresHumanApproval: false,
+			canRunWithoutCodexMonitor: true,
+			codexFallbackRequired: false,
+			costRisk: 'release_or_customer_send',
+			workflowFirstSatisfied: false,
+			decisionBasis: {
+				releaseBlocked: true,
+				hotfixCommitRequired: true,
+				liveHotfixBlockedUntilCommit: true
+			},
+			requiredHotfixCommitProof: ['sourceCommitSha', 'githubCommitUrl', 'gitCommitStatus=passed', 'gitPushStatus=passed'],
+			preconditions: ['sourceCommitSha, githubCommitUrl, passed gitCommitStatus, and passed gitPushStatus before live hotfix apply'],
+			successEvidence: ['GitHub commit and push proof for any manager-applied hotfix'],
+			stopConditions: ['Do not apply a live AICoder backend/static hotfix until sourceCommitSha, githubCommitUrl, passed gitCommitStatus, and passed gitPushStatus are recorded.'],
+			forbiddenActions: ['applying live hotfix before pushed GitHub commit proof'],
+			nextCommands: ['repair_aicoder_release_gate', 'commit_and_push_hotfix_to_github', 'apply_live_hotfix_only_after_github_commit_proof'],
+			blockers: ['Sample data release gate is blocked.']
+		}
+	},
+	usageLedger: [{
+		model: 'codex-manual',
+		category: 'manual-codex-builder-monitor',
+		usage_source: 'manual_codex',
+		usage_surface: 'aicoder',
+		cost_basis: 'manual_estimate',
+		is_manual: true,
+		is_untracked: true,
+		untracked_reason: 'Sidecar Codex session watched the Layflat builder.',
+		total_tokens: 0,
+		cost_estimate: 42
+	}],
+	qaEvidence: {
+		journeyContract: aicoderJourneyContract,
+		workflowQaRows: aicoderWorkflowQaRows,
+		scorecardPassed: true,
+		deployStatus: 'pass',
+		publishStatus: 'published',
+		sampleDataStatus: 'empty seed collections',
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/optimizer', status: 'pass' }],
+		businessAssertions: aicoderWorkflowBusinessAssertions
+	}
+});
+assert.equal(aicoderRun.source, 'aicoder_app');
+assert.equal(aicoderRun.outcome, 'release_blocked');
+assert.equal(aicoderRun.events.some((event) => event.type === 'hotfix' && event.metadata?.hotfixSatisfied === true), true);
+	assert.equal(aicoderRun.gates.some((gate) => gate.key === 'hotfix_commit_proof' && gate.status === 'pass'), true);
+	assert.equal(aicoderRun.gates.some((gate) => gate.key === 'aicoder_workflow_proof_readiness' && gate.status === 'fail'), true);
+	assert.equal(aicoderRun.metadata?.journeyContract?.workflowQaCoverageTags?.includes('workflow_completion'), true);
+	assert.equal(aicoderRun.metadata?.journeyContract?.workflowQaProofKinds?.includes('report_export'), true);
+	assert.equal(aicoderRun.metadata?.workflowProofReadiness?.status, 'release_blocked');
+	assert.equal(aicoderRun.metadata?.hotfixDurability?.commitProofPassed, true);
+	assert.equal(aicoderRun.metadata?.hotfixDurability?.commitFirstProtocolSatisfied, true);
+	assert.equal(aicoderRun.metadata?.hotfixDurability?.liveHotfixAllowed, true);
+	assert.equal(aicoderRun.metadata?.hotfixDurability?.commitBlocked, false);
+assert.equal(aicoderRun.gates.some((gate) => gate.key === 'cost_observability' && gate.status === 'warn'), true);
+assert.equal(aicoderRun.metadata?.costObservability?.externalCodexMonitorUsed, true);
+assert.equal(aicoderRun.metadata?.costObservability?.untrackedEstimatedUsd, 42);
+assert.equal(aicoderRun.metadata?.nextActionContract?.primaryCommand, 'repair_aicoder_release_gate');
+assert.equal(aicoderRun.metadata?.nextActionContract?.hotfixCommitRequired, true);
+assert.equal(aicoderRun.metadata?.nextActionContract?.liveHotfixBlockedUntilCommit, true);
+assert.deepEqual(aicoderRun.metadata?.nextActionContract?.requiredHotfixCommitProof, ['sourceCommitSha', 'githubCommitUrl', 'gitCommitStatus=passed', 'gitPushStatus=passed']);
+
+const aicoderRouteOnlyRun = buildAICoderAIRunFromEvidence({
+	app: { _id: 'route-only-app', name: 'Route Only App' },
+	job: {
+		_id: 'aicoder-route-only',
+		phase: 'COMPLETE',
+		status: 'Passed',
+		workflowProofCheckpoint: {
+			required: true,
+			status: 'waiting_for_workflow_proof',
+			readinessStatus: 'workflow_qa_required',
+			nextGate: 'workflow_qa',
+			workflowProofFingerprint: 'aicoder-workflow-proof-route-only',
+			artifactFingerprint: 'aicoder-workflow-artifacts-route-only',
+			requiredEvidence: ['AIQaBusinessAssertion tied to journey_contract.qa_assertions'],
+			requiredResetEvidence: ['new workflow proof fingerprint', 'fresh workflow QA artifact'],
+			successRequiresWorkflowBusinessProof: true,
+			blocksProductRepairUntilJourneyContract: false,
+			blocksPublishUntilWorkflowProof: true,
+			blocksPublishUntilReleaseGate: false,
+			blocksWowUiUntilWorkflowProof: true,
+			nextAction: 'Run workflow QA from the journey contract before publish or wow UI polish.'
+		},
+		nextActionContract: {
+			contractId: 'aicoder-next-route-only',
+			action: 'retry_same_step',
+			label: 'Run Workflow QA',
+			primaryCommand: 'run_aicoder_workflow_qa',
+			lane: 'qa',
+			stepType: 'workflow_qa',
+			safeToAutoRun: true,
+			requiresHumanApproval: false,
+			canRunWithoutCodexMonitor: true,
+			codexFallbackRequired: false,
+			costRisk: 'small_model_or_qa',
+			workflowFirstSatisfied: false,
+			decisionBasis: {
+				journeyContractReady: true,
+				workflowProofReady: false,
+				routeOnlyBlocked: true
+			},
+			preconditions: ['workflow QA rows generated from the journey contract'],
+			expectedStateTransition: 'Route/browser evidence becomes AIQaBusinessAssertion proof for the north-star workflow.',
+			successEvidence: ['AIQaBusinessAssertion tied to journey_contract.qa_assertions'],
+			stopConditions: ['Route-only proof must stay labeled as route evidence, not acceptance.'],
+			forbiddenActions: ['accepting route-only proof as app success'],
+			nextCommands: ['run_aicoder_workflow_qa', 'record_aiqa_business_assertion'],
+			blockers: ['Route-only proof blocks publish.']
+		}
+	},
+	qaEvidence: {
+		journeyContract: aicoderJourneyContract,
+		scorecardPassed: true,
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/dashboard/hub', status: 'pass' }],
+		deployStatus: 'pass',
+		publishStatus: 'published',
+		sampleDataStatus: 'pass'
+	}
+});
+assert.equal(aicoderRouteOnlyRun.outcome, 'false_pass');
+assert.equal(aicoderRouteOnlyRun.gates.some((gate) => gate.key === 'aicoder_workflow_proof_readiness' && gate.status === 'blocked'), true);
+assert.equal(aicoderRouteOnlyRun.gates.some((gate) => gate.key === 'aicoder_workflow_proof_checkpoint' && gate.status === 'blocked'), true);
+assert.equal(aicoderRouteOnlyRun.metadata?.workflowProofReadiness?.status, 'route_only');
+assert.equal(aicoderRouteOnlyRun.metadata?.workflowProofCheckpoint?.blocksPublishUntilWorkflowProof, true);
+assert.equal(aicoderRouteOnlyRun.metadata?.workflowProofCheckpoint?.blocksWowUiUntilWorkflowProof, true);
+assert.equal(aicoderRouteOnlyRun.events.some((event) => event.category === 'aicoder_workflow_proof_checkpoint'), true);
+assert.equal(aicoderRouteOnlyRun.gates.some((gate) => gate.key === 'aicoder_next_action_contract' && gate.status === 'pass'), true);
+assert.equal(aicoderRouteOnlyRun.metadata?.nextActionContract?.primaryCommand, 'run_aicoder_workflow_qa');
+assert.equal(aicoderRouteOnlyRun.metadata?.nextActionContract?.canRunWithoutCodexMonitor, true);
+assert.equal(aicoderRouteOnlyRun.metadata?.nextActionContract?.costRisk, 'small_model_or_qa');
+assert.equal(aicoderRouteOnlyRun.events.some((event) => event.category === 'aicoder_next_action_contract'), true);
+
+const aicoderCodexFallbackBlockedRun = buildAICoderAIRunFromEvidence({
+	app: { _id: 'codex-fallback-app', name: 'Codex Fallback Blocked App' },
+	job: {
+		_id: 'aicoder-codex-fallback-blocked',
+		phase: 'QA',
+		status: 'Running',
+		nextActionContract: {
+			contractId: 'aicoder-next-codex-fallback',
+			action: 'retry_same_step',
+			label: 'Run Scoped Repair',
+			primaryCommand: 'run_aicoder_owner_scoped_repair',
+			lane: 'repair',
+			stepType: 'repair',
+			safeToAutoRun: false,
+			requiresHumanApproval: false,
+			canRunWithoutCodexMonitor: false,
+			codexFallbackRequired: true,
+			codexFallbackReason: 'owner_files_or_workflow_proof_missing',
+			costRisk: 'expensive_model',
+			workflowFirstSatisfied: true,
+			blockers: ['Owner-file repair scope is missing.'],
+			stopConditions: ['Do not run repair without owner scope.'],
+			nextCommands: ['collect_aicoder_owner_scope']
+		}
+	},
+	qaEvidence: {
+		journeyContract: aicoderJourneyContract,
+		workflowQaRows: aicoderWorkflowQaRows,
+		scorecardPassed: false,
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/dashboard/hub', status: 'pass' }],
+		deployStatus: 'pass',
+		publishStatus: 'ready',
+		sampleDataStatus: 'pass',
+		businessAssertions: aicoderWorkflowBusinessAssertions
+	}
+});
+assert.equal(aicoderCodexFallbackBlockedRun.outcome, 'manual_handoff');
+assert.equal(aicoderCodexFallbackBlockedRun.gates.some((gate) => gate.key === 'aicoder_next_action_contract' && gate.status === 'blocked'), true);
+assert.equal(aicoderCodexFallbackBlockedRun.metadata?.nextActionContract?.canRunWithoutCodexMonitor, false);
+assert.equal(aicoderCodexFallbackBlockedRun.metadata?.nextActionContract?.codexFallbackRequired, true);
+assert.ok(/validated AICoder next-action contract/i.test(String(aicoderCodexFallbackBlockedRun.nextAction || '')));
+
+const aicoderMissingJourneyContractRun = buildAICoderAIRunFromEvidence({
+	app: { _id: 'missing-journey-app', name: 'Missing Journey App' },
+	job: {
+		_id: 'aicoder-missing-journey',
+		phase: 'COMPLETE',
+		status: 'Passed'
+	},
+	qaEvidence: {
+		scorecardPassed: true,
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/dashboard/hub', status: 'pass' }],
+		deployStatus: 'pass',
+		publishStatus: 'published',
+		sampleDataStatus: 'pass'
+	}
+});
+const aicoderMissingJourneyGate = aicoderMissingJourneyContractRun.gates.find((gate) => gate.key === 'aicoder_journey_contract');
+assert.equal(aicoderMissingJourneyContractRun.outcome, 'false_pass');
+assert.equal(aicoderMissingJourneyGate?.status, 'blocked');
+assert.equal(aicoderMissingJourneyGate?.metadata?.valid, false);
+assert.equal(aicoderMissingJourneyGate?.metadata?.blocksBuildUntilValid, true);
+assert.ok(Array.isArray(aicoderMissingJourneyGate?.metadata?.issueCodes));
+assert.ok((aicoderMissingJourneyGate?.metadata?.issueCodes || []).includes('missing_contract'));
+assert.equal(aicoderMissingJourneyContractRun.metadata?.journeyContract?.valid, false);
+assert.equal(aicoderMissingJourneyContractRun.metadata?.workflowProofReadiness?.status, 'missing_journey_contract');
+assert.equal(classifyAIRunFailureClass(aicoderMissingJourneyContractRun), 'journey_contract');
+const aicoderMissingJourneyRetry = decideAIRunRetry({ currentRun: aicoderMissingJourneyContractRun });
+assert.equal(aicoderMissingJourneyRetry.action, 'retry_journey_contract');
+assert.match(String(aicoderMissingJourneyRetry.nextAction || ''), /APP_JOURNEY_CONTRACT/i);
+assert.equal(aicoderMissingJourneyContractRun.events.some((event) => event.category === 'aicoder_journey_contract'), true);
+
+const aicoderRepeatedJourneyRun = buildAICoderAIRunFromEvidence({
+	app: { _id: 'repeated-journey-app', name: 'Repeated Journey App' },
+	job: {
+		_id: 'aicoder-repeated-journey',
+		phase: 'Build',
+		status: 'Running',
+		aicoderV6Budget: { maxRepeatedNoProgress: 2 },
+		aicoderV6StepHistory: [{
+			lane: 'aicoder',
+			stepType: 'journey_validation',
+			outcome: 'needs_repair',
+			failureClass: 'workflow',
+			blocker: 'Journey contract still has no last saved/exported result.',
+			evidenceHash: 'journey-missing-final-result',
+			artifactPaths: ['qa/journey-contract-review.json']
+		}, {
+			lane: 'aicoder',
+			stepType: 'journey_validation',
+			outcome: 'needs_repair',
+			failureClass: 'workflow',
+			blocker: 'Journey contract still has no last saved/exported result.',
+			evidenceHash: 'journey-missing-final-result',
+			artifactPaths: ['qa/journey-contract-review.json']
+		}]
+	},
+	qaEvidence: {
+		journeyContract: aicoderJourneyContract,
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/dashboard/hub', status: 'pass' }]
+	}
+});
+const aicoderRepeatedJourneyGate = aicoderRepeatedJourneyRun.gates.find((gate) => gate.key === 'manager_no_blind_loop_policy');
+assert.equal(aicoderRepeatedJourneyGate?.status, 'blocked');
+assert.equal(aicoderRepeatedJourneyGate?.metadata?.action, 'park_repeated_failure');
+assert.equal(aicoderRepeatedJourneyGate?.metadata?.requiresNewEvidence, true);
+assert.equal(aicoderRepeatedJourneyGate?.metadata?.productRepairAllowed, false);
+assert.equal(aicoderRepeatedJourneyRun.outcome, 'manual_handoff');
+assert.equal(aicoderRepeatedJourneyRun.events.some((event) => event.category === 'manager_no_blind_loop_policy'), true);
+assert.equal(aicoderRepeatedJourneyRun.metadata?.managerNoBlindLoopPolicy?.requiresNewEvidence, true);
+
+const aicoderInfraRetryRun = buildAICoderAIRunFromEvidence({
+	app: { _id: 'aicoder-infra-retry-app', name: 'AICoder Infra Retry App' },
+	job: {
+		_id: 'aicoder-infra-retry',
+		phase: 'QA',
+		status: 'Running',
+		aicoderV6StepHistory: [{
+			lane: 'qa',
+			stepType: 'workflow_qa',
+			outcome: 'needs_repair',
+			failureClass: 'infra',
+			blocker: 'Puppeteer module is missing before workflow QA can run.',
+			evidenceHash: 'puppeteer-module-missing',
+			artifactPaths: ['qa/puppeteer-preflight.log']
+		}]
+	},
+	qaEvidence: {
+		infraChecks: [{
+			name: 'puppeteer_require',
+			status: 'blocked',
+			message: 'Cannot find module puppeteer.',
+			path: 'qa/puppeteer-preflight.log'
+		}]
+	}
+});
+const aicoderInfraRetryGate = aicoderInfraRetryRun.gates.find((gate) => gate.key === 'manager_no_blind_loop_policy');
+assert.equal(aicoderInfraRetryGate?.status, 'warn');
+assert.equal(aicoderInfraRetryGate?.metadata?.action, 'retry_infra');
+assert.equal(aicoderInfraRetryGate?.metadata?.productRepairFailure, false);
+assert.equal(aicoderInfraRetryGate?.metadata?.dispatchAction, 'run_infra_repair');
+assert.equal(aicoderInfraRetryRun.outcome, 'qa_infra_failed');
+
+const aicoderFreshProofRun = buildAICoderAIRunFromEvidence({
+	app: { _id: 'fresh-proof-app', name: 'Fresh Proof App' },
+	job: { _id: 'aicoder-fresh-proof', phase: 'COMPLETE', status: 'Passed' },
+	qaEvidence: {
+		journeyContract: aicoderJourneyContract,
+		workflowQaRows: aicoderWorkflowQaRows,
+		scorecardPassed: true,
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/dashboard/hub', status: 'pass' }],
+		deployStatus: 'pass',
+		publishStatus: 'published',
+		sampleDataStatus: 'pass',
+		businessAssertions: aicoderWorkflowBusinessAssertions
+	}
+});
+const freshProofFingerprint = String(aicoderFreshProofRun.metadata?.workflowProofReadiness?.workflowProofFingerprint || '');
+assert.match(freshProofFingerprint, /^aicoder-workflow-proof-/);
+
+const aicoderStaleProofRun = buildAICoderAIRunFromEvidence({
+	app: { _id: 'stale-proof-app', name: 'Stale Proof App' },
+	job: { _id: 'aicoder-stale-proof', phase: 'COMPLETE', status: 'Passed' },
+	qaEvidence: {
+		journeyContract: aicoderJourneyContract,
+		workflowQaRows: aicoderWorkflowQaRows,
+		scorecardPassed: true,
+		compile: { status: 'pass' },
+		routeProbes: [{ route: '/dashboard/hub', status: 'pass' }],
+		deployStatus: 'pass',
+		publishStatus: 'published',
+		sampleDataStatus: 'pass',
+		previousWorkflowProofFingerprint: freshProofFingerprint,
+		businessAssertions: aicoderWorkflowBusinessAssertions
+	}
+});
+assert.equal(aicoderStaleProofRun.metadata?.workflowProofReadiness?.status, 'stale_workflow_proof');
+assert.equal(aicoderStaleProofRun.metadata?.workflowProofReadiness?.proofFreshness, 'same_as_previous');
+assert.equal(aicoderStaleProofRun.gates.some((gate) => gate.key === 'aicoder_workflow_proof_readiness' && gate.status === 'blocked'), true);
+
+const assistantRun = buildAssistantAIRunFromEvidence({
+	conversation: { _id: 'conversation-1', title: 'Invoice query', status: 'Closed', accepted: true },
+	messages: [{ role: 'assistant', content: 'Used the current date window.' }],
+	answerQuality: {
+		queryStatus: 'ok',
+		requiresCurrentDate: true,
+		currentDateUsed: '2026-06-16',
+		expectedCurrentDate: '2026-06-16',
+		legalQueryShape: true,
+		queryExecutions: [{
+			id: 'tool-result-invoices-june-2026',
+			tool: 'aiAssistantMongoRead',
+			status: 'ok',
+			collection: 'invoices',
+			resultCount: 3
+		}],
+		citations: [{ id: 'tool-result-invoices-june-2026' }],
+		confidence: { level: 'high' },
+		nextActions: ['Review the returned June 2026 invoice rows.']
+	},
+	correctnessChecks: [{
+		assertion: 'Date window uses the actual current month.',
+		status: 'pass',
+		expected: 'June 2026',
+		observed: 'June 2026'
+	}],
+	usageLedger: [{
+		model: 'gpt-5.4-mini',
+		category: 'assistant',
+		usage_source: 'runner',
+		usage_surface: 'assistant',
+		input_tokens: 500,
+		output_tokens: 120,
+		cost_estimate: 0.18
+	}]
+});
+assert.equal(assistantRun.source, 'ai_assistant');
+assert.equal(assistantRun.outcome, 'accepted');
+assert.equal(assistantRun.gates.some((gate) => gate.key === 'assistant_answer_quality' && gate.status === 'pass'), true);
+assert.equal(assistantRun.gates.some((gate) => gate.key === 'assistant_answer_actionability' && gate.status === 'pass'), true);
+assert.equal(assistantRun.gates.some((gate) => gate.key === 'cost_observability' && gate.status === 'pass'), true);
+assert.equal(assistantRun.metadata?.costObservability?.externalCodexMonitorUsed, false);
+assert.equal(assistantRun.metadata?.costObservability?.estimatedUsd, 0.18);
+assert.equal(assistantRun.metadata?.answerQuality?.queryStatus, 'ok');
+assert.equal(assistantRun.metadata?.answerQuality?.queryEvidencePresent, true);
+assert.equal(assistantRun.metadata?.answerActionability?.primaryCommand, 'answer_from_verified_system_data');
+assert.equal(assistantRun.metadata?.answerActionability?.canAnswerCustomer, true);
+assert.equal(assistantRun.metadata?.answerActionability?.canRunWithoutCodexMonitor, true);
+assert.equal(assistantRun.events.some((event) => event.type === 'assistant_query' && event.metadata?.collection === 'invoices'), true);
+assert.equal(assistantRun.events.some((event) => event.category === 'assistant_answer_actionability'), true);
+
+const assistantNoDataRun = buildAssistantAIRunFromEvidence({
+	conversation: { _id: 'conversation-no-data', title: 'No invoice query', status: 'Closed', accepted: true },
+	messages: [{ role: 'assistant', content: 'No invoices were found for June 2026.' }],
+	answerQuality: {
+		queryStatus: 'no_data',
+		noDataConfirmed: true,
+		requiresCurrentDate: true,
+		currentDateUsed: '2026-06-16',
+		expectedCurrentDate: '2026-06-16',
+		legalQueryShape: true,
+		queryExecutions: [{
+			id: 'tool-result-empty-invoices-june-2026',
+			tool: 'aiAssistantMongoRead',
+			status: 'no_data',
+			collection: 'invoices',
+			resultCount: 0
+		}],
+		citationRefs: ['tool-result-empty-invoices-june-2026'],
+		confidenceLevel: 'high',
+		nextActions: ['Verify the date range or customer filter if invoices were expected.']
+	}
+});
+assert.equal(assistantNoDataRun.outcome, 'accepted');
+assert.equal(assistantNoDataRun.metadata?.answerQuality?.queryStatus, 'no_data');
+assert.equal(assistantNoDataRun.metadata?.answerQuality?.noDataConfirmed, true);
+assert.equal(assistantNoDataRun.metadata?.answerQuality?.queryEvidencePresent, true);
+assert.equal(assistantNoDataRun.metadata?.answerActionability?.status, 'ready_to_answer');
+assert.equal(assistantNoDataRun.metadata?.answerActionability?.queryResultClass, 'no_data');
+assert.equal(assistantNoDataRun.metadata?.answerActionability?.canAnswerCustomer, true);
+
+const assistantCitationOnlyRun = buildAssistantAIRunFromEvidence({
+	conversation: { _id: 'conversation-citation-only', title: 'Citation-only answer', status: 'Closed', accepted: true },
+	messages: [{ role: 'assistant', content: 'Found invoices for June 2026.' }],
+	answerQuality: {
+		queryStatus: 'ok',
+		requiresCurrentDate: true,
+		currentDateUsed: '2026-06-16',
+		expectedCurrentDate: '2026-06-16',
+		legalQueryShape: true,
+		citationRefs: ['tool-result-invoices-june-2026'],
+		confidenceLevel: 'high',
+		nextActions: ['Open the invoice list.']
+	}
+});
+assert.notEqual(assistantCitationOnlyRun.outcome, 'accepted');
+assert.equal(assistantCitationOnlyRun.metadata?.answerQuality?.status, 'missing_query_proof');
+assert.equal(assistantCitationOnlyRun.metadata?.answerQuality?.queryEvidenceRequired, true);
+assert.equal(assistantCitationOnlyRun.metadata?.answerQuality?.queryEvidencePresent, false);
+assert.equal(assistantCitationOnlyRun.gates.some((gate) => gate.key === 'assistant_answer_actionability' && gate.status === 'blocked'), true);
+assert.equal(assistantCitationOnlyRun.metadata?.answerActionability?.status, 'needs_evidence');
+assert.equal(assistantCitationOnlyRun.metadata?.answerActionability?.primaryCommand, 'collect_assistant_answer_evidence');
+assert.ok(assistantCitationOnlyRun.metadata?.answerActionability?.forbiddenActions.some((entry: string) => /keyword or route guesses/i.test(entry)));
+assert.equal(assistantCitationOnlyRun.outcome, 'false_pass');
+assert.equal(classifyAIRunFailureClass(assistantCitationOnlyRun), 'assistant_missing_evidence');
+assert.equal(decideAIRunRetry({ currentRun: assistantCitationOnlyRun }).action, 'retry_assistant_answer_quality');
+
+const assistantWrongDateRun = buildAssistantAIRunFromEvidence({
+	conversation: { _id: 'conversation-wrong-date', title: 'Wrong month query', status: 'Closed', accepted: true },
+	messages: [{ role: 'assistant', content: 'Used May 2026.' }],
+	answerQuality: {
+		queryStatus: 'ok',
+		requiresCurrentDate: true,
+		currentDateUsed: '2026-05-01',
+		expectedCurrentDate: '2026-06-16',
+		legalQueryShape: true,
+		citationRefs: ['tool-result-wrong-month'],
+		confidenceLevel: 'high',
+		nextActions: ['Rerun using the actual current date.']
+	}
+});
+assert.notEqual(assistantWrongDateRun.outcome, 'accepted');
+assert.equal(assistantWrongDateRun.gates.some((gate) => gate.key === 'assistant_answer_quality' && gate.status === 'fail'), true);
+assert.equal(assistantWrongDateRun.metadata?.answerQuality?.status, 'date_incorrect');
+assert.equal(classifyAIRunFailureClass(assistantWrongDateRun), 'assistant_date_window');
+assert.equal(decideAIRunRetry({ currentRun: assistantWrongDateRun }).action, 'retry_assistant_date_window');
+
+const assistantMissingDateWindowRun = buildAssistantAIRunFromEvidence({
+	conversation: { _id: 'conversation-missing-window', title: 'Missing date window', status: 'Closed', accepted: true },
+	messages: [{ role: 'assistant', content: 'Used the current date but did not record the query window.' }],
+	answerQuality: {
+		queryStatus: 'ok',
+		requiresCurrentDate: true,
+		currentDateUsed: '2026-06-16',
+		expectedCurrentDate: '2026-06-16',
+		requiresDateWindow: true,
+		citationRefs: ['tool-result-no-window'],
+		confidenceLevel: 'high',
+		nextActions: ['Rerun with concrete date-window evidence.']
+	}
+});
+assert.notEqual(assistantMissingDateWindowRun.outcome, 'accepted');
+assert.equal(assistantMissingDateWindowRun.gates.some((gate) => gate.key === 'assistant_answer_quality' && gate.status === 'fail'), true);
+assert.equal(assistantMissingDateWindowRun.metadata?.answerQuality?.status, 'missing_date_window');
+assert.equal(assistantMissingDateWindowRun.metadata?.answerQuality?.dateWindowRequired, true);
+assert.equal(assistantMissingDateWindowRun.metadata?.answerQuality?.dateWindowPresent, false);
+assert.equal(classifyAIRunFailureClass(assistantMissingDateWindowRun), 'assistant_date_window');
+assert.equal(decideAIRunRetry({ currentRun: assistantMissingDateWindowRun }).action, 'retry_assistant_date_window');
+
+const assistantIllegalProjectionRun = buildAssistantAIRunFromEvidence({
+	conversation: { _id: 'conversation-illegal-query', title: 'Illegal Mongo projection', status: 'Closed', accepted: true },
+	messages: [{ role: 'assistant', content: 'Mongo query failed.' }],
+	answerQuality: {
+		queryStatus: 'ok',
+		requiresCurrentDate: false,
+		mongoQuery: {
+			collection: 'invoices',
+			filter: { customerId: 'customer-1' },
+			projection: { 'lineItems.$.amount': 1 }
+		},
+		citationRefs: ['tool-result-illegal-projection'],
+		confidenceLevel: 'high',
+		nextActions: ['Rewrite the projection using a legal aggregation or full field projection.']
+	}
+});
+assert.notEqual(assistantIllegalProjectionRun.outcome, 'accepted');
+assert.equal(assistantIllegalProjectionRun.metadata?.answerQuality?.status, 'illegal_query_shape');
+assert.equal(classifyAIRunFailureClass(assistantIllegalProjectionRun), 'assistant_query_shape');
+assert.equal(decideAIRunRetry({ currentRun: assistantIllegalProjectionRun }).action, 'retry_assistant_query_shape');
+
+const assistantQueryErrorRun = buildAssistantAIRunFromEvidence({
+	conversation: { _id: 'conversation-query-error', title: 'Query error answer', status: 'Closed', accepted: true },
+	messages: [{ role: 'assistant', content: 'No invoices were found.' }],
+	answerQuality: {
+		queryStatus: 'query_error',
+		requiresCurrentDate: false,
+		legalQueryShape: true,
+		citationRefs: ['tool-result-query-error'],
+		confidenceLevel: 'high',
+		nextActions: ['Fix the query error and retry before answering.']
+	}
+});
+assert.notEqual(assistantQueryErrorRun.outcome, 'accepted');
+assert.equal(assistantQueryErrorRun.gates.some((gate) => gate.key === 'assistant_answer_quality' && gate.status === 'blocked'), true);
+assert.equal(assistantQueryErrorRun.gates.some((gate) => gate.key === 'assistant_answer_actionability' && gate.status === 'blocked'), true);
+assert.equal(assistantQueryErrorRun.metadata?.answerQuality?.queryStatus, 'query_error');
+assert.equal(assistantQueryErrorRun.metadata?.answerActionability?.primaryCommand, 'repair_assistant_query_and_rerun');
+assert.equal(assistantQueryErrorRun.metadata?.answerActionability?.canAnswerCustomer, false);
+assert.equal(classifyAIRunFailureClass(assistantQueryErrorRun), 'assistant_query_error');
+assert.equal(decideAIRunRetry({ currentRun: assistantQueryErrorRun }).action, 'retry_assistant_query');
+
+const assistantPermissionErrorRun = buildAssistantAIRunFromEvidence({
+	conversation: { _id: 'conversation-permission-error', title: 'Permission error answer', status: 'Closed', accepted: true },
+	messages: [{ role: 'assistant', content: 'No invoices were found.' }],
+	answerQuality: {
+		queryStatus: 'permission_error',
+		requiresCurrentDate: false,
+		citationRefs: ['tool-result-permission-error'],
+		confidenceLevel: 'high',
+		nextActions: ['Ask an authorized user to grant invoice access before answering.']
+	}
+});
+assert.notEqual(assistantPermissionErrorRun.outcome, 'accepted');
+assert.equal(assistantPermissionErrorRun.gates.some((gate) => gate.key === 'assistant_answer_quality' && gate.status === 'blocked'), true);
+assert.equal(assistantPermissionErrorRun.metadata?.answerQuality?.queryStatus, 'permission_error');
+assert.equal(assistantPermissionErrorRun.metadata?.answerActionability?.primaryCommand, 'request_assistant_data_permission');
+assert.equal(assistantPermissionErrorRun.metadata?.answerActionability?.costRisk, 'manual_blocked');
+assert.equal(classifyAIRunFailureClass(assistantPermissionErrorRun), 'assistant_permission');
+assert.equal(decideAIRunRetry({ currentRun: assistantPermissionErrorRun }).action, 'request_assistant_permission');
+
+const assistantMissingQualityRun = buildAssistantAIRunFromEvidence({
+	conversation: { _id: 'conversation-missing-quality', title: 'Missing assistant answerQuality', status: 'Closed', accepted: true },
+	messages: [{ role: 'assistant', content: 'Invoices look fine.' }]
+});
+assert.notEqual(assistantMissingQualityRun.outcome, 'accepted');
+assert.equal(assistantMissingQualityRun.gates.some((gate) => gate.key === 'assistant_answer_quality' && gate.status === 'blocked'), true);
+assert.equal(assistantMissingQualityRun.metadata?.answerQuality?.status, 'missing_data_source');
+assert.equal(classifyAIRunFailureClass(assistantMissingQualityRun), 'assistant_missing_evidence');
+assert.equal(decideAIRunRetry({ currentRun: assistantMissingQualityRun }).action, 'retry_assistant_answer_quality');
+
+const assistantAnswerRun = buildAssistantAIRunFromEvidence({
+	runId: 'ai-run:ai_assistant:chat:conversation-1:message-2',
+	requestId: 'request-1',
+	messageId: 'message-2',
+	conversation: { _id: 'conversation-1', title: 'Invoice query', status: 'Closed' },
+	messages: [
+		{ _id: 'message-1', role: 'user', content: 'Show invoices for this month.' },
+		{
+			_id: 'message-2',
+			role: 'assistant',
+			content: 'Found 3 invoices for June 2026.',
+			usage: { model: 'gpt-5.4-mini' }
+		}
+	],
+	answerQuality: {
+		queryStatus: 'ok',
+		requiresCurrentDate: true,
+		currentDateUsed: '2026-06-16',
+		expectedCurrentDate: '2026-06-16',
+		legalQueryShape: true,
+		queryExecutions: [{
+			id: 'tool-result-invoices-june-2026',
+			tool: 'aiAssistantMongoRead',
+			status: 'ok',
+			collection: 'invoices',
+			resultCount: 3
+		}],
+		citationRefs: ['tool-result-invoices-june-2026'],
+		confidenceLevel: 'high',
+		nextActions: ['Open the invoice list filtered to June 2026.']
+	},
+	usageLedger: [{
+		model: 'gpt-5.4-mini',
+		category: 'ai-terminal',
+		usage_source: 'ai_assistant',
+		usage_surface: 'assistant',
+		usage_phase: 'chat',
+		input_tokens: 100,
+		output_tokens: 50,
+		total_tokens: 150,
+		cost_estimate: 0.02
+	}]
+});
+assert.equal(assistantAnswerRun.id, 'ai-run:ai_assistant:chat:conversation-1:message-2');
+assert.equal(assistantAnswerRun.sourceIds.requestId, 'request-1');
+assert.equal(assistantAnswerRun.sourceIds.messageId, 'message-2');
+assert.equal(assistantAnswerRun.events.some((event) => event.type === 'assistant_message' && event.metadata?.model === 'gpt-5.4-mini'), true);
+assert.equal(assistantAnswerRun.events.some((event) => event.type === 'assistant_query' && event.metadata?.id === 'tool-result-invoices-june-2026'), true);
+assert.equal(assistantAnswerRun.cost?.surfaces?.assistant.estimatedUsd, 0.02);
+
+console.log('ai run evidence tests passed');