@resolveio/server-lib 22.3.148 → 22.3.150

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

@@ -0,0 +1,488 @@
+import * as assert from 'node:assert/strict';
+import {
+	buildResolveIOSupportIssueClassProbes,
+	buildResolveIOSupportV5MicrotaskPrompt,
+	buildResolveIOSupportV5DiagnoseFirstPrompt,
+	buildResolveIOSupportV5Incident,
+	buildResolveIOSupportV5PromptBudget,
+	buildResolveIOSupportV5ScopeDigest,
+	changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles,
+	decideResolveIOSupportV5RepairGate,
+	decideResolveIOSupportV5RepeatedFailureStop,
+	decideResolveIOSupportV5Continuation,
+	extractResolveIOSupportDiagnosisGateFromText,
+	fingerprintResolveIOSupportV5Blocker,
+	initializeResolveIOSupportV5State,
+	recordResolveIOSupportV5MicrotaskUsage,
+	recordResolveIOSupportV5Step,
+	selectResolveIOSupportV5ActiveMicrotask,
+	summarizeResolveIOSupportV5MicrotaskUsage,
+	validateResolveIOSupportDiagnosisGate
+} from '../src/util/support-runner-v5';
+
+const initialized = initializeResolveIOSupportV5State({
+	jobId: 'job-1',
+	ticketId: 'ticket-1',
+	ticketNumber: '004999',
+	title: 'Support ticket #004999',
+	description: 'Fix BOL driver display and QA it.',
+	approvedScopeRequirements: ['BOL driver display', 'disabled driver canonical rejection'],
+	prBranch: 'feature/support-004999',
+	buildThreadKey: 'support:ticket-1:job:job-1:build',
+	qaThreadKey: 'support:ticket-1:job:job-1:qa',
+	now: '2026-06-06T00:00:00.000Z'
+});
+
+assert.equal(initialized.supportWorkflowVersion, 'v5');
+assert.equal(initialized.supportV5SupervisorState.noEmailUnlessApproved, true);
+assert.equal(initialized.supportV5LaneMemory.build.model, 'gpt-5.3-codex');
+assert.equal(initialized.supportV5LaneMemory.qa.model, 'gpt-5.4-mini');
+assert.equal(initialized.supportV5LaneMemory.build.threadKey, 'support:ticket-1:job:job-1:build');
+assert.match(initialized.supportV5SupervisorState.approvedScope, /BOL driver display/);
+assert.ok(initialized.supportV5MicrotaskLedger.length >= 4);
+assert.equal(initialized.supportV5MicrotaskLedger[0].type, 'diagnosis_gate');
+assert.equal(initialized.supportV5MicrotaskLedger[0].lane, 'build');
+assert.equal(initialized.supportV5MicrotaskLedger[1].lane, 'build');
+assert.equal(initialized.supportV5MicrotaskLedger[2].lane, 'qa');
+assert.equal(initialized.supportV5MicrotaskLedger[0].threadKey, 'support:ticket-1:job:job-1:build');
+assert.equal(initialized.supportV5MicrotaskLedger[2].threadKey, 'support:ticket-1:job:job-1:qa');
+assert.equal(initialized.supportV5ActiveMicrotaskId, initialized.supportV5MicrotaskLedger[0].microtaskId);
+assert.equal(selectResolveIOSupportV5ActiveMicrotask(initialized.supportV5MicrotaskLedger)?.type, 'diagnosis_gate');
+assert.match(initialized.supportV5ScopeDigest || '', /Approved scope/);
+assert.equal(validateResolveIOSupportDiagnosisGate(initialized.supportV5DiagnosisGate).valid, false);
+assert.deepEqual(initialized.supportV5RecoveryDispatchHistory, []);
+assert.equal(initialized.supportV5RecoveryDirective, undefined);
+
+const validDiagnosis = {
+	issue_case: {
+		customer_complaint: 'Disabled drivers appear in the BOL driver dropdown.',
+		expected_result: 'Disabled drivers are excluded or rejected.',
+		observed_result: 'Disabled driver can be selected.',
+		route_module: '/dashboard/driver/truck-treating/bol-detail/bol/route',
+		account_customer_context: '004999 reporter, truck treating route fixture',
+		reproduction_status: 'reproduced' as const
+	},
+	issue_class: 'filter_query_mismatch' as const,
+	accepted_hypothesis: {
+		statement: 'The driver dropdown publication does not filter disabled users.',
+		falsifiable_test: 'Inspect the publication/method query and run the dropdown with a disabled driver fixture.',
+		evidence: ['Ticket names disabled driver selection.', 'Publication path returns drivers without active filter.']
+	},
+	rejected_alternatives: ['Route auth failure rejected because the BOL page hydrates.', 'Pure CSS issue rejected because persisted selected id changes.'],
+	failing_path: {
+		frontend: 'geochem/angular/app/bol/new/bol-new.component.ts driver select',
+		backend: 'geochem/server/src/publications/drivers.ts',
+		description: 'Frontend driver select consumes an unfiltered backend driver list.'
+	},
+	owner_files: [
+		'geochem/angular/app/bol/new/bol-new.component.ts',
+		'geochem/server/src/publications/drivers.ts'
+	],
+	proof_plan: {
+		before: 'Seed/identify a disabled driver available to the BOL route.',
+		action: 'Open the BOL route, open the driver dropdown, and attempt selecting the disabled driver.',
+		after: 'Disabled driver is absent or rejected and the active driver remains selected.',
+		business_assertion: 'Disabled driver cannot replace the selected active driver.',
+		route: '/dashboard/driver/truck-treating/bol-detail/bol/route',
+		data_assertion: 'Persisted BOL driver id remains active after save attempt.',
+		business_proof_contract: {
+			issue_class: 'filter_query_mismatch' as const,
+			setup_state: 'A BOL route has one active driver and one disabled driver in the candidate dataset.',
+			action_under_test: 'Open the driver dropdown and attempt to choose the disabled driver.',
+			expected_business_state_change: 'The disabled driver is excluded or rejected while the active driver remains selected.',
+			prohibited_false_pass: 'Route load, screenshot visibility, or a populated dropdown alone is not acceptance.',
+			proof_artifacts: ['browser trace', 'dropdown DOM snapshot', 'persisted BOL driver id check'],
+			data_or_dom_assertion: 'The disabled driver option is absent or blocked and the saved BOL driver id remains active.'
+		}
+	},
+	evidence: [{ type: 'code' as const, summary: 'Publication lacks disabled-user filter.' }],
+	status: 'passed' as const
+};
+
+const validDiagnosisResult = validateResolveIOSupportDiagnosisGate(validDiagnosis);
+assert.equal(validDiagnosisResult.valid, true);
+assert.equal(validDiagnosisResult.normalized?.status, 'passed');
+assert.equal(buildResolveIOSupportIssueClassProbes(validDiagnosis)[0].issue_class, 'filter_query_mismatch');
+assert.match(buildResolveIOSupportIssueClassProbes(validDiagnosis)[0].expected_evidence, /dropdown DOM snapshot/);
+
+const blockedDiagnosis = validateResolveIOSupportDiagnosisGate({
+	...validDiagnosis,
+	accepted_hypothesis: { statement: '', falsifiable_test: '', evidence: [] },
+	owner_files: ['geochem/angular/app']
+});
+assert.equal(blockedDiagnosis.valid, false);
+assert.ok(blockedDiagnosis.blockers.some((blocker) => /accepted_hypothesis\.statement/.test(blocker)));
+assert.ok(blockedDiagnosis.blockers.some((blocker) => /broad or unsafe/.test(blocker)));
+
+const routeOnlyDiagnosis = validateResolveIOSupportDiagnosisGate({
+	...validDiagnosis,
+	proof_plan: {
+		before: 'The affected route is available.',
+		action: 'Open the support ticket route.',
+		after: 'The page loads and is visible.',
+		business_assertion: 'The route loads and the page is visible.',
+		route: '/support'
+	}
+});
+assert.equal(routeOnlyDiagnosis.valid, false);
+assert.ok(routeOnlyDiagnosis.blockers.some((blocker) => /route-load|screenshot-only|business state/i.test(blocker)));
+
+const missingProofContractDiagnosis = validateResolveIOSupportDiagnosisGate({
+	...validDiagnosis,
+	proof_plan: {
+		...validDiagnosis.proof_plan,
+		business_proof_contract: undefined
+	}
+});
+assert.equal(missingProofContractDiagnosis.valid, false);
+assert.ok(missingProofContractDiagnosis.blockers.some((blocker) => /business_proof_contract is required/.test(blocker)));
+
+const mismatchedProofContractDiagnosis = validateResolveIOSupportDiagnosisGate({
+	...validDiagnosis,
+	proof_plan: {
+		...validDiagnosis.proof_plan,
+		business_proof_contract: {
+			...validDiagnosis.proof_plan.business_proof_contract,
+			issue_class: 'upload_import' as const
+		}
+	}
+});
+assert.equal(mismatchedProofContractDiagnosis.valid, false);
+assert.ok(mismatchedProofContractDiagnosis.blockers.some((blocker) => /must match diagnosis issue_class/.test(blocker)));
+
+const diagnosisJson = JSON.stringify({ support_diagnosis_gate: validDiagnosis });
+assert.equal(extractResolveIOSupportDiagnosisGateFromText(`\`\`\`json\n${diagnosisJson}\n\`\`\``)?.issue_class, 'filter_query_mismatch');
+
+const diagnosedBundle = recordResolveIOSupportV5Step(initialized, {
+	stepType: 'diagnosis_gate',
+	outcome: 'pass',
+	lane: 'build',
+	summary: diagnosisJson,
+	diagnosisGate: validDiagnosis,
+	now: '2026-06-06T00:00:30.000Z'
+});
+assert.equal(diagnosedBundle.supportV5DiagnosisGate?.status, 'passed');
+assert.deepEqual(diagnosedBundle.supportV5MicrotaskLedger[1].targetFiles, validDiagnosis.owner_files);
+assert.equal(diagnosedBundle.supportV5LaneMemory.qa.activeQaRow?.workflow, validDiagnosis.proof_plan.business_proof_contract.action_under_test);
+assert.equal(diagnosedBundle.supportV5LaneMemory.qa.activeQaRow?.assertion, validDiagnosis.proof_plan.business_proof_contract.data_or_dom_assertion);
+assert.equal(diagnosedBundle.supportV5RecoveryPlan?.recoveryClass, 'advance_after_proof');
+assert.equal(diagnosedBundle.supportV5RecoveryCheckpoint?.recoveryClass, 'advance_after_proof');
+assert.equal(diagnosedBundle.supportV5RecoveryAction?.checkpointId, diagnosedBundle.supportV5RecoveryCheckpoint?.checkpointId);
+const diagnosisMicrotaskId = diagnosedBundle.supportV5MicrotaskLedger.find((task) => task.type === 'diagnosis_gate')?.microtaskId;
+const buildMicrotasksAfterDiagnosis = diagnosedBundle.supportV5MicrotaskLedger.filter((task) => task.lane === 'build' && task.type !== 'diagnosis_gate');
+assert.ok(diagnosisMicrotaskId);
+assert.ok(buildMicrotasksAfterDiagnosis.length > 0);
+assert.ok(buildMicrotasksAfterDiagnosis.every((task) => task.dependsOn.includes(diagnosisMicrotaskId || '')));
+assert.ok(buildMicrotasksAfterDiagnosis.every((task) => task.dependsOn.length === new Set(task.dependsOn).size));
+assert.equal(changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles(validDiagnosis, [
+	'geochem/angular/app/bol/new/bol-new.component.ts',
+	'geochem/server/src/methods/unrelated.ts'
+]).length, 1);
+const missingDiagnosisRepairGate = decideResolveIOSupportV5RepairGate({
+	diagnosisGate: undefined,
+	activeStepType: 'build_repair'
+});
+assert.equal(missingDiagnosisRepairGate.action, 'diagnose_only');
+assert.equal(missingDiagnosisRepairGate.recoveryPlan.recoveryClass, 'diagnosis_only');
+assert.equal(missingDiagnosisRepairGate.recoveryPlan.productRepairAllowed, false);
+assert.ok(missingDiagnosisRepairGate.recoveryPlan.requiredEvidence.includes('accepted_hypothesis'));
+assert.equal(missingDiagnosisRepairGate.recoveryCheckpoint.recoveryClass, 'diagnosis_only');
+assert.equal(missingDiagnosisRepairGate.recoveryCheckpoint.productRepairAllowed, false);
+const allowedRepairGate = decideResolveIOSupportV5RepairGate({
+	diagnosisGate: validDiagnosis,
+	activeStepType: 'build_repair',
+	changedFiles: ['geochem/angular/app/bol/new/bol-new.component.ts']
+});
+assert.equal(allowedRepairGate.action, 'allow_product_repair');
+assert.equal(allowedRepairGate.recoveryPlan.recoveryClass, 'product_code_repair');
+assert.equal(allowedRepairGate.recoveryPlan.productRepairAllowed, true);
+assert.equal(allowedRepairGate.recoveryCheckpoint.recoveryClass, 'product_code_repair');
+assert.equal(allowedRepairGate.recoveryCheckpoint.productRepairAllowed, true);
+const outOfScopeRepairGate = decideResolveIOSupportV5RepairGate({
+	diagnosisGate: validDiagnosis,
+	activeStepType: 'build_repair',
+	changedFiles: ['geochem/server/src/methods/unrelated.ts']
+});
+assert.equal(outOfScopeRepairGate.action, 'reject_out_of_scope');
+assert.equal(outOfScopeRepairGate.recoveryPlan.recoveryClass, 'diagnosis_revision');
+assert.ok(outOfScopeRepairGate.recoveryPlan.forbiddenActions.some((action) => /outside owner_files/.test(action)));
+const infraRepairGate = decideResolveIOSupportV5RepairGate({
+	diagnosisGate: validDiagnosis,
+	activeStepType: 'build_repair',
+	failureClass: 'infra',
+	blocker: 'Puppeteer failed to launch.'
+});
+assert.equal(infraRepairGate.action, 'infra_repair_only');
+assert.equal(infraRepairGate.recoveryPlan.recoveryClass, 'infra_repair');
+assert.equal(infraRepairGate.recoveryPlan.expensiveModelAllowed, false);
+assert.ok(infraRepairGate.recoveryPlan.forbiddenActions.some((action) => /product-code model repair/.test(action)));
+assert.equal(infraRepairGate.recoveryCheckpoint.recoveryClass, 'infra_repair');
+assert.equal(infraRepairGate.recoveryCheckpoint.productRepairAllowed, false);
+const repeatedRepairGate = decideResolveIOSupportV5RepairGate({
+	diagnosisGate: validDiagnosis,
+	activeStepType: 'build_repair',
+	failureClass: 'product_code',
+	blocker: 'same blocker',
+	evidenceHash: 'same',
+	history: [
+		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'same', recordedAt: '1' },
+		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'same', recordedAt: '2' }
+	],
+	maxRepeatedNoProgress: 2
+});
+assert.equal(repeatedRepairGate.action, 'park_repeated_failure');
+assert.equal(repeatedRepairGate.recoveryPlan.recoveryClass, 'blocked_until_new_evidence');
+assert.ok(repeatedRepairGate.recoveryPlan.loopResetEvidence.some((evidence) => /changed evidence hash/.test(evidence)));
+assert.equal(repeatedRepairGate.recoveryCheckpoint.status, 'parked');
+assert.equal(repeatedRepairGate.recoveryCheckpoint.allowedAction, 'collect_new_evidence_only');
+assert.equal(repeatedRepairGate.recoveryEvidenceProbe.evidenceOnly, true);
+assert.equal(repeatedRepairGate.recoveryEvidenceProbe.productRepairAllowed, false);
+assert.ok(repeatedRepairGate.recoveryEvidenceProbe.steps.some((step) => step.kind === 'rerun_same_gate'));
+assert.equal(repeatedRepairGate.recoveryAction.mode, 'collect_evidence');
+assert.equal(repeatedRepairGate.recoveryAction.productRepairAllowed, false);
+assert.equal(repeatedRepairGate.recoveryAction.retryPolicy.requireNewEvidence, true);
+
+const withFailure = recordResolveIOSupportV5Step(initialized, {
+	stepType: 'qa_row',
+	outcome: 'needs_repair',
+	lane: 'qa',
+	model: 'gpt-5.4-mini',
+	threadKey: 'support:ticket-1:job:job-1:qa',
+	promptTokenEstimate: 1200,
+	runtimeMs: 45000,
+	summary: 'Row 2 failed.',
+	blocker: 'Screenshot shell-only for row 2',
+	artifactPaths: ['qa-artifacts/row-2.jpg'],
+	activeQaRow: {
+		index: 2,
+		workflow: 'Disabled driver cannot replace selected active driver',
+		route: '/dashboard/driver/truck-treating/bol-detail/bol/route',
+		status: 'failed'
+	},
+	now: '2026-06-06T00:01:00.000Z'
+});
+
+assert.equal(withFailure.supportV5StepHistory.length, 1);
+assert.equal(withFailure.supportV5Budget.loopCount, 1);
+assert.equal(withFailure.supportV5LaneMemory.qa.activeBlocker, 'Screenshot shell-only for row 2');
+assert.equal(withFailure.supportV5SupervisorState.currentQaRow?.index, 2);
+assert.deepEqual(decideResolveIOSupportV5Continuation(withFailure).action, 'continue');
+
+let repeated = withFailure;
+repeated = recordResolveIOSupportV5Step(repeated, {
+	stepType: 'qa_row',
+	outcome: 'needs_repair',
+	lane: 'qa',
+	blocker: 'Screenshot shell-only for row 2',
+	summary: 'Still shell-only.',
+	now: '2026-06-06T00:02:00.000Z'
+});
+repeated = recordResolveIOSupportV5Step(repeated, {
+	stepType: 'qa_row',
+	outcome: 'needs_repair',
+	lane: 'qa',
+	blocker: 'Screenshot shell-only for row 2',
+	summary: 'Still shell-only again.',
+	now: '2026-06-06T00:03:00.000Z'
+});
+
+const repeatedDecision = decideResolveIOSupportV5Continuation(repeated);
+assert.equal(repeatedDecision.action, 'park');
+assert.equal(repeatedDecision.reason, 'support_v5_repeated_no_progress');
+assert.equal(repeatedDecision.recoveryPlan.recoveryClass, 'blocked_until_new_evidence');
+assert.equal(repeatedDecision.recoveryPlan.allowedAction, 'collect_new_evidence_only');
+assert.equal(repeatedDecision.recoveryCheckpoint.status, 'parked');
+assert.equal(repeatedDecision.recoveryCheckpoint.allowedAction, 'collect_new_evidence_only');
+assert.equal(repeatedDecision.recoveryEvidenceProbe.evidenceOnly, true);
+assert.equal(repeatedDecision.recoveryEvidenceProbe.productRepairAllowed, false);
+assert.ok(repeatedDecision.recoveryEvidenceProbe.acceptanceEvidence.some((evidence) => /changed evidence hash|new artifact path/i.test(evidence)));
+assert.equal(repeatedDecision.recoveryAction.mode, 'collect_evidence');
+assert.equal(repeatedDecision.recoveryAction.retryPolicy.requireNewEvidence, true);
+assert.ok(repeatedDecision.recoveryAction.requiredArtifacts.length > 0);
+
+const repeatedProductFailure = decideResolveIOSupportV5RepeatedFailureStop({
+	history: [
+		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'same', recordedAt: '1' },
+		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'same', recordedAt: '2' }
+	],
+	failureClass: 'product_code',
+	blocker: 'same blocker',
+	evidenceHash: 'same',
+	limit: 2
+});
+assert.equal(repeatedProductFailure.shouldStop, true);
+const repeatedInfraFailure = decideResolveIOSupportV5RepeatedFailureStop({
+	history: [
+		{ stepType: 'compile_check', outcome: 'needs_repair', lane: 'build', summary: 'same', failureClass: 'infra', blocker: 'puppeteer missing', evidenceHash: 'same', recordedAt: '1' }
+	],
+	failureClass: 'infra',
+	blocker: 'puppeteer missing',
+	evidenceHash: 'same',
+	limit: 1
+});
+assert.equal(repeatedInfraFailure.shouldStop, false);
+
+let repeatedInfraBundle = diagnosedBundle;
+repeatedInfraBundle = recordResolveIOSupportV5Step(repeatedInfraBundle, {
+	stepType: 'compile_check',
+	outcome: 'needs_repair',
+	lane: 'build',
+	failureClass: 'infra',
+	blocker: 'Puppeteer executable missing.',
+	evidenceHash: 'same-infra',
+	now: '2026-06-06T00:03:10.000Z'
+});
+repeatedInfraBundle = recordResolveIOSupportV5Step(repeatedInfraBundle, {
+	stepType: 'compile_check',
+	outcome: 'needs_repair',
+	lane: 'build',
+	failureClass: 'infra',
+	blocker: 'Puppeteer executable missing.',
+	evidenceHash: 'same-infra',
+	now: '2026-06-06T00:03:20.000Z'
+});
+repeatedInfraBundle = recordResolveIOSupportV5Step(repeatedInfraBundle, {
+	stepType: 'compile_check',
+	outcome: 'needs_repair',
+	lane: 'build',
+	failureClass: 'infra',
+	blocker: 'Puppeteer executable missing.',
+	evidenceHash: 'same-infra',
+	now: '2026-06-06T00:03:30.000Z'
+});
+const repeatedInfraContinuation = decideResolveIOSupportV5Continuation(repeatedInfraBundle);
+assert.equal(repeatedInfraContinuation.action, 'continue');
+assert.equal(repeatedInfraContinuation.reason, 'support_v5_infra_or_compile_repair_required');
+assert.equal(repeatedInfraContinuation.recoveryPlan.recoveryClass, 'infra_repair');
+assert.equal(repeatedInfraContinuation.recoveryPlan.productRepairAllowed, false);
+
+const sameBlockerNewEvidence = decideResolveIOSupportV5RepeatedFailureStop({
+	history: [
+		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same root issue', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'before-fix-log', recordedAt: '1' },
+		{ stepType: 'build_repair', outcome: 'needs_repair', lane: 'build', summary: 'same root issue', failureClass: 'product_code', blocker: 'same blocker', evidenceHash: 'after-targeted-fix-log', recordedAt: '2' }
+	],
+	failureClass: 'product_code',
+	blocker: 'same blocker',
+	evidenceHash: 'after-targeted-fix-log',
+	limit: 2
+});
+assert.equal(sameBlockerNewEvidence.shouldStop, false);
+
+const pingPongFailure = decideResolveIOSupportV5RepeatedFailureStop({
+	history: [
+		{ stepType: 'qa_row', outcome: 'needs_repair', lane: 'qa', summary: 'Filter excludes active customers', failureClass: 'business', blocker: 'Filter excludes active customers', evidenceHash: 'a', recordedAt: '1' },
+		{ stepType: 'qa_row', outcome: 'needs_repair', lane: 'qa', summary: 'Filter includes inactive customers', failureClass: 'business', blocker: 'Filter includes inactive customers', evidenceHash: 'b', recordedAt: '2' },
+		{ stepType: 'qa_row', outcome: 'needs_repair', lane: 'qa', summary: 'Filter excludes active customers', failureClass: 'business', blocker: 'Filter excludes active customers', evidenceHash: 'a', recordedAt: '3' },
+		{ stepType: 'qa_row', outcome: 'needs_repair', lane: 'qa', summary: 'Filter includes inactive customers', failureClass: 'business', blocker: 'Filter includes inactive customers', evidenceHash: 'b', recordedAt: '4' }
+	],
+	failureClass: 'business',
+	blocker: 'Filter includes inactive customers',
+	evidenceHash: 'b',
+	limit: 3
+});
+assert.equal(pingPongFailure.shouldStop, true);
+assert.equal(pingPongFailure.reason, 'support_v5_ping_pong_failure_loop');
+
+const budgeted = recordResolveIOSupportV5Step(initialized, {
+	stepType: 'build_repair',
+	outcome: 'needs_repair',
+	lane: 'build',
+	promptTokenEstimate: 1900,
+	blocker: 'Prompt was too broad for a repair step.',
+	now: '2026-06-06T00:04:00.000Z'
+});
+assert.equal(decideResolveIOSupportV5Continuation(budgeted).reason, 'support_v5_budget_guard');
+assert.equal(decideResolveIOSupportV5Continuation(budgeted).recoveryPlan.recoveryClass, 'manual_handoff');
+
+const prompt = buildResolveIOSupportV5DiagnoseFirstPrompt({
+	goal: initialized.supportV5SupervisorState.currentGoal,
+	activeStep: 'qa_row',
+	activeBlocker: 'Route failed to hydrate.',
+	lane: 'qa',
+	currentQaRow: withFailure.supportV5SupervisorState.currentQaRow,
+	artifactPaths: ['qa-artifacts/client.log'],
+	changedFiles: ['geochem/angular/app/bol/new/bol-new.component.ts']
+}).join('\n');
+
+assert.match(prompt, /Diagnose First/);
+assert.match(prompt, /Do not send customer email/);
+assert.match(prompt, /Current QA row/);
+assert.match(prompt, /geochem\/angular\/app\/bol\/new\/bol-new\.component\.ts/);
+
+assert.equal(
+	fingerprintResolveIOSupportV5Blocker('Line 123 failed for 6a239cd7d67a2b24b36f3dfe'),
+	fingerprintResolveIOSupportV5Blocker('Line 456 failed for abcdefabcdefabcdef')
+);
+
+const incident = buildResolveIOSupportV5Incident({
+	incidentClass: 'false_screenshot_rejection',
+	summary: 'Sparse but valid BOL detail screen was rejected by file-size gate.',
+	stepType: 'artifact_package',
+	blocker: 'screenshot shell-only',
+	artifactPaths: ['qa-artifacts/row-2.jpg'],
+	now: '2026-06-06T00:05:00.000Z'
+});
+assert.equal(incident.incidentClass, 'false_screenshot_rejection');
+assert.ok(incident.blockerFingerprint);
+
+const microtaskPrompt = buildResolveIOSupportV5MicrotaskPrompt({
+	bundle: diagnosedBundle,
+	lane: 'build',
+	stage: 'support-autonomous-owner',
+	failureText: 'QA row failed because the driver dropdown still includes disabled drivers.',
+	changedFiles: ['geochem/angular/app/bol/new/bol-new.component.ts'],
+	contextSnippets: ['Workspace root: /var/ai-workspace/job-1', 'Project root: geochem']
+});
+assert.equal(microtaskPrompt.activeMicrotask?.lane, 'build');
+assert.equal(microtaskPrompt.withinHardCap, true);
+assert.ok(microtaskPrompt.promptTokenEstimate <= buildResolveIOSupportV5PromptBudget().buildMicrotaskHardCap);
+assert.match(microtaskPrompt.prompt, /Microtask id:/);
+assert.match(microtaskPrompt.prompt, /persistent lane thread/);
+assert.match(microtaskPrompt.prompt, /Diagnosis issue class: filter_query_mismatch/);
+assert.doesNotMatch(microtaskPrompt.prompt, /Initial ticket context:/);
+assert.doesNotMatch(microtaskPrompt.prompt, /Staged support context:/);
+assert.doesNotMatch(microtaskPrompt.prompt, /BUILD_PLAN/);
+
+const qaPrompt = buildResolveIOSupportV5MicrotaskPrompt({
+	bundle: {
+		...diagnosedBundle,
+		supportV5ActiveMicrotaskId: diagnosedBundle.supportV5MicrotaskLedger.find((task) => task.lane === 'qa')?.microtaskId
+	},
+	lane: 'qa',
+	stage: 'support-qa-validation',
+	activeQaRow: {
+		index: 0,
+		workflow: 'BOL driver display',
+		route: '/dashboard/driver/truck-treating/bol-detail/bol/route',
+		assertion: 'Disabled driver is rejected',
+		status: 'pending'
+	}
+});
+assert.equal(qaPrompt.activeMicrotask?.lane, 'qa');
+assert.ok(qaPrompt.promptTokenEstimate <= buildResolveIOSupportV5PromptBudget().qaMicrotaskHardCap);
+assert.match(qaPrompt.prompt, /Return strict JSON only/);
+
+const usageBundle = recordResolveIOSupportV5MicrotaskUsage(initialized, {
+	microtaskId: initialized.supportV5MicrotaskLedger[0].microtaskId,
+	lane: 'build',
+	model: 'gpt-5.3-codex',
+	threadKey: initialized.supportV5LaneMemory.build.threadKey,
+	reuseThread: true,
+	promptTokenEstimate: microtaskPrompt.promptTokenEstimate,
+	promptSections: microtaskPrompt.promptSections,
+	outcome: 'pass'
+});
+const usageSummary = summarizeResolveIOSupportV5MicrotaskUsage(usageBundle);
+assert.equal(usageSummary.byMicrotask.length, 1);
+assert.ok(usageSummary.bySection.some((section) => section.name === 'active_microtask'));
+assert.equal(usageSummary.broadPromptViolations.length, 0);
+
+const digest = buildResolveIOSupportV5ScopeDigest({
+	goal: 'Resolve support ticket 004999',
+	approvedScope: ['A'.repeat(2000), 'B'.repeat(2000)],
+	prBranch: 'support-004999',
+	maxTokens: 200
+});
+assert.ok(digest.length <= 800);
+
+console.log('support runner v5 tests passed');

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "outDir": "./dist/out-tsc",
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true, 
+    "inlineSources": true, 
+    "baseUrl": ".",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "es5",
+    "skipLibCheck": true,
+    "stripInternal": true,
+    "noImplicitAny": false,
+    "downlevelIteration": true,
+    "typeRoots": [
+      "node_modules/@types"
+    ],
+    "lib": [
+      "es2017",
+      "dom"
+    ],
+    "noImplicitReturns": true
+  },
+  "include": [
+    "./**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/ai/assistant-core-heuristics.d.ts

@@ -1,11 +0,0 @@
-type AiAssistantCoreTermHint = {
-    terms: string[];
-    collections: string[];
-};
-export declare const AI_ASSISTANT_CORE_HEURISTICS: Readonly<{
-    version: 3;
-    collection_aliases: Record<string, string>;
-    collection_alias_options: Record<string, string[]>;
-    collection_term_hints: AiAssistantCoreTermHint[];
-}>;
-export {};