@resolveio/server-lib 22.3.141 → 22.3.142

package/tests/ai-manager-autopilot-snapshot.test.ts

@@ -0,0 +1,172 @@
+import * as assert from 'node:assert/strict';
+import {
+	buildResolveIOAIManagerAutopilotSnapshot
+} from '../src/util/ai-runner-manager-autopilot';
+import {
+	appendResolveIOAIManagerRecoveryActionDispatch,
+	buildResolveIOAIManagerRecoveryActionPacket,
+	buildResolveIOAIManagerRecoveryCheckpoint,
+	buildResolveIOAIManagerRecoveryEvidenceProbe,
+	buildResolveIOAIManagerRecoveryExecutionDirective,
+	buildResolveIOAIManagerRecoveryPlan,
+	decideResolveIOAIManagerRecoveryActionDispatch
+} from '../src/util/ai-runner-manager-policy';
+
+const current = {
+	lane: 'qa',
+	stepType: 'workflow_qa',
+	failureClass: 'business',
+	blocker: 'Workflow save button shows success but the saved recommendation is not persisted.',
+	evidenceHash: 'workflow-save-same-proof',
+	artifactPaths: ['qa/workflow-save-before.png']
+};
+const plan = buildResolveIOAIManagerRecoveryPlan({
+	action: 'park_ping_pong',
+	reason: 'workflow proof alternated between two failed save patches',
+	failureClass: 'business',
+	lane: 'qa',
+	stepType: 'workflow_qa',
+	blocker: current.blocker,
+	artifactPaths: current.artifactPaths,
+	productRepairFailure: true
+});
+const checkpoint = buildResolveIOAIManagerRecoveryCheckpoint({
+	plan,
+	current,
+	now: '2026-06-15T00:00:00.000Z'
+});
+const probe = buildResolveIOAIManagerRecoveryEvidenceProbe({
+	checkpoint,
+	current,
+	now: '2026-06-15T00:00:30.000Z'
+});
+const action = buildResolveIOAIManagerRecoveryActionPacket({
+	plan,
+	checkpoint,
+	probe,
+	current,
+	now: '2026-06-15T00:01:00.000Z'
+});
+const firstDispatch = decideResolveIOAIManagerRecoveryActionDispatch({
+	action,
+	current,
+	now: '2026-06-15T00:02:00.000Z'
+});
+const directive = buildResolveIOAIManagerRecoveryExecutionDirective({
+	action,
+	dispatchDecision: firstDispatch,
+	current,
+	surface: 'aicoder_builder',
+	now: '2026-06-15T00:02:00.000Z'
+});
+
+const firstSnapshot = buildResolveIOAIManagerAutopilotSnapshot({
+	surface: 'aicoder_builder',
+	runId: 'job-1',
+	title: 'Layflat Pressure Optimizer',
+	status: 'parked',
+	phase: 'qa',
+	runKind: 'initial_builder',
+	current,
+	recoveryPlan: plan,
+	recoveryCheckpoint: checkpoint,
+	recoveryEvidenceProbe: probe,
+	recoveryAction: action,
+	recoveryDirective: directive,
+	recoveryDispatchHistory: [],
+	loopCount: 3,
+	maxLoopCount: 3,
+	totalUsd: 42.5,
+	totalTokens: 125000,
+	updatedAt: '2026-06-15T00:02:00.000Z'
+});
+
+assert.equal(firstSnapshot.surface, 'aicoder_builder');
+assert.equal(firstSnapshot.recommendedAction.action, 'run_evidence_probe');
+assert.equal(firstSnapshot.recommendedAction.label, 'Collect New Evidence');
+assert.equal(firstSnapshot.recommendedAction.enabled, true);
+assert.equal(firstSnapshot.recommendedAction.safety, 'low');
+assert.equal(firstSnapshot.recommendedAction.canRunProductRepair, false);
+assert.equal(firstSnapshot.recommendedAction.requiresNewEvidence, true);
+assert.equal(firstSnapshot.loopGuard.state, 'collecting_evidence');
+assert.equal(firstSnapshot.loopGuard.sameEvidenceAlreadyAttempted, false);
+assert.equal(firstSnapshot.recovery.evidenceOnly, true);
+assert.equal(firstSnapshot.recovery.requiredArtifacts.some((entry) => /current-blocker|business-assertion/i.test(entry)), true);
+assert.equal(firstSnapshot.cost.totalUsd, 42.5);
+assert.match(firstSnapshot.cost.untrackedWarning, /Manual Codex/i);
+
+const completedHistory = appendResolveIOAIManagerRecoveryActionDispatch([], firstDispatch.dispatchRecord
+	? {
+		...firstDispatch.dispatchRecord,
+		status: 'completed',
+		completedAt: '2026-06-15T00:03:00.000Z'
+	}
+	: undefined);
+const repeatDispatch = decideResolveIOAIManagerRecoveryActionDispatch({
+	action,
+	history: completedHistory,
+	current,
+	now: '2026-06-15T00:04:00.000Z'
+});
+const repeatDirective = buildResolveIOAIManagerRecoveryExecutionDirective({
+	action,
+	dispatchDecision: repeatDispatch,
+	current,
+	surface: 'aicoder_builder',
+	now: '2026-06-15T00:04:00.000Z'
+});
+const repeatedSnapshot = buildResolveIOAIManagerAutopilotSnapshot({
+	surface: 'aicoder_builder',
+	runId: 'job-1',
+	title: 'Layflat Pressure Optimizer',
+	status: 'parked',
+	phase: 'qa',
+	runKind: 'initial_builder',
+	current,
+	recoveryPlan: plan,
+	recoveryCheckpoint: checkpoint,
+	recoveryEvidenceProbe: probe,
+	recoveryAction: action,
+	recoveryDirective: repeatDirective,
+	recoveryDispatchHistory: completedHistory,
+	loopCount: 3,
+	maxLoopCount: 3
+});
+
+assert.equal(repeatedSnapshot.recommendedAction.action, 'park_manual');
+assert.equal(repeatedSnapshot.recommendedAction.enabled, false);
+assert.equal(repeatedSnapshot.recommendedAction.safety, 'blocked');
+assert.equal(repeatedSnapshot.loopGuard.state, 'parked');
+assert.equal(repeatedSnapshot.loopGuard.sameEvidenceAlreadyAttempted, true);
+assert.equal(repeatedSnapshot.loopGuard.sameEvidenceDispatchCount, 1);
+assert.match(repeatedSnapshot.recommendedAction.reason, /same recovery action already ran/i);
+assert.equal(repeatedSnapshot.recommendedAction.canRunProductRepair, false);
+
+const newEvidenceSnapshot = buildResolveIOAIManagerAutopilotSnapshot({
+	surface: 'aicoder_app_dashboard_terminal',
+	runId: 'conversation-1',
+	title: 'AI terminal repair',
+	status: 'parked',
+	phase: 'repair',
+	runKind: 'terminal_helper',
+	current: {
+		...current,
+		lane: 'repair',
+		stepType: 'repair',
+		evidenceHash: 'workflow-save-after-network-trace',
+		artifactPaths: ['qa/workflow-save-before.png', 'qa/workflow-save-network-trace.json']
+	},
+	recoveryPlan: plan,
+	recoveryCheckpoint: checkpoint,
+	recoveryEvidenceProbe: probe,
+	recoveryAction: action,
+	recoveryDirective: directive,
+	recoveryDispatchHistory: completedHistory
+});
+
+assert.equal(newEvidenceSnapshot.surface, 'aicoder_app_dashboard_terminal');
+assert.equal(newEvidenceSnapshot.recommendedAction.enabled, true);
+assert.equal(newEvidenceSnapshot.loopGuard.sameEvidenceAlreadyAttempted, false);
+assert.equal(newEvidenceSnapshot.recommendedAction.canResetLoopAfterEvidence, true);
+
+console.log('ai manager autopilot snapshot tests passed');

package/tests/ai-manager-recovery-checkpoint.test.ts

@@ -0,0 +1,323 @@
+import * as assert from 'node:assert/strict';
+import {
+	buildResolveIOAIManagerRecoveryCheckpoint,
+	buildResolveIOAIManagerRecoveryActionPacket,
+	buildResolveIOAIManagerRecoveryEvidenceProbe,
+	buildResolveIOAIManagerRecoveryPlan,
+	appendResolveIOAIManagerRecoveryActionDispatch,
+	buildResolveIOAIManagerRecoveryExecutionDirective,
+	decideResolveIOAIManagerRecoveryActionDispatch,
+	decideResolveIOAIManagerRecoveryGate
+} from '../src/util/ai-runner-manager-policy';
+
+const parkedPlan = buildResolveIOAIManagerRecoveryPlan({
+	action: 'park_repeated_failure',
+	reason: 'same blocker repeated without new proof',
+	failureClass: 'product_code',
+	lane: 'repair',
+	stepType: 'repair',
+	blocker: 'Save action still throws TypeError.',
+	artifactPaths: ['qa/save-before.log'],
+	maxSameFailureRepeats: 2,
+	productRepairFailure: true
+});
+
+const parkedCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint({
+	plan: parkedPlan,
+	current: {
+		lane: 'repair',
+		stepType: 'repair',
+		failureClass: 'product_code',
+		blocker: 'Save action still throws TypeError.',
+		evidenceHash: 'save-typeerror-before',
+		artifactPaths: ['qa/save-before.log']
+	},
+	now: '2026-06-15T00:00:00.000Z'
+});
+
+assert.equal(parkedCheckpoint.status, 'parked');
+assert.equal(parkedCheckpoint.recoveryClass, 'blocked_until_new_evidence');
+assert.equal(parkedCheckpoint.allowedAction, 'collect_new_evidence_only');
+
+const parkedEvidenceProbe = buildResolveIOAIManagerRecoveryEvidenceProbe({
+	checkpoint: parkedCheckpoint
+});
+const parkedAction = buildResolveIOAIManagerRecoveryActionPacket({
+	checkpoint: parkedCheckpoint,
+	probe: parkedEvidenceProbe
+});
+
+assert.equal(parkedEvidenceProbe.evidenceOnly, true);
+assert.equal(parkedEvidenceProbe.productRepairAllowed, false);
+assert.equal(parkedEvidenceProbe.expensiveModelAllowed, false);
+assert.ok(parkedEvidenceProbe.steps.some((step) => step.kind === 'rerun_same_gate'));
+assert.ok(parkedEvidenceProbe.stopConditions.some((entry) => /product-code repair/i.test(entry)));
+assert.equal(parkedAction.mode, 'collect_evidence');
+assert.equal(parkedAction.evidenceOnly, true);
+assert.equal(parkedAction.productRepairAllowed, false);
+assert.equal(parkedAction.retryPolicy.requireNewEvidence, true);
+assert.ok(parkedAction.nextCommands.some((command) => /rerun_same_gate|snapshot_current_blocker/i.test(command)));
+
+const firstDispatch = decideResolveIOAIManagerRecoveryActionDispatch({
+	action: parkedAction,
+	current: {
+		lane: 'repair',
+		stepType: 'repair',
+		failureClass: 'product_code',
+		blocker: 'Save action still throws TypeError.',
+		evidenceHash: 'save-typeerror-before',
+		artifactPaths: ['qa/save-before.log']
+	},
+	now: '2026-06-15T00:01:00.000Z'
+});
+
+assert.equal(firstDispatch.allowed, true);
+assert.equal(firstDispatch.dispatchAction, 'run_evidence_probe');
+assert.equal(firstDispatch.canRunProductRepair, false);
+assert.equal(firstDispatch.shouldRecordDispatch, true);
+assert.equal(firstDispatch.dispatchRecord?.status, 'started');
+
+const firstDirective = buildResolveIOAIManagerRecoveryExecutionDirective({
+	action: parkedAction,
+	dispatchDecision: firstDispatch,
+	current: {
+		lane: 'repair',
+		stepType: 'repair',
+		failureClass: 'product_code',
+		blocker: 'Save action still throws TypeError.',
+		evidenceHash: 'save-typeerror-before',
+		artifactPaths: ['qa/save-before.log']
+	},
+	surface: 'aicoder_builder',
+	now: '2026-06-15T00:01:00.000Z'
+});
+
+assert.equal(firstDirective.allowed, true);
+assert.equal(firstDirective.phase, 'evidence');
+assert.equal(firstDirective.canRunProductRepair, false);
+assert.match(firstDirective.rerunReason, /MANAGER_RECOVERY:run_evidence_probe/);
+assert.ok(firstDirective.forbiddenActions.some((entry) => /product-code repair/i.test(entry)));
+
+const completedDispatchHistory = appendResolveIOAIManagerRecoveryActionDispatch([], {
+	...firstDispatch.dispatchRecord!,
+	status: 'completed',
+	completedAt: '2026-06-15T00:02:00.000Z'
+});
+const repeatedDispatch = decideResolveIOAIManagerRecoveryActionDispatch({
+	action: parkedAction,
+	history: completedDispatchHistory,
+	current: {
+		lane: 'repair',
+		stepType: 'repair',
+		failureClass: 'product_code',
+		blocker: 'Save action still throws TypeError.',
+		evidenceHash: 'save-typeerror-before',
+		artifactPaths: ['qa/save-before.log']
+	},
+	now: '2026-06-15T00:03:00.000Z'
+});
+
+assert.equal(repeatedDispatch.allowed, false);
+assert.equal(repeatedDispatch.dispatchAction, 'park_manual');
+assert.equal(repeatedDispatch.reason, 'recovery_dispatch_same_evidence_already_attempted');
+assert.equal(repeatedDispatch.requiresNewEvidence, true);
+
+const repeatedDirective = buildResolveIOAIManagerRecoveryExecutionDirective({
+	action: parkedAction,
+	dispatchDecision: repeatedDispatch,
+	current: {
+		lane: 'repair',
+		stepType: 'repair',
+		failureClass: 'product_code',
+		blocker: 'Save action still throws TypeError.',
+		evidenceHash: 'save-typeerror-before',
+		artifactPaths: ['qa/save-before.log']
+	},
+	surface: 'aicoder_builder',
+	now: '2026-06-15T00:03:00.000Z'
+});
+
+assert.equal(repeatedDirective.allowed, false);
+assert.equal(repeatedDirective.phase, 'manual');
+assert.equal(repeatedDirective.dispatchAction, 'park_manual');
+assert.equal(repeatedDirective.requiresNewEvidence, true);
+
+const newEvidenceDispatch = decideResolveIOAIManagerRecoveryActionDispatch({
+	action: parkedAction,
+	history: completedDispatchHistory,
+	current: {
+		lane: 'repair',
+		stepType: 'repair',
+		failureClass: 'product_code',
+		blocker: 'Save action still throws TypeError.',
+		evidenceHash: 'save-typeerror-after-dom-trace',
+		artifactPaths: ['qa/save-before.log', 'qa/save-after-dom-trace.json']
+	},
+	now: '2026-06-15T00:04:00.000Z'
+});
+
+assert.equal(newEvidenceDispatch.allowed, true);
+assert.equal(newEvidenceDispatch.newEvidence, true);
+assert.equal(newEvidenceDispatch.dispatchAction, 'run_evidence_probe');
+
+const stillParked = decideResolveIOAIManagerRecoveryGate({
+	checkpoint: parkedCheckpoint,
+	current: {
+		lane: 'repair',
+		stepType: 'repair',
+		failureClass: 'product_code',
+		blocker: 'Save action still throws TypeError.',
+		evidenceHash: 'save-typeerror-before',
+		artifactPaths: ['qa/save-before.log']
+	}
+});
+
+assert.equal(stillParked.action, 'collect_new_evidence');
+assert.equal(stillParked.shouldResetLoopBudget, false);
+assert.equal(stillParked.canRunProductRepair, false);
+
+const runnerSpecificFingerprintCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint({
+	plan: parkedPlan,
+	current: {
+		lane: 'repair',
+		stepType: 'repair',
+		failureClass: 'product_code',
+		blocker: 'Save action still throws TypeError.',
+		blockerFingerprint: 'aicoder-v6-runner-specific',
+		evidenceHash: 'save-typeerror-before',
+		artifactPaths: ['qa/save-before.log']
+	},
+	now: '2026-06-15T00:00:00.000Z'
+});
+const runnerSpecificStillParked = decideResolveIOAIManagerRecoveryGate({
+	checkpoint: runnerSpecificFingerprintCheckpoint,
+	current: {
+		lane: 'repair',
+		stepType: 'repair',
+		failureClass: 'product_code',
+		blocker: 'Save action still throws TypeError.',
+		evidenceHash: 'save-typeerror-before',
+		artifactPaths: ['qa/save-before.log']
+	}
+});
+
+assert.equal(runnerSpecificStillParked.action, 'collect_new_evidence');
+assert.equal(runnerSpecificStillParked.newEvidence, false);
+assert.equal(runnerSpecificStillParked.canRunProductRepair, false);
+
+const noCurrentStillParked = decideResolveIOAIManagerRecoveryGate({
+	checkpoint: runnerSpecificFingerprintCheckpoint
+});
+
+assert.equal(noCurrentStillParked.action, 'collect_new_evidence');
+assert.equal(noCurrentStillParked.newEvidence, false);
+
+const blindRepairRejected = decideResolveIOAIManagerRecoveryGate({
+	checkpoint: parkedCheckpoint,
+	proposedAction: 'targeted_product_repair',
+	current: {
+		lane: 'repair',
+		stepType: 'repair',
+		failureClass: 'product_code',
+		blocker: 'Save action still throws TypeError.',
+		evidenceHash: 'save-typeerror-before',
+		artifactPaths: ['qa/save-before.log']
+	}
+});
+
+assert.equal(blindRepairRejected.action, 'reject_action');
+assert.equal(blindRepairRejected.reason, 'recovery_gate_product_repair_not_allowed_for_checkpoint');
+
+const newEvidenceUnblocks = decideResolveIOAIManagerRecoveryGate({
+	checkpoint: parkedCheckpoint,
+	current: {
+		lane: 'repair',
+		stepType: 'repair',
+		failureClass: 'product_code',
+		blocker: 'Save action still throws TypeError.',
+		evidenceHash: 'save-typeerror-after-dom-trace',
+		artifactPaths: ['qa/save-before.log', 'qa/save-after-dom-trace.json']
+	}
+});
+
+assert.equal(newEvidenceUnblocks.action, 'allow');
+assert.equal(newEvidenceUnblocks.reason, 'recovery_gate_new_evidence_unblocks_retry');
+assert.equal(newEvidenceUnblocks.shouldResetLoopBudget, true);
+assert.equal(newEvidenceUnblocks.canRunProductRepair, true);
+assert.equal(newEvidenceUnblocks.newEvidence, true);
+
+const infraPlan = buildResolveIOAIManagerRecoveryPlan({
+	action: 'retry_infra',
+	reason: 'puppeteer missing',
+	failureClass: 'infra',
+	lane: 'qa',
+	stepType: 'workflow_qa',
+	blocker: 'Chrome executable missing.'
+});
+const infraCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint({
+	plan: infraPlan,
+	current: {
+		lane: 'qa',
+		stepType: 'workflow_qa',
+		failureClass: 'infra',
+		blocker: 'Chrome executable missing.',
+		evidenceHash: 'chrome-missing'
+	}
+});
+const productRepairOnInfra = decideResolveIOAIManagerRecoveryGate({
+	checkpoint: infraCheckpoint,
+	proposedAction: 'targeted_product_repair',
+	current: {
+		lane: 'qa',
+		stepType: 'workflow_qa',
+		failureClass: 'infra',
+		blocker: 'Chrome executable missing.',
+		evidenceHash: 'chrome-missing'
+	}
+});
+
+assert.equal(productRepairOnInfra.action, 'reject_action');
+assert.equal(productRepairOnInfra.canRunProductRepair, false);
+
+const infraEvidenceProbe = buildResolveIOAIManagerRecoveryEvidenceProbe({
+	checkpoint: infraCheckpoint
+});
+const infraAction = buildResolveIOAIManagerRecoveryActionPacket({
+	checkpoint: infraCheckpoint,
+	probe: infraEvidenceProbe
+});
+
+assert.equal(infraEvidenceProbe.evidenceOnly, true);
+assert.ok(infraEvidenceProbe.steps.some((step) => step.kind === 'infra_preflight'));
+assert.ok(infraEvidenceProbe.requiredArtifacts.some((entry) => /infra-preflight/i.test(entry)));
+assert.equal(infraAction.mode, 'repair_infra');
+assert.equal(infraAction.autoRunnable, true);
+assert.equal(infraAction.productRepairAllowed, false);
+
+const budgetPlan = buildResolveIOAIManagerRecoveryPlan({
+	action: 'budget_stop',
+	reason: 'hard budget guard',
+	failureClass: 'product_code',
+	lane: 'build',
+	stepType: 'build'
+});
+const budgetCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint({
+	plan: budgetPlan,
+	current: {
+		lane: 'build',
+		stepType: 'build',
+		failureClass: 'product_code',
+		blocker: 'Budget guard tripped.',
+		evidenceHash: 'budget-stop'
+	}
+});
+
+assert.equal(decideResolveIOAIManagerRecoveryGate({
+	checkpoint: budgetCheckpoint
+}).action, 'manual_handoff');
+assert.equal(decideResolveIOAIManagerRecoveryGate({
+	checkpoint: budgetCheckpoint,
+	operatorApproved: true
+}).action, 'allow');
+
+console.log('ai manager recovery checkpoint tests passed');

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

@@ -0,0 +1,88 @@
+import * as assert from 'node:assert/strict';
+import {
+	AI_RUN_SEED_EVAL_FIXTURES,
+	buildAIRunDatasetExport,
+	buildAIRunTrainingExampleFromRun,
+	classifyAIRunFailureClass,
+	decideAIRunRetry,
+	evaluateAIRunFixtures
+} from '../src/util/ai-run-evidence-eval';
+import {
+	buildAIRunFalsePassWarnings,
+	buildAIRunOperatorView,
+	buildAIRunQaHealth,
+	buildAIRunTimeline
+} from '../src/util/ai-run-evidence-dashboard';
+
+const summary = evaluateAIRunFixtures();
+assert.equal(summary.passed, true);
+assert.equal(summary.failedCount, 0);
+assert.equal(summary.total, AI_RUN_SEED_EVAL_FIXTURES.length);
+assert.equal(summary.outcomes.accepted, 2);
+assert.ok(summary.outcomes.false_pass >= 2);
+assert.ok(summary.outcomes.qa_infra_failed >= 2);
+assert.ok(summary.outcomes.release_blocked >= 2);
+
+const routeOnlyFixture = AI_RUN_SEED_EVAL_FIXTURES.find((fixture) => fixture.id === 'qa-route-only-pass');
+assert.ok(routeOnlyFixture);
+assert.equal(routeOnlyFixture.run.outcome, 'false_pass');
+assert.equal(classifyAIRunFailureClass(routeOnlyFixture.run), 'false_pass');
+
+const repeatedRouteOnlyDecision = decideAIRunRetry({
+	currentRun: routeOnlyFixture.run,
+	previousRun: routeOnlyFixture.run,
+	newEvidenceCount: 0,
+	sameFailureCount: 2,
+	unchangedFailureLimit: 2
+});
+assert.equal(repeatedRouteOnlyDecision.action, 'stop');
+assert.equal(repeatedRouteOnlyDecision.repeatedFailure, true);
+
+const puppeteerFixture = AI_RUN_SEED_EVAL_FIXTURES.find((fixture) => fixture.id === 'qa-missing-puppeteer');
+assert.ok(puppeteerFixture);
+const infraDecision = decideAIRunRetry({
+	currentRun: puppeteerFixture.run,
+	newEvidenceCount: 1
+});
+assert.equal(infraDecision.action, 'retry_infra_repair');
+assert.equal(infraDecision.failureClass, 'infra');
+
+const layflatFixture = AI_RUN_SEED_EVAL_FIXTURES.find((fixture) => fixture.id === 'aicoder-layflat-pressure-optimizer');
+assert.ok(layflatFixture);
+const releaseDecision = decideAIRunRetry({
+	currentRun: layflatFixture.run,
+	newEvidenceCount: 1
+});
+assert.equal(releaseDecision.action, 'retry_release_repair');
+
+const example = buildAIRunTrainingExampleFromRun(routeOnlyFixture.run);
+assert.equal(example.outcome, 'false_pass');
+assert.match(example.actionSummary, /failureClass=false_pass/);
+assert.ok(example.evidence.some((entry) => /business/i.test(entry)));
+
+const routeOnlyTimeline = buildAIRunTimeline(routeOnlyFixture.run);
+assert.ok(routeOnlyTimeline.some((entry) => entry.type === 'qa_route_probe'));
+assert.ok(routeOnlyTimeline.some((entry) => entry.type === 'gate' && entry.status === 'blocked'));
+const routeOnlyHealth = buildAIRunQaHealth(routeOnlyFixture.run);
+assert.equal(routeOnlyHealth.business.missing, true);
+assert.equal(routeOnlyHealth.route.pass, 1);
+assert.ok(buildAIRunFalsePassWarnings(routeOnlyFixture.run).includes('false_pass_outcome'));
+const routeOnlyOperatorView = buildAIRunOperatorView(routeOnlyFixture.run);
+assert.equal(routeOnlyOperatorView.failureClass, 'false_pass');
+assert.equal(routeOnlyOperatorView.costPanel.totalTokens, 0);
+assert.equal(routeOnlyOperatorView.trainingExample.outcome, 'false_pass');
+
+const exportPayload = buildAIRunDatasetExport(AI_RUN_SEED_EVAL_FIXTURES.map((fixture) => fixture.run), {
+	includeRuns: false,
+	redact: true,
+	now: '2026-06-13T00:00:00.000Z'
+});
+assert.equal(exportPayload.generatedAt, '2026-06-13T00:00:00.000Z');
+assert.equal(exportPayload.runs.length, 0);
+assert.equal(exportPayload.trainingExamples.length, AI_RUN_SEED_EVAL_FIXTURES.length);
+assert.equal(exportPayload.summary.byFailureClass.false_pass, 2);
+assert.equal(exportPayload.summary.bySource.support_ticket, 6);
+assert.equal(exportPayload.summary.bySource.aicoder_app, 2);
+assert.equal(exportPayload.summary.bySource.ai_assistant, 2);
+
+console.log('ai run eval tests passed');