@resolveio/server-lib 22.3.150 → 22.3.151

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

@@ -1,488 +0,0 @@
-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

@@ -1,34 +0,0 @@
-{
-  "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"
-  ]
-}