@resolveio/server-lib 22.3.197 → 22.3.199

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

@@ -1,2129 +0,0 @@
-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 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,
-			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,
-				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: 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 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_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.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 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 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 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 },
-		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 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' },
-	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);
-
-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: [{
-		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.'
-	}, {
-		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.'
-	}, {
-		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',
-		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',
-		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',
-		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',
-		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',
-		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 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');